fix(web): text after a composer list no longer joins its last item

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

@@ -340,6 +340,18 @@ it("keeps the caret inside unknown dollar text across rich and plain remounts",
   expect(serializeEditorDoc(editor.state.doc).value).toBe("echo $HOXYME now");
 });
 
+it.each([
+  ["- item\npara", "- item\n\nparaX"],
+  ["> quote\npara", "> quote\n\nparaX"],
+])("keeps the caret at the end of %j when loading adds a blank line", async (value, typed) => {
+  await using screen = await mountEditor(value);
+  const { editor } = screen;
+  await act(async () => {
+    editor.commands.insertContent("X");
+  });
+  expect(serializeEditorDoc(editor.state.doc).value).toBe(typed);
+});
+
 async function focusAt(editor: Editor, position: number | "end") {
   // ProseMirror rewrites the DOM caret 20ms after focus. Run that now, or it
   // can undo the first key before ProseMirror reads the native move.

apps/web/src/components/ComposerPromptEditorTiptap.tsx

@@ -87,6 +87,7 @@ import {
   pmToFlat,
   serializeEditorDoc,
   serializeSelection,
+  shiftPastAddedBlankLines,
   skillChipReplacements,
   splitOrLiftListItem,
   stepCaretAcrossStyledEdge,
@@ -1524,7 +1525,14 @@ function ComposerPromptEditorTiptapInner(
         },
       );
     }
-    selectMarkdownOffset(editor, normalizedExpandedCursor);
+    selectMarkdownOffset(
+      editor,
+      shiftPastAddedBlankLines(
+        value,
+        serializeEditorDoc(editor.state.doc).value,
+        normalizedExpandedCursor,
+      ),
+    );
     const map = serializeEditorDoc(editor.state.doc);
     if (isFocused) scrollTiptapCaretIntoView(editor);
     if (pendingCitation) {
@@ -1594,7 +1602,14 @@ function ComposerPromptEditorTiptapInner(
     const boundedCursor = clampEditorCursor(snapshotRef.current.value, nextCursor);
     const expandedCursor =
       exactExpandedCursor ?? expandEditorCursor(snapshotRef.current.value, boundedCursor);
-    selectMarkdownOffset(editor, expandedCursor);
+    selectMarkdownOffset(
+      editor,
+      shiftPastAddedBlankLines(
+        snapshotRef.current.value,
+        serializeEditorDoc(editor.state.doc).value,
+        expandedCursor,
+      ),
+    );
     scrollTiptapCaretIntoView(editor);
     if (boundedCursor === snapshotRef.current.cursor) return;
     snapshotRef.current = {

apps/web/src/composer-list-split.browser.test.ts

@@ -60,7 +60,7 @@ function storedDraft(editor: Editor) {
 
 describe("Backspace at the start of a line", () => {
   it.each([
-    ["- a\n```\nl1\nl2\n```", "- a\nl1\nl2"],
+    ["- a\n```\nl1\nl2\n```", "- a\n\nl1\nl2"],
     ["p\n```ts\nl1\n```", "p\nl1"],
   ])("removes the fence of %j rather than joining its code up", (value, expected) => {
     using editor = makeEditor(value);
@@ -95,6 +95,6 @@ describe("blocks that a list item or quote cannot hold", () => {
     editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atEnd(editor.state.doc)));
     const lines = buildTiptapContent("one\ntwo", (name) => ({ label: name, description: null }));
     editor.commands.insertContent(lines);
-    expect(storedDraft(editor)).toBe("- a\none\ntwo");
+    expect(storedDraft(editor)).toBe("- a\n\none\ntwo");
   });
 });

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

@@ -303,7 +303,7 @@ describe("composer rich text document model", () => {
     "- [ ] parent\n  - [ ] child\n  - [ ] sibling\n- [ ] uncle",
     "- [ ] empty task follows\n- [ ]",
     "- [ ] **bold** task with @README.md",
-    "para\n- [ ] task\npara",
+    "para\n- [ ] task\n\npara",
     "- [ ]No space stays literal",
     "-[ ] also literal",
     "@README.md explain this",
@@ -487,7 +487,7 @@ describe("composer rich text document model", () => {
     "- **bold** item with @README.md",
     "- [ ] task\n- bullet after",
     "- bullet\n- [x] task after",
-    "para\n- item\npara",
+    "- item\n  indented continuation",
     "\t- tab indented\n\t- again",
     "  - leading indent only",
     "- item\n\n- after a blank",
@@ -587,6 +587,23 @@ describe("composer rich text document model", () => {
     });
   });
 
+  it.each([
+    ["para\n- item\npara", "para\n- item\n\npara"],
+    ["1. one\n2. two\nafter", "1. one\n2. two\n\nafter"],
+    ["- [ ] task\nafter", "- [ ] task\n\nafter"],
+    ["- a\n  - b\nafter", "- a\n  - b\n\nafter"],
+    ["- item\n@README.md please", "- item\n\n@README.md please"],
+    ["> quoted\nafter", "> quoted\n\nafter"],
+  ])("separates %j from the block above, which Markdown would fold it into", (glued, settled) => {
+    expect(roundTrip(glued).value).toBe(settled);
+    expect(roundTrip(settled).value).toBe(settled);
+    const blockTypes = (value: string) =>
+      buildDocJson(value, (name) => ({ label: name, description: null })).content.map(
+        (block) => block.type,
+      );
+    expect(blockTypes(settled)).toEqual(blockTypes(glued));
+  });
+
   it.each([
     "---",
     "***",
@@ -683,6 +700,9 @@ describe("composer rich text document model", () => {
       "paragraph",
     ]);
     expect(roundTrip(value).value).toBe(value);
+    for (const spaced of ["- item\r\n\r\npara", "> quote\r\n\r\npara"]) {
+      expect(roundTrip(spaced).value).toBe(spaced);
+    }
   });
 
   it("keeps the caret inside an empty fence", () => {

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

@@ -792,7 +792,7 @@ export function buildTiptapContent(
     | { rule: string }
     | { heading: { level: number; space: string; inline: InlineJson[] } }
     | { quote: { prefix: string; inline: InlineJson[] } }
-    | { line: DocLine }
+    | { line: DocLine; source: string }
   )[] = [];
   const restoreSources = (line: string) =>
     line.split(sentinel).reduce((joined, piece, index) => {
@@ -806,6 +806,7 @@ export function buildTiptapContent(
     if (index === 0 && literal) {
       entries.push({
         line: { list: null, inline: [textJsonForSpan(literal, []), ...buildInline(line)] },
+        source: literal + line,
       });
       continue;
     }
@@ -828,7 +829,7 @@ export function buildTiptapContent(
       }
       const quote = blockSyntax ? /^(>[ \t]*)([^\n]*)$/.exec(line) : null;
       if (quote) entries.push({ quote: { prefix: quote[1]!, inline: buildInline(quote[2]!) } });
-      else entries.push({ line: buildDocLine(line) });
+      else entries.push({ line: buildDocLine(line), source: line });
       continue;
     }
     const language = restoreSources(opening.language);
@@ -879,7 +880,23 @@ export function buildTiptapContent(
     });
     openQuote = null;
   };
-  for (const entry of entries) {
+  const lazyTarget = (entry: (typeof entries)[number] | undefined) =>
+    !entry ? null : "quote" in entry ? "quote" : "line" in entry && entry.line.list ? "list" : null;
+  for (const [index, entry] of entries.entries()) {
+    const next = entries[index + 1];
+    if (
+      "line" in entry &&
+      entry.source === "" &&
+      next &&
+      "line" in next &&
+      !next.line.list &&
+      needsBlankLineBetween(lazyTarget(entries[index - 1]), {
+        empty: next.source === "",
+        indented: /^[ \t]/.test(next.source),
+      })
+    ) {
+      continue;
+    }
     if ("quote" in entry) {
       flushLists();
       if (openQuote && openQuote.prefix !== entry.quote.prefix) flushQuote();
@@ -1026,11 +1043,37 @@ function pushBreakRun(acc: RichAccumulator, position?: number): void {
   acc.md += 1;
 }
 
-// Separate prose from quotes to avoid lazy continuation; an empty paragraph already separates them.
-function needsBlankLineAfterQuote(previous: ProseMirrorNode, block: ProseMirrorNode): boolean {
-  return (
-    previous.type.name === "blockquote" && block.type.name === "paragraph" && block.content.size > 0
-  );
+// Markdown folds a paragraph line into the quote or list right above it, so the serializer writes
+// a blank line between them and the parser drops it. An empty paragraph is that line already, and
+// an indented line after a list continues the item on purpose.
+function needsBlankLineBetween(
+  previous: "quote" | "list" | null,
+  paragraph: { empty: boolean; indented: boolean },
+): boolean {
+  if (!previous || paragraph.empty) return false;
+  return previous === "quote" || !paragraph.indented;
+}
+
+function lazyContinuationTarget(block: ProseMirrorNode): "quote" | "list" | null {
+  if (block.type.name === "blockquote") return "quote";
+  return LIST_NODE_NAMES.has(block.type.name) ? "list" : null;
+}
+
+// Loading a draft can add the blank line Markdown needs after a quote or list. Moves an offset in
+// `value` to the same text in `serialized`.
+export function shiftPastAddedBlankLines(
+  value: string,
+  serialized: string,
+  offset: number,
+): number {
+  if (value === serialized) return offset;
+  let shift = 0;
+  for (let index = 0; index < offset; index += 1) {
+    while (value[index] !== serialized[index + shift] && serialized[index + shift] === "\n") {
+      shift += 1;
+    }
+  }
+  return Math.min(serialized.length, offset + shift);
 }
 
 // Blank-line runs own no document characters; offsets clamp to the paragraph start.
@@ -1477,7 +1520,17 @@ function serializeDoc(doc: ProseMirrorNode): RichDocMap {
   let pmBlockStart = 0;
   blocks.forEach((block, blockIndex) => {
     if (blockIndex > 0 && !isTrailingLineAfterRule(doc, blockIndex)) pushBreakRun(acc);
-    if (blockIndex > 0 && needsBlankLineAfterQuote(blocks[blockIndex - 1]!, block)) {
+    const first = block.firstChild;
+    if (
+      blockIndex > 0 &&
+      block.type.name === "paragraph" &&
+      needsBlankLineBetween(lazyContinuationTarget(blocks[blockIndex - 1]!), {
+        // A CRLF blank line keeps its "\r".
+        empty: !first || (block.childCount === 1 && first.text === "\r"),
+        // Checks the first node, not textContent, which skips a leading chip.
+        indented: Boolean(first?.isText && !first.marks.length && /^[ \t]/.test(first.text!)),
+      })
+    ) {
       pushBlankLineRun(acc, pmBlockStart + 1);
     }
     if (LIST_NODE_NAMES.has(block.type.name)) {