fix(web): pasted URLs and paths keep their underscores

apps/web/src/components/ComposerPromptEditorTiptap.input.browser.test.tsx

@@ -220,6 +220,61 @@ it("keeps unknown dollar names editable when restoring and pasting a draft", asy
   expect(serializeEditorDoc(editor.state.doc).value).toBe(value);
 });
 
+// regression: #25180 pasted plain text was re-read as Markdown and sent rewritten
+it.each([
+  {
+    name: "underscores in a URL and a path",
+    value: "",
+    caret: 1,
+    pasted: "Read https://example.com/_handle_/status/1 and open src/__test__.tsx",
+    expected: "Read https://example.com/_handle_/status/1 and open src/__test__.tsx",
+  },
+  {
+    name: "Markdown inside inline code",
+    value: "`xy`",
+    caret: 2,
+    pasted: "a_b_ **c**",
+    expected: "`xa_b_ **c**y`",
+  },
+  {
+    name: "bold markers inside a pasted code span",
+    value: "",
+    caret: 1,
+    pasted: "see `**x**` now",
+    expected: "see `**x**` now",
+  },
+])("sends pasted $name exactly as pasted", async ({ value, caret, pasted, expected }) => {
+  await using screen = await mountEditor(value);
+  const { editor } = screen;
+  await act(async () => {
+    editor.commands.setTextSelection(caret);
+    const clipboardData = new DataTransfer();
+    clipboardData.setData("text/plain", pasted);
+    editor.view.dom.dispatchEvent(new ClipboardEvent("paste", { clipboardData, cancelable: true }));
+  });
+  expect(serializeEditorDoc(editor.state.doc).value).toBe(expected);
+});
+
+// regression: #25180 a multiline or backtick paste into a code span serialized as a span the parser cannot rebuild
+it.each([" _a_\nb", "`__z__`"])(
+  "rebuilds a paste of %j into a code span unchanged",
+  async (pasted) => {
+    await using screen = await mountEditor("`xy`");
+    const { editor } = screen;
+    await act(async () => {
+      editor.commands.setTextSelection(2);
+      const clipboardData = new DataTransfer();
+      clipboardData.setData("text/plain", pasted);
+      editor.view.dom.dispatchEvent(
+        new ClipboardEvent("paste", { clipboardData, cancelable: true }),
+      );
+    });
+    const { value } = serializeEditorDoc(editor.state.doc);
+    await using rebuilt = await mountEditor(value);
+    expect(serializeEditorDoc(rebuilt.editor.state.doc).value).toBe(value);
+  },
+);
+
 it("keeps the caret inside unknown dollar text across rich and plain remounts", async () => {
   const value = "echo $HOME now";
   await using screen = await mountEditor(value);

apps/web/src/components/ComposerPromptEditorTiptap.tsx

@@ -1123,6 +1123,8 @@ function ComposerPromptEditorTiptapInner(
         literalText,
       }),
       editable: !disabled,
+      // Pastes are parsed as Markdown above; Tiptap's rules would restyle the literal text of code spans.
+      enablePasteRules: false,
       editorProps: {
         attributes: editorAttributes,
         handleKeyDown: (view, event) => {
@@ -1369,8 +1371,13 @@ function ComposerPromptEditorTiptapInner(
           const pastedText = clipboardData.getData("text/plain");
           if (!pastedText) return false;
           event.preventDefault();
-          // Paste verbatim inside fences; markdown parsing would split blocks and create unsupported chips.
-          if (isInCodeBlock(view)) {
+          // Paste verbatim inside fences and code spans; markdown parsing would split blocks and create unsupported chips.
+          const { storedMarks, selection } = view.state;
+          // Code spans cannot hold a newline or backtick, so those pastes take the Markdown path and split the span.
+          const inCodeSpan =
+            !/[\n`]/.test(pastedText) &&
+            (storedMarks ?? selection.$from.marks()).some((mark) => mark.type.name === "code");
+          if (isInCodeBlock(view) || inCodeSpan) {
             const { from, to } = view.state.selection;
             view.dispatch(
               markAsClipboardEdit(

apps/web/src/composer-rich-text-doc.test.ts

@@ -813,6 +813,12 @@ describe("serializeSelection", () => {
   });
 });
 
+// regression: #25180 rebuilding a draft rewrote underscores in URLs and paths as emphasis
+it("rebuilds a draft with underscores in a URL and a path unchanged", () => {
+  const value = "Read https://example.com/_handle_/status/1 and open src/__test__.tsx";
+  expect(roundTrip(value).value).toBe(value);
+});
+
 describe("pasting into a list item or quote", () => {
   it("keeps inline marks but builds no blocks", () => {
     const content = buildTiptapContent(
@@ -888,7 +894,7 @@ describe("pasting into a path query", () => {
   });
 
   it("parses markdown when the paste does not continue a path query", () => {
-    expect(boldText(paste("Open ", "src/__test__.tsx"))).toEqual(["test"]);
+    expect(boldText(paste("Open ", "__test__ now"))).toEqual(["test"]);
     expect(boldText(paste("Open @a ", "__b__"))).toEqual(["b"]);
     expect(boldText(paste("Open @", " __b__"))).toEqual(["b"]);
   });

apps/web/src/composer-rich-text.test.ts

@@ -51,6 +51,27 @@ describe("composer rich text markdown", () => {
     ]);
   });
 
+  // regression: #25180 underscores in URLs and paths were read as emphasis
+  it("keeps underscores in URLs and paths literal", () => {
+    for (const text of [
+      "Read src/(_foo_).tsx",
+      "https://example.com/~_user_/a",
+      "_build_/file.ts",
+      "src/__test__.tsx",
+      "edit __init__.py, then",
+    ]) {
+      expect(parseInlineMarkdown(text)).toEqual([{ text, marks: [] }]);
+    }
+    expect(parseInlineMarkdown("(_see_) _a b_ __c__")).toEqual([
+      { text: "(", marks: [] },
+      { text: "see", marks: ["italic"] },
+      { text: ") ", marks: [] },
+      { text: "a b", marks: ["italic"] },
+      { text: " ", marks: [] },
+      { text: "c", marks: ["bold"] },
+    ]);
+  });
+
   it("keeps code span contents literal", () => {
     expect(parseInlineMarkdown("`**not bold**`")).toEqual([
       { text: "**not bold**", marks: ["code"] },

apps/web/src/composer-rich-text.ts

@@ -26,7 +26,14 @@ function pushSpan(spans: RichTextSpan[], text: string, marks: RichTextMark[]): v
   }
 }
 
+/** Words containing a slash or ending in a file extension are URLs, paths, or filenames. */
+const LITERAL_UNDERSCORE_WORD = /\/|\.[a-z][a-z0-9]*\W*$/i;
+
 export function parseInlineMarkdown(text: string): RichTextSpan[] {
+  const literalWords = Array.from(text.matchAll(/\S+/g)).filter((word) =>
+    LITERAL_UNDERSCORE_WORD.test(word[0]),
+  );
+  let literalWord = 0;
   const root: RichTextSpan[] = [];
   const stack: { delimiter: string; mark: RichTextMark; spans: RichTextSpan[] }[] = [];
   const current = () => stack.at(-1)?.spans ?? root;
@@ -62,6 +69,15 @@ export function parseInlineMarkdown(text: string): RichTextSpan[] {
     }
     let end = index;
     while (text[end] === char) end += 1;
+    if (char === "_") {
+      let word = literalWords[literalWord];
+      while (word && word.index + word[0].length <= index) word = literalWords[++literalWord];
+      if (word && word.index <= index) {
+        pushSpan(current(), text.slice(index, end), []);
+        index = end;
+        continue;
+      }
+    }
     const before = text[index - 1] ?? "";
     const after = text[end] ?? "";
     const canClose = before !== "" && !/\s/.test(before) && (char !== "_" || !/\w/.test(after));