From 99fb68c12078cd178ebeb23287388ea6b5691ebf Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Wed, 21 Oct 2026 16:48:48 +0000
Subject: [PATCH 1/6] fix(web): normalize list markers edited in composer
 paragraphs

---
 apps/web/src/composer-block-shortcuts.test.ts | 188 +++++++++++++++++-
 apps/web/src/composer-rich-text-doc.ts        | 114 +++++++++++
 2 files changed, 300 insertions(+), 2 deletions(-)

diff --git a/apps/web/src/composer-block-shortcuts.test.ts b/apps/web/src/composer-block-shortcuts.test.ts
index eea43193dd75d..5beaa9829f104 100644
--- a/apps/web/src/composer-block-shortcuts.test.ts
+++ b/apps/web/src/composer-block-shortcuts.test.ts
@@ -1,7 +1,9 @@
 import { Editor } from "@tiptap/core";
+import { closeHistory, redo, undo } from "@tiptap/pm/history";
+import { splitBlock } from "@tiptap/pm/commands";
 import { TextSelection } from "@tiptap/pm/state";
 import StarterKit from "@tiptap/starter-kit";
-import { describe, expect, it } from "vite-plus/test";
+import { describe, expect, it, onTestFinished } from "vite-plus/test";
 
 import {
   buildDocJson,
@@ -32,7 +34,7 @@ function chord(spec: string) {
   } as unknown as KeyboardEvent;
 }
 
-function press(value: string, spec: string) {
+function createEditor(value: string) {
   const editor = new Editor({
     extensions: [
       StarterKit.configure({
@@ -53,7 +55,14 @@ function press(value: string, spec: string) {
     ],
     content: buildDocJson(value, (name) => ({ label: name, description: null })),
   });
+  editor.view.updateState(editor.state.reconfigure({ plugins: editor.extensionManager.plugins }));
   editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atEnd(editor.state.doc)));
+  onTestFinished(() => editor.destroy());
+  return editor;
+}
+
+function press(value: string, spec: string) {
+  const editor = createEditor(value);
   const event = chord(spec);
   const before = editor.state.doc;
   const handled = editor.extensionManager.plugins.some((plugin) =>
@@ -92,3 +101,178 @@ describe("Tiptap's block shortcuts", () => {
     expect(result.value).toBe(value);
   });
 });
+
+describe("composer list normalization", () => {
+  it("converts a dash edited on an earlier line and keeps the view equal to Markdown", () => {
+    const editor = createEditor("");
+    editor.view.dispatch(editor.state.tr.insertText("-get md"));
+    splitBlock(editor.state, editor.view.dispatch);
+    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.create(editor.state.doc, 2)));
+    editor.view.dispatch(editor.state.tr.insertText(" "));
+    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atEnd(editor.state.doc)));
+
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+    expect(editor.state.doc.firstChild?.firstChild?.textContent).toBe("get md");
+    expect(serializeEditorDoc(editor.state.doc).value).toBe("- get md\n");
+    expect(
+      editor.state.doc.eq(
+        editor.schema.nodeFromJSON(
+          buildDocJson(serializeEditorDoc(editor.state.doc).value, (name) => ({
+            label: name,
+            description: null,
+          })),
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it("converts a dash and space typed before existing text", () => {
+    const editor = createEditor("existing text");
+    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atStart(editor.state.doc)));
+    editor.view.dispatch(editor.state.tr.insertText("-"));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    editor.view.dispatch(editor.state.tr.insertText(" "));
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+    expect(editor.state.selection.$from.parentOffset).toBe(0);
+    expect(serializeEditorDoc(editor.state.doc).value).toBe("- existing text");
+  });
+
+  it.each(["- ", "* ", "+ ", "3) ", "4. ", "- [ ] ", "- [x] "])(
+    "converts %j inserted in front of existing text",
+    (marker) => {
+      const editor = createEditor("existing text");
+      editor.view.dispatch(editor.state.tr.insertText(marker, 1));
+      const list = editor.state.doc.firstChild!;
+      expect(list.type.name).toBe(
+        marker.includes("[") ? "taskList" : /^\d/.test(marker) ? "orderedList" : "bulletList",
+      );
+      expect(list.firstChild?.textContent).toBe("existing text");
+      expect(serializeEditorDoc(editor.state.doc).value).toBe(`${marker}existing text`);
+    },
+  );
+
+  it.each(["a - b", "-x", "-"])("leaves %j as a paragraph", (text) => {
+    const editor = createEditor("");
+    editor.view.dispatch(editor.state.tr.insertText(text));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(editor.state.doc.textContent).toBe(text);
+  });
+
+  it("undoes the insertion and conversion together and can redo them", () => {
+    const editor = createEditor("existing text");
+    editor.view.dispatch(closeHistory(editor.state.tr).insertText("- ", 1));
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+    expect(undo(editor.state, editor.view.dispatch)).toBe(true);
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(editor.state.doc.textContent).toBe("existing text");
+    expect(redo(editor.state, editor.view.dispatch)).toBe(true);
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+  });
+
+  it("keeps the dash gesture available until a task marker is complete", () => {
+    const editor = createEditor("");
+    for (const ch of "- [x]") {
+      editor.view.dispatch(editor.state.tr.insertText(ch));
+      expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    }
+    editor.view.dispatch(editor.state.tr.insertText(" "));
+    expect(editor.state.doc.firstChild?.type.name).toBe("taskList");
+    expect(editor.state.doc.firstChild?.firstChild?.attrs.checked).toBe(true);
+  });
+
+  it("normalizes pasted markers without waiting for another keystroke", () => {
+    const editor = createEditor("existing text");
+    editor.view.dispatch(editor.state.tr.insertText("- ", 1).setMeta("uiEvent", "paste"));
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+  });
+
+  it.each(["```\ncode\n```", "- outer\n  - inner", "> quoted"])(
+    "does not convert paragraphs inside %j",
+    (value) => {
+      const editor = createEditor(value);
+      let position = 0;
+      editor.state.doc.descendants((node, pos) => {
+        if (node.isText) position = pos;
+      });
+      const before: string[] = [];
+      editor.state.doc.descendants((node) => {
+        before.push(node.type.name);
+      });
+      editor.view.dispatch(editor.state.tr.insertText("- ", position));
+      const after: string[] = [];
+      editor.state.doc.descendants((node) => {
+        after.push(node.type.name);
+      });
+      expect(after).toEqual(before);
+      expect(editor.state.doc.textContent).toContain("- ");
+    },
+  );
+
+  it("waits until composition ends before changing paragraph structure", async () => {
+    const editor = createEditor("");
+    editor.view.dispatch(editor.state.tr.insertText("- text").setMeta("composition", 1));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    editor.view.dispatch(editor.state.tr.insertText("日本語", 3, 7).setMeta("composition", 1));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    const normalization = editor.state.plugins.find(
+      (plugin) => plugin.props.handleDOMEvents?.compositionend && plugin.spec.appendTransaction,
+    )!;
+    normalization.props.handleDOMEvents!.compositionend!.call(
+      normalization,
+      editor.view,
+      new Event("compositionend") as CompositionEvent,
+    );
+    // ProseMirror flushes the final composition text in a microtask after this event.
+    queueMicrotask(() => {
+      editor.view.dispatch(editor.state.tr.insertText("確定", 3, 6).setMeta("composition", 1));
+    });
+    await Promise.resolve();
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    await Promise.resolve();
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+    expect(serializeEditorDoc(editor.state.doc).value).toBe("- 確定");
+    expect(undo(editor.state, editor.view.dispatch)).toBe(true);
+    expect(editor.state.doc.textContent).toBe("");
+    expect(redo(editor.state, editor.view.dispatch)).toBe(true);
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+  });
+
+  it("does not immediately reconvert a literal marker restored by undo", () => {
+    const editor = createEditor("");
+    editor.view.dispatch(editor.state.tr.insertText("- "));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    editor.view.dispatch(closeHistory(editor.state.tr).insertText("text"));
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+    expect(undo(editor.state, editor.view.dispatch)).toBe(true);
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(editor.state.doc.textContent).toBe("- ");
+    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atStart(editor.state.doc)));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+  });
+
+  it("preserves formatting and the caret when removing the literal prefix", () => {
+    const editor = createEditor("**text**");
+    editor.view.dispatch(editor.state.tr.insertText("- ", 1));
+    expect(editor.state.selection.$from.parent.type.name).toBe("paragraph");
+    expect(editor.state.selection.$from.parentOffset).toBe(4);
+    expect(serializeEditorDoc(editor.state.doc).value).toBe("- **text**");
+  });
+
+  it("does not turn an inline code marker into a list", () => {
+    const editor = createEditor("`-text`");
+    editor.view.dispatch(editor.state.tr.insertText(" ", 2));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(serializeEditorDoc(editor.state.doc).value).toBe("`- text`");
+  });
+
+  it("only normalizes changed blocks", () => {
+    const editor = createEditor("");
+    editor.view.updateState(editor.state.reconfigure({ plugins: [] }));
+    editor.view.dispatch(editor.state.tr.insertText("- untouched"));
+    splitBlock(editor.state, editor.view.dispatch);
+    editor.view.updateState(editor.state.reconfigure({ plugins: editor.extensionManager.plugins }));
+    editor.view.dispatch(editor.state.tr.insertText("changed"));
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(editor.state.doc.firstChild?.textContent).toBe("- untouched");
+  });
+});
diff --git a/apps/web/src/composer-rich-text-doc.ts b/apps/web/src/composer-rich-text-doc.ts
index 35d8b50c202b1..5978580ae6e5d 100644
--- a/apps/web/src/composer-rich-text-doc.ts
+++ b/apps/web/src/composer-rich-text-doc.ts
@@ -13,12 +13,16 @@ import { Heading } from "@tiptap/extension-heading";
 import { HorizontalRule } from "@tiptap/extension-horizontal-rule";
 import { Italic, starInputRegex, starPasteRegex } from "@tiptap/extension-italic";
 import {
+  combineTransactionSteps,
+  getChangedRanges,
   type Command,
   type Editor,
   markInputRule,
   markPasteRule,
   mergeAttributes,
 } from "@tiptap/core";
+import { isHistoryTransaction } from "@tiptap/pm/history";
+import { findWrapping } from "@tiptap/pm/transform";
 import { BulletList, ListItem, OrderedList } from "@tiptap/extension-list";
 import { TaskItem } from "@tiptap/extension-task-item";
 import { TaskList } from "@tiptap/extension-task-list";
@@ -300,6 +304,12 @@ const ComposerListItemExtension = ListItem.extend({
 
 export const ComposerListExtensions = [
   BulletList.extend({
+    addProseMirrorPlugins() {
+      return [
+        ...(this.parent?.() ?? []),
+        listNormalizationPlugin(() => this.editor.view.composing),
+      ];
+    },
     addKeyboardShortcuts() {
       return withoutBlockChords(this.parent?.(), ["Mod-Shift-8"]);
     },
@@ -440,6 +450,110 @@ function parseListPrefix(line: string): { prefix: ListLinePrefix; markerLength:
   return null;
 }
 
+/** Only changed top-level paragraphs can acquire a literal list prefix outside an input rule. */
+function listNormalizationPlugin(isComposing: () => boolean) {
+  let pending = new Set<number>();
+  const key = new PluginKey("composerListNormalization");
+  return new Plugin({
+    key,
+    props: {
+      handleDOMEvents: {
+        compositionend(view) {
+          // ProseMirror queues its final DOM flush later in this event's compositionend handler.
+          queueMicrotask(() =>
+            queueMicrotask(() => {
+              if (!view.isDestroyed && pending.size > 0)
+                view.dispatch(view.state.tr.setMeta(key, true));
+            }),
+          );
+          return false;
+        },
+      },
+    },
+    appendTransaction(transactions, oldState, state) {
+      if (transactions.some(isHistoryTransaction)) {
+        pending.clear();
+        return null;
+      }
+      const changes = combineTransactionSteps(oldState.doc, [...transactions]);
+      pending = new Set(
+        [...pending].flatMap((pos) => {
+          const mapped = changes.mapping.mapResult(pos, 1);
+          return mapped.deleted ? [] : [mapped.pos];
+        }),
+      );
+      for (const { newRange } of getChangedRanges(changes)) {
+        state.doc.nodesBetween(newRange.from, newRange.to, (node, pos) => {
+          if (node.type.name === "paragraph") pending.add(pos);
+          return false;
+        });
+      }
+      if (isComposing() || transactions.some((tr) => tr.getMeta("composition") != null))
+        return null;
+
+      const tr = state.tr;
+      for (const pos of [...pending].sort((a, b) => b - a)) {
+        pending.delete(pos);
+        if (state.doc.resolve(pos).depth !== 0) continue;
+        const node = state.doc.nodeAt(pos);
+        if (node?.type.name !== "paragraph") continue;
+        const text = node.textBetween(0, node.content.size, undefined, "\ufffc");
+        const parsed = parseListPrefix(text);
+        if (!parsed || parsed.prefix.indent) continue;
+        const { prefix, markerLength } = parsed;
+        const code = state.schema.marks.code;
+        if (code && node.rangeHasMark(0, markerLength, code)) continue;
+        const active = state.selection.$from.depth === 1 && state.selection.$from.before(1) === pos;
+        const content = text.slice(markerLength);
+        // Keep `- ` and unfinished task markers literal while the user is entering the gesture.
+        if (
+          active &&
+          (prefix.kind === "task"
+            ? !prefix.contentSpace
+            : prefix.kind === "bullet" &&
+              prefix.marker === "-" &&
+              (!content || content.startsWith("[")))
+        ) {
+          pending.add(pos);
+          continue;
+        }
+        if (prefix.kind !== "task" && !prefix.space) continue;
+        const listType =
+          state.schema.nodes[
+            prefix.kind === "task"
+              ? "taskList"
+              : prefix.kind === "ordered"
+                ? "orderedList"
+                : "bulletList"
+          ];
+        if (!listType) continue;
+        const attrs =
+          prefix.kind === "ordered" ? { start: Number.parseInt(prefix.marker, 10) || 1 } : {};
+        const $from = tr.doc.resolve(pos + 1);
+        const range = $from.blockRange();
+        const wrapping = range && findWrapping(range, listType, attrs);
+        if (!range || !wrapping) continue;
+        tr.wrap(range, wrapping);
+        tr.setNodeMarkup(
+          pos + 1,
+          undefined,
+          prefix.kind === "task"
+            ? {
+                checked: prefix.checked,
+                indent: prefix.indent,
+                markerSpace: prefix.markerSpace,
+                contentSpace: prefix.contentSpace,
+              }
+            : { indent: prefix.indent, marker: prefix.marker, space: prefix.space },
+        );
+        tr.delete(pos + 3, pos + 3 + markerLength);
+      }
+      pending = new Set([...pending].map((pos) => tr.mapping.map(pos, 1)));
+      return tr.docChanged ? tr : null;
+    },
+  });
+}
+
 function listKey(prefix: ListLinePrefix): string {
   if (prefix.kind === "task") return "task";
   if (prefix.kind === "ordered") return `ordered:${prefix.marker.slice(-1)}`;

From 0eea92865b552da884ed1da8ba0361bc068aa4e1 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Wed, 21 Oct 2026 16:54:43 +0000
Subject: [PATCH 2/6] fix(web): normalize bracket-prefixed composer list
 content

---
 apps/web/src/composer-block-shortcuts.test.ts | 11 +++++++++++
 apps/web/src/composer-rich-text-doc.ts        |  2 +-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/apps/web/src/composer-block-shortcuts.test.ts b/apps/web/src/composer-block-shortcuts.test.ts
index 5beaa9829f104..39cf507fcb7c8 100644
--- a/apps/web/src/composer-block-shortcuts.test.ts
+++ b/apps/web/src/composer-block-shortcuts.test.ts
@@ -137,6 +137,17 @@ describe("composer list normalization", () => {
     expect(serializeEditorDoc(editor.state.doc).value).toBe("- existing text");
   });
 
+  it.each(["[link](url)", "[ordinary text]", "[x]text"])(
+    "converts a dash before existing bracket-prefixed text %j",
+    (text) => {
+      const editor = createEditor(text);
+      editor.view.dispatch(editor.state.tr.insertText("- ", 1));
+      expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+      expect(editor.state.doc.firstChild?.firstChild?.textContent).toBe(text);
+      expect(serializeEditorDoc(editor.state.doc).value).toBe(`- ${text}`);
+    },
+  );
+
   it.each(["- ", "* ", "+ ", "3) ", "4. ", "- [ ] ", "- [x] "])(
     "converts %j inserted in front of existing text",
     (marker) => {
diff --git a/apps/web/src/composer-rich-text-doc.ts b/apps/web/src/composer-rich-text-doc.ts
index 5978580ae6e5d..94f6f84be4dc5 100644
--- a/apps/web/src/composer-rich-text-doc.ts
+++ b/apps/web/src/composer-rich-text-doc.ts
@@ -512,7 +512,7 @@ function listNormalizationPlugin(isComposing: () => boolean) {
             ? !prefix.contentSpace
             : prefix.kind === "bullet" &&
               prefix.marker === "-" &&
-              (!content || content.startsWith("[")))
+              (!content || /^\[(?:[ xX]\]?)?$/.test(content)))
         ) {
           pending.add(pos);
           continue;

From 9c3c3acbc65b6cd756052c03ce9a41a905e40b90 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Wed, 21 Oct 2026 16:58:18 +0000
Subject: [PATCH 3/6] fix(web): preserve styled literal composer list markers

---
 apps/web/src/composer-block-shortcuts.test.ts | 36 ++++++++++---------
 apps/web/src/composer-rich-text-doc.ts        | 23 ++++--------
 2 files changed, 27 insertions(+), 32 deletions(-)

diff --git a/apps/web/src/composer-block-shortcuts.test.ts b/apps/web/src/composer-block-shortcuts.test.ts
index 39cf507fcb7c8..cc85589203d98 100644
--- a/apps/web/src/composer-block-shortcuts.test.ts
+++ b/apps/web/src/composer-block-shortcuts.test.ts
@@ -55,6 +55,7 @@ function createEditor(value: string) {
     ],
     content: buildDocJson(value, (name) => ({ label: name, description: null })),
   });
+  // Headless editors need the plugins installed explicitly because there is no mounted view.
   editor.view.updateState(editor.state.reconfigure({ plugins: editor.extensionManager.plugins }));
   editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atEnd(editor.state.doc)));
   onTestFinished(() => editor.destroy());
@@ -219,27 +220,15 @@ describe("composer list normalization", () => {
     },
   );
 
-  it("waits until composition ends before changing paragraph structure", async () => {
+  it("waits for a non-composition transaction before changing paragraph structure", () => {
     const editor = createEditor("");
     editor.view.dispatch(editor.state.tr.insertText("- text").setMeta("composition", 1));
     expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
     editor.view.dispatch(editor.state.tr.insertText("日本語", 3, 7).setMeta("composition", 1));
     expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
-    const normalization = editor.state.plugins.find(
-      (plugin) => plugin.props.handleDOMEvents?.compositionend && plugin.spec.appendTransaction,
-    )!;
-    normalization.props.handleDOMEvents!.compositionend!.call(
-      normalization,
-      editor.view,
-      new Event("compositionend") as CompositionEvent,
-    );
-    // ProseMirror flushes the final composition text in a microtask after this event.
-    queueMicrotask(() => {
-      editor.view.dispatch(editor.state.tr.insertText("確定", 3, 6).setMeta("composition", 1));
-    });
-    await Promise.resolve();
+    editor.view.dispatch(editor.state.tr.insertText("確定", 3, 6).setMeta("composition", 1));
     expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
-    await Promise.resolve();
+    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atEnd(editor.state.doc)));
     expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
     expect(serializeEditorDoc(editor.state.doc).value).toBe("- 確定");
     expect(undo(editor.state, editor.view.dispatch)).toBe(true);
@@ -263,7 +252,7 @@ describe("composer list normalization", () => {
 
   it("preserves formatting and the caret when removing the literal prefix", () => {
     const editor = createEditor("**text**");
-    editor.view.dispatch(editor.state.tr.insertText("- ", 1));
+    editor.view.dispatch(editor.state.tr.insert(1, editor.schema.text("- ")));
     expect(editor.state.selection.$from.parent.type.name).toBe("paragraph");
     expect(editor.state.selection.$from.parentOffset).toBe(4);
     expect(serializeEditorDoc(editor.state.doc).value).toBe("- **text**");
@@ -276,6 +265,21 @@ describe("composer list normalization", () => {
     expect(serializeEditorDoc(editor.state.doc).value).toBe("`- text`");
   });
 
+  it.each(["**- x**", "*-* x", "~~- x~~", "a\n**1.** b"])(
+    "preserves styled markers when restoring %j",
+    (value) => {
+      const editor = createEditor("");
+      editor.commands.setContent(
+        buildDocJson(value, (name) => ({ label: name, description: null })),
+        { emitUpdate: false },
+      );
+      expect(serializeEditorDoc(editor.state.doc).value).toBe(value);
+      expect(editor.state.doc.lastChild?.type.name).toBe("paragraph");
+      editor.view.dispatch(editor.state.tr.insertText("x", editor.state.doc.content.size - 1));
+      expect(editor.state.doc.lastChild?.type.name).toBe("paragraph");
+    },
+  );
+
   it("only normalizes changed blocks", () => {
     const editor = createEditor("");
     editor.view.updateState(editor.state.reconfigure({ plugins: [] }));
diff --git a/apps/web/src/composer-rich-text-doc.ts b/apps/web/src/composer-rich-text-doc.ts
index 94f6f84be4dc5..7b9c192359cf6 100644
--- a/apps/web/src/composer-rich-text-doc.ts
+++ b/apps/web/src/composer-rich-text-doc.ts
@@ -456,25 +456,12 @@ function listNormalizationPlugin(isComposing: () => boolean) {
   const key = new PluginKey("composerListNormalization");
   return new Plugin({
     key,
-    props: {
-      handleDOMEvents: {
-        compositionend(view) {
-          // ProseMirror queues its final DOM flush later in this event's compositionend handler.
-          queueMicrotask(() =>
-            queueMicrotask(() => {
-              if (!view.isDestroyed && pending.size > 0)
-                view.dispatch(view.state.tr.setMeta(key, true));
-            }),
-          );
-          return false;
-        },
-      },
-    },
     appendTransaction(transactions, oldState, state) {
       if (transactions.some(isHistoryTransaction)) {
         pending.clear();
         return null;
       }
+      if (pending.size === 0 && !transactions.some((tr) => tr.docChanged)) return null;
       const changes = combineTransactionSteps(oldState.doc, [...transactions]);
       pending = new Set(
         [...pending].flatMap((pos) => {
@@ -488,6 +475,7 @@ function listNormalizationPlugin(isComposing: () => boolean) {
           return false;
         });
       }
+      // The next non-composition transaction can normalize after the browser finishes its DOM edits.
       if (isComposing() || transactions.some((tr) => tr.getMeta("composition") != null))
         return null;
 
@@ -499,10 +487,13 @@ function listNormalizationPlugin(isComposing: () => boolean) {
         if (node?.type.name !== "paragraph") continue;
         const text = node.textBetween(0, node.content.size, undefined, "\ufffc");
         const parsed = parseListPrefix(text);
+        // Input rules only introduce unindented top-level lists; keep the same boundary here.
         if (!parsed || parsed.prefix.indent) continue;
         const { prefix, markerLength } = parsed;
-        const code = state.schema.marks.code;
-        if (code && node.rangeHasMark(0, markerLength, code)) continue;
+        if (
+          Object.values(state.schema.marks).some((mark) => node.rangeHasMark(0, markerLength, mark))
+        )
+          continue;
         const active = state.selection.$from.depth === 1 && state.selection.$from.before(1) === pos;
         const content = text.slice(markerLength);
         // Keep `- ` and unfinished task markers literal while the user is entering the gesture.

From d339b7935816c9ca619b57c9ebf007894f7ac8af Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Thu, 22 Oct 2026 12:30:38 +0000
Subject: [PATCH 4/6] test(web): add composer list-marker evidence driver for
 #22989

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../evidence/drive-composer-list-markers.mjs  | 684 ++++++++++++++++++
 1 file changed, 684 insertions(+)
 create mode 100644 scripts/evidence/drive-composer-list-markers.mjs

diff --git a/scripts/evidence/drive-composer-list-markers.mjs b/scripts/evidence/drive-composer-list-markers.mjs
new file mode 100644
index 0000000000000..e292a3b7561be
--- /dev/null
+++ b/scripts/evidence/drive-composer-list-markers.mjs
@@ -0,0 +1,684 @@
+#!/usr/bin/env node
+// Drives the rich-text chat composer through the list-marker fixtures of PR #22997
+// (late-completed Markdown list markers) and records a self-narrating video plus a
+// per-step log, so the same keystrokes can be compared on two revisions.
+//
+// Run against a dev server that is already paired (see `vp run dev` and its pairingUrl):
+//
+//   PLAYWRIGHT_MODULE=<repo>/node_modules/.pnpm/playwright@1.60.0/node_modules/playwright/index.mjs \
+//   node drive-composer-list-markers.mjs \
+//     --base-url http://localhost:5733 --label after --viewport 1440 --theme light \
+//     --rows F1,F2,F6 --storage-state ./state-after.json --out-dir ./out [--pair-url <url>] \
+//     [--stills F1,F14] [--no-video]
+//
+// --pair-url pairs a fresh browser and writes --storage-state; later runs reuse it.
+// Outputs, per run: <label>-<viewport>-<theme>-<tag>.webm/.mp4 (trimmed to the first step),
+// a .json and .md step log with offsets from the start of the trimmed video, and, for rows
+// listed in --stills, a full-page PNG of the row's end state taken under a frozen clock.
+// Never presses plain Enter or Mod+Enter: both send the message.
+
+import * as NodeChildProcess from "node:child_process";
+import * as NodeFS from "node:fs";
+import * as NodePath from "node:path";
+
+const args = Object.fromEntries(
+  process.argv.slice(2).reduce((acc, arg, i, all) => {
+    if (!arg.startsWith("--")) return acc;
+    const next = all[i + 1];
+    acc.push([arg.slice(2), next === undefined || next.startsWith("--") ? true : next]);
+    return acc;
+  }, []),
+);
+const baseUrl = String(args["base-url"] ?? "").replace(/\/$/, "");
+const label = String(args.label ?? "run");
+const viewportWidth = Number(args.viewport ?? 1440);
+const theme = args.theme === "dark" ? "dark" : "light";
+const rowIds = String(args.rows ?? "F1")
+  .split(",")
+  .filter(Boolean);
+const stillRows = new Set(
+  String(args.stills ?? "")
+    .split(",")
+    .filter(Boolean),
+);
+const outDir = NodePath.resolve(String(args["out-dir"] ?? "./out"));
+const storageState = NodePath.resolve(String(args["storage-state"] ?? `./state-${label}.json`));
+const recordVideo = !args["no-video"];
+const tag = String(args.tag ?? rowIds.join("-"));
+const FROZEN_TIME = new Date("2026-10-22T12:00:00Z");
+const EDITOR = '[data-testid="composer-editor"]';
+const DRAFT_KEY = "t3code:composer-drafts:v1";
+const FONT_PREVIEW = '[data-testid="composer-editor"][aria-label="Prompt font preview"]';
+let editorSel = EDITOR;
+if (!baseUrl) throw new Error("--base-url is required");
+NodeFS.mkdirSync(outDir, { recursive: true });
+
+const { chromium } = await import(process.env.PLAYWRIGHT_MODULE ?? "playwright");
+const browser = await chromium.launch();
+const viewport = { width: viewportWidth, height: viewportWidth <= 500 ? 844 : 900 };
+
+if (args["pair-url"]) {
+  const ctx = await browser.newContext({ viewport });
+  const page = await ctx.newPage();
+  await page.goto(String(args["pair-url"]));
+  await page.waitForURL((u) => !u.pathname.startsWith("/pair"), { timeout: 180_000 });
+  await ctx.storageState({ path: storageState });
+  await ctx.close();
+}
+
+const base = `${label}-${viewportWidth}-${theme}-${tag}`;
+const context = await browser.newContext({
+  viewport,
+  deviceScaleFactor: 1,
+  colorScheme: theme,
+  storageState,
+  permissions: ["clipboard-read", "clipboard-write"],
+  ...(recordVideo
+    ? { recordVideo: { dir: NodePath.join(outDir, `.raw-${base}`), size: viewport } }
+    : {}),
+});
+await context.addInitScript(() => {
+  window.__caption = (text) => {
+    let el = document.getElementById("__ev_caption");
+    if (!el) {
+      el = document.createElement("div");
+      el.id = "__ev_caption";
+      el.style.cssText =
+        "position:fixed;top:8px;left:50%;transform:translateX(-50%);z-index:2147483647;" +
+        "pointer-events:none;max-width:92vw;padding:6px 12px;border-radius:8px;" +
+        "font:600 13px/1.35 ui-monospace,monospace;background:#111c;color:#fff;" +
+        "white-space:pre-wrap;box-shadow:0 2px 8px #0005";
+      document.documentElement.appendChild(el);
+    }
+    el.textContent = text;
+  };
+});
+const page = await context.newPage();
+await page.clock.install({ time: FROZEN_TIME });
+const videoStart = Date.now();
+const steps = [];
+let t0 = null;
+let currentRow = "";
+
+const offset = () => ((Date.now() - (t0 ?? Date.now())) / 1000).toFixed(2);
+async function caption(text) {
+  await page.evaluate((t) => window.__caption?.(t), text).catch(() => {});
+}
+async function step(text, fn) {
+  await caption(`${label.toUpperCase()} · ${currentRow} · ${text}`);
+  steps.push({ row: currentRow, t: Number(offset()), step: text });
+  await page.waitForTimeout(350);
+  if (fn) await fn();
+  await page.waitForTimeout(450);
+}
+const type = (text) =>
+  step(`type ${JSON.stringify(text)}`, () => page.keyboard.type(text, { delay: 70 }));
+const press = (key, times = 1) =>
+  step(times > 1 ? `${key} ×${times}` : key, async () => {
+    for (let i = 0; i < times; i++) await page.keyboard.press(key);
+  });
+const pause = (ms = 1100) =>
+  step(`pause ${ms} ms (undo group boundary)`, () => page.waitForTimeout(ms));
+const paste = (text) =>
+  step(`paste ${JSON.stringify(text)}`, async () => {
+    await page.evaluate((t) => navigator.clipboard.writeText(t), text);
+    await page.keyboard.press("Control+V");
+  });
+const cdpInsert = (text) =>
+  step(`CDP Input.insertText ${JSON.stringify(text)}`, async () => {
+    const cdp = await context.newCDPSession(page);
+    await cdp.send("Input.insertText", { text });
+    await cdp.detach();
+  });
+
+async function waitForComposer() {
+  await page.waitForSelector(EDITOR, { timeout: 240_000 });
+  await page.waitForTimeout(1500);
+}
+async function focusComposer() {
+  await page.locator(editorSel).first().click();
+}
+async function reset() {
+  await step("reset composer (Ctrl+A, Backspace)", async () => {
+    await focusComposer();
+    await page.keyboard.press("Control+A");
+    await page.keyboard.press("Backspace");
+  });
+}
+
+// Structure of the composer document plus the persisted draft Markdown.
+async function observe(note = "observe") {
+  await page.waitForTimeout(500);
+  const state = await page.evaluate(
+    ({ sel, key }) => {
+      const root = document.querySelector(sel);
+      const describe = (node) => {
+        const tagName = node.tagName.toLowerCase();
+        if (tagName === "ul" || tagName === "ol") {
+          const kind = node.getAttribute("data-type") === "taskList" ? "taskList" : tagName;
+          const start = node.getAttribute("start");
+          const items = [...node.children].map((li) => {
+            const marker = li.getAttribute("data-marker");
+            const checked = li.getAttribute("data-checked");
+            return `li${marker ? `[marker=${JSON.stringify(marker)}]` : ""}${checked ? `[checked=${checked}]` : ""} ${JSON.stringify(li.textContent)}`;
+          });
+          return `${kind}${start ? `[start=${start}]` : ""}{ ${items.join("; ")} }`;
+        }
+        if (tagName === "p") return `p ${JSON.stringify(node.textContent)}`;
+        return `${tagName} ${JSON.stringify(node.textContent)}`;
+      };
+      const structure = root ? [...root.children].map(describe) : ["<no composer>"];
+      const prompts = [];
+      const walk = (v) => {
+        if (v && typeof v === "object") {
+          for (const [k, x] of Object.entries(v)) {
+            if (k === "prompt" && typeof x === "string" && x) prompts.push(x);
+            else walk(x);
+          }
+        }
+      };
+      try {
+        walk(JSON.parse(localStorage.getItem(key) ?? "null"));
+      } catch {}
+      const toasts = document.querySelectorAll('[data-sonner-toast], [role="alert"]').length;
+      return {
+        structure,
+        draftMarkdown: prompts,
+        focused: !!root?.contains(document.activeElement),
+        toasts,
+      };
+    },
+    { sel: editorSel, key: DRAFT_KEY },
+  );
+  steps.push({ row: currentRow, t: Number(offset()), step: `${note}`, ...state });
+  await caption(`${label.toUpperCase()} · ${currentRow} · ${note}: ${state.structure.join(" | ")}`);
+  await page.waitForTimeout(900);
+  return state;
+}
+async function still(name) {
+  const file = NodePath.join(outDir, `${label}-${viewportWidth}-${theme}-${name}.png`);
+  await caption("");
+  await page.evaluate(() => document.getElementById("__ev_caption")?.remove());
+  await page
+    .locator(EDITOR)
+    .evaluate((el) => el.blur())
+    .catch(() => {});
+  await page.clock.pauseAt(FROZEN_TIME.getTime() + 60_000).catch(() => {});
+  await page.waitForTimeout(300);
+  await page.screenshot({ path: file, fullPage: true });
+  await page.clock.resume().catch(() => {});
+  steps.push({ row: currentRow, t: Number(offset()), step: `still ${NodePath.basename(file)}` });
+}
+async function reload() {
+  await step("reload page", async () => {
+    await page.reload();
+    await waitForComposer();
+  });
+}
+async function setRichText(on) {
+  await step(`Settings → rich text composer ${on ? "ON" : "OFF"}, back to thread`, async () => {
+    const threadUrl = page.url();
+    await page.evaluate(() => {
+      history.pushState({}, "", "/settings/general");
+      dispatchEvent(new PopStateEvent("popstate"));
+    });
+    const toggle = page.getByRole("switch", { name: "Rich text composer" });
+    await toggle.waitFor({ timeout: 30_000 });
+    if ((await toggle.getAttribute("aria-checked")) !== String(on)) await toggle.click();
+    await page.waitForTimeout(600);
+    await page.evaluate((u) => {
+      history.pushState({}, "", u);
+      dispatchEvent(new PopStateEvent("popstate"));
+    }, new URL(threadUrl).pathname);
+    await waitForComposer();
+  });
+}
+async function switchThreadAndBack() {
+  await step("switch to another thread and back", async () => {
+    const threadPath = new URL(page.url()).pathname;
+    const settled = page.getByText(/^Settled/).first();
+    if (await settled.isVisible().catch(() => false)) await settled.click();
+    const rows = page.locator('[data-testid="sidebar-row-slim"], [data-testid="sidebar-row-card"]');
+    const count = await rows.count();
+    for (let i = count - 1; i >= 0; i--) {
+      await rows.nth(i).click();
+      await page.waitForTimeout(800);
+      if (new URL(page.url()).pathname !== threadPath) break;
+    }
+    steps.push({
+      row: currentRow,
+      t: Number(offset()),
+      step: `  on ${new URL(page.url()).pathname}`,
+    });
+    await page.waitForTimeout(800);
+    await page.evaluate((u) => {
+      history.pushState({}, "", u);
+      dispatchEvent(new PopStateEvent("popstate"));
+    }, threadPath);
+    await waitForComposer();
+  });
+}
+
+async function f1Keys() {
+  await type("-existing text");
+  await press("Shift+Enter");
+  await type("second line");
+  await press("Control+Home");
+  await press("ArrowRight");
+  await pause();
+  await press("Space");
+  await observe("after Space");
+  await press("Control+End");
+}
+
+const ROWS = {
+  F1: async () => {
+    await reset();
+    await f1Keys();
+    await observe("end");
+  },
+  F2: async () => {
+    for (const marker of ["*", "+"]) {
+      await reset();
+      await type(" existing");
+      await press("Home");
+      await type(marker);
+      await observe(`end ${marker}`);
+    }
+    await reset();
+    await type(" existing");
+    await press("Home");
+    await type("1");
+    await observe("after 1 alone");
+    await type(")");
+    await observe("end 1)");
+  },
+  "F2-ctrl": async () => {
+    for (const marker of ["*", "+", "1.", "1)"]) {
+      await reset();
+      await type(`${marker}existing`);
+      await press("Home");
+      await press("ArrowRight", marker.length);
+      await press("Space");
+      await observe(`end ${marker}`);
+    }
+  },
+  F3: async () => {
+    for (const digit of ["3", "1"]) {
+      await reset();
+      await type(" existing");
+      await press("Home");
+      await type(digit);
+      await type(".");
+      await observe(`end ${digit}.`);
+    }
+  },
+  F4: async () => {
+    await reset();
+    await type("*x existing");
+    await press("Home");
+    await press("ArrowRight");
+    await press("Delete");
+    await observe("end");
+  },
+  F5: async () => {
+    for (const box of ["[ ]", "[x]"]) {
+      await reset();
+      await type(`-${box} existing`);
+      await press("Home");
+      await press("ArrowRight");
+      await press("Space");
+      await observe(`end (a) ${box}`);
+    }
+    await reset();
+    await type("other");
+    await press("Home");
+    await press("Shift+Enter");
+    await press("ArrowUp");
+    await type("- [ ]");
+    await observe("(b) caret on line");
+    await press("ArrowDown");
+    await observe("(b) after ArrowDown");
+  },
+  F6: async () => {
+    await reset();
+    await f1Keys();
+    await pause();
+    await press("Control+Z");
+    await observe("after undo");
+    await pause();
+    await press("Control+Shift+Z");
+    await observe("after redo");
+    await pause();
+    await press("Control+Z");
+    await observe("after second undo");
+  },
+  F7: async () => {
+    await reset();
+    await type("- ");
+    await observe("(a) after '- '");
+    await type("x");
+    await observe("(a) end");
+    await reset();
+    for (const ch of ["- [", "x", "]"]) {
+      await type(ch);
+      await observe(`(b) after ${JSON.stringify(ch)}`);
+    }
+    await press("Space");
+    await observe("(b) end");
+    await reset();
+    await type("- [l");
+    await observe("(c) after '- [l'");
+    await type("ink](url)");
+    await observe("(c) end");
+    await reset();
+    await type("- [ ]x");
+    await observe("(d) end");
+    await reset();
+    await type("-");
+    await press("ArrowRight");
+    await observe("(e) end");
+  },
+  F8: async () => {
+    await reset();
+    await type("other");
+    await press("Home");
+    await press("Shift+Enter");
+    await press("ArrowUp");
+    await type("- ");
+    await observe("run 1 caret on '- '");
+    await press("ArrowDown");
+    await observe("run 1 end");
+    await reset();
+    await type("other");
+    await press("Home");
+    await press("Shift+Enter");
+    await press("ArrowUp");
+    await type("- ");
+    await press("Home");
+    await press("Shift+Enter");
+    await observe("run 2 after split");
+    await press("ArrowUp");
+    await observe("run 2 end");
+  },
+  "F8-E1": async () => {
+    await reset();
+    await type("- ");
+    await press("Shift+Enter");
+    await observe("end");
+  },
+  F9: async () => {
+    for (const marker of ["- ", "* ", "1. ", "1) ", "- [ ] "]) {
+      await reset();
+      await type("existing text");
+      await press("Home");
+      await paste(marker);
+      await observe(`(a) pasted ${JSON.stringify(marker)}`);
+      await press("Control+Z");
+      await observe("(a) after undo");
+    }
+    for (const [sub, spaces] of [
+      ["b", " "],
+      ["c", "  "],
+    ]) {
+      await reset();
+      await type("-existing");
+      await press("Home");
+      await press("ArrowRight");
+      await pause();
+      await paste(spaces);
+      await observe(`(${sub}) after paste`);
+      await pause();
+      await press("Control+Z");
+      await observe(`(${sub}) after undo`);
+      await pause();
+      await press("Control+Shift+Z");
+      await observe(`(${sub}) after redo`);
+    }
+  },
+  F10: async () => {
+    await reset();
+    await type("text more");
+    await press("ArrowLeft", 4);
+    await type("- ");
+    await observe("(a) end");
+    await reset();
+    await type("a - b");
+    await observe("(b) end");
+    await reset();
+    await type("  - x");
+    await observe("(c) end");
+    await reset();
+    await cdpInsert("\t");
+    await type("1. x");
+    await observe("(d) end");
+  },
+  F11: async () => {
+    await reset();
+    await type("**-**existing");
+    await press("Home");
+    await press("ArrowRight");
+    await press("Space");
+    await observe("(a) end");
+    await reset();
+    await type("`-`existing");
+    await press("Home");
+    await press("ArrowRight");
+    await press("Space");
+    await observe("(b) end");
+    await reset();
+    await type("**- x**");
+    await observe("(c) typed");
+    await reload();
+    await focusComposer();
+    await press("Control+End");
+    await type(" y");
+    await observe("(c) after reload + typing");
+  },
+  F12: async () => {
+    const cases = [
+      ["a", async () => type("- outer")],
+      ["b", async () => type("> quoted")],
+      ["d", async () => type("# Title")],
+    ];
+    for (const [sub, setup] of cases) {
+      await reset();
+      await setup();
+      await press("Home");
+      await type("- ");
+      await observe(`(${sub}) end`);
+    }
+    await reset();
+    await type("```");
+    await press("Shift+Enter");
+    await type("- x");
+    await observe("(c) end");
+  },
+  F13: async () => {
+    await reset();
+    await type("second");
+    await press("Home");
+    await press("Shift+Enter");
+    await press("ArrowUp");
+    await type("- ");
+    await pause();
+    await type("x");
+    await observe("after x");
+    await pause();
+    await press("Control+Z");
+    await observe("after undo");
+    await press("ArrowDown");
+    await press("End");
+    await type(" edit");
+    await observe("end");
+  },
+  F14: async () => {
+    await reset();
+    await f1Keys();
+    await observe("converted state");
+    await switchThreadAndBack();
+    await observe("(a) after thread switch");
+    await reload();
+    await observe("(b) after reload");
+    if (stillRows.has("F14")) await still("F14-after-reload");
+    await setRichText(false);
+    await observe("(c) rich text OFF");
+    await setRichText(true);
+    await observe("(c) rich text ON again");
+  },
+  F15: async () => {
+    await reset();
+    await step("attach compositionstart/compositionend listeners", () =>
+      page.evaluate((sel) => {
+        window.__compositionEvents = [];
+        const root = document.querySelector(sel);
+        for (const name of ["compositionstart", "compositionupdate", "compositionend"])
+          root.addEventListener(name, (e) => window.__compositionEvents.push(`${name}:${e.data}`));
+      }, EDITOR),
+    );
+    const cdp = await context.newCDPSession(page);
+    await step('CDP Input.imeSetComposition "- にほんご"', () =>
+      cdp.send("Input.imeSetComposition", {
+        text: "- にほんご",
+        selectionStart: 6,
+        selectionEnd: 6,
+      }),
+    );
+    await observe("composing");
+    await step('CDP Input.imeSetComposition "- 日本語"', () =>
+      cdp.send("Input.imeSetComposition", { text: "- 日本語", selectionStart: 5, selectionEnd: 5 }),
+    );
+    await step('CDP Input.insertText "- 日本語" (commit)', () =>
+      cdp.send("Input.insertText", { text: "- 日本語" }),
+    );
+    await observe("right after commit");
+    const events = await page.evaluate(() => window.__compositionEvents);
+    steps.push({ row: currentRow, t: Number(offset()), step: "composition events", events });
+    await pause();
+    await press("End");
+    await observe("after End");
+    await press("Control+Z");
+    await observe("after undo");
+    await cdp.detach();
+  },
+  F16b: async () => {
+    const threadPath = new URL(page.url()).pathname;
+    await step("open Settings → Appearance (prompt font preview editor)", async () => {
+      await page.evaluate(() => {
+        history.pushState({}, "", "/settings/appearance");
+        dispatchEvent(new PopStateEvent("popstate"));
+      });
+      await page.locator(FONT_PREVIEW).waitFor({ timeout: 30_000 });
+      await page.locator(FONT_PREVIEW).scrollIntoViewIfNeeded();
+    });
+    editorSel = FONT_PREVIEW;
+    try {
+      await reset();
+      await f1Keys();
+      await observe("end (font preview editor)");
+    } finally {
+      editorSel = EDITOR;
+      await page.evaluate((u) => {
+        history.pushState({}, "", u);
+        dispatchEvent(new PopStateEvent("popstate"));
+      }, threadPath);
+      await waitForComposer();
+    }
+  },
+  F16a: async () => {
+    await setRichText(false);
+    await focusComposer();
+    await reset();
+    await f1Keys();
+    await observe("end (rich text OFF)");
+    await setRichText(true);
+  },
+};
+
+let failed = null;
+try {
+  await page.goto(`${baseUrl}/`);
+  await waitForComposer();
+  const toastClose = page.locator("[data-sonner-toast] button[aria-label*='lose']");
+  if (await toastClose.count())
+    await toastClose
+      .first()
+      .click()
+      .catch(() => {});
+  t0 = Date.now();
+  steps.push({ row: "-", t: 0, step: `thread ${new URL(page.url()).pathname}` });
+  for (const id of rowIds) {
+    currentRow = id;
+    const run = ROWS[id];
+    if (!run) throw new Error(`unknown row ${id}`);
+    steps.push({ row: id, t: Number(offset()), step: "ROW START" });
+    try {
+      await run();
+      if (stillRows.has(id) && id !== "F14") await still(`${id}-end`);
+    } catch (error) {
+      steps.push({ row: id, t: Number(offset()), step: `ERROR ${String(error).split("\n")[0]}` });
+    }
+  }
+  await caption(`${label.toUpperCase()} · done`);
+  await page.waitForTimeout(800);
+} catch (error) {
+  failed = error;
+} finally {
+  // Clear the composer so a leftover draft never sits in the thread.
+  await page
+    .locator(EDITOR)
+    .click()
+    .catch(() => {});
+  await page.keyboard.press("Control+A").catch(() => {});
+  await page.keyboard.press("Backspace").catch(() => {});
+  const video = page.video();
+  await context.close();
+  await browser.close();
+  const log = {
+    label,
+    viewport,
+    theme,
+    url: baseUrl,
+    frozenClock: FROZEN_TIME.toISOString(),
+    rows: rowIds,
+    steps,
+  };
+  NodeFS.writeFileSync(NodePath.join(outDir, `${base}.steps.json`), JSON.stringify(log, null, 2));
+  const md = [
+    `# ${base}`,
+    "",
+    "| row | t (s) | step | structure | draft Markdown |",
+    "|---|---|---|---|---|",
+    ...steps.map(
+      (s) =>
+        `| ${s.row} | ${s.t.toFixed(2)} | ${s.step.replace(/\|/g, "\\|")}${s.events ? ` ${JSON.stringify(s.events)}` : ""} | ${(s.structure ?? []).join(" ⏎ ").replace(/\|/g, "\\|")} | ${s.draftMarkdown ? JSON.stringify(s.draftMarkdown).replace(/\|/g, "\\|") : ""} |`,
+    ),
+  ].join("\n");
+  NodeFS.writeFileSync(NodePath.join(outDir, `${base}.steps.md`), md + "\n");
+  if (video && t0) {
+    const raw = await video.path();
+    const trimStart = ((t0 - videoStart) / 1000).toFixed(2);
+    NodeChildProcess.execFileSync("ffmpeg", [
+      "-y",
+      "-loglevel",
+      "error",
+      "-ss",
+      trimStart,
+      "-i",
+      raw,
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-preset",
+      "veryfast",
+      "-crf",
+      "26",
+      "-movflags",
+      "+faststart",
+      NodePath.join(outDir, `${base}.mp4`),
+    ]);
+    NodeFS.rmSync(NodePath.dirname(raw), { recursive: true, force: true });
+  }
+  if (failed) throw failed;
+}

From 89b7b5234af3aa057c2ba6e4c3baeca2ab9b226e Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Wed, 11 Nov 2026 05:51:50 +0000
Subject: [PATCH 5/6] fix(web): join converted list lines with neighbouring
 lists

A line converted into a list next to a compatible list now joins it, so
the editor matches the Markdown it saves. Pending conversions also flush
after an IME composition ends instead of waiting for the next edit.
Drops the evidence driver script.

AI-assisted; verified with the tests and tools listed above.
---
 apps/web/src/composer-block-shortcuts.test.ts |  72 +-
 apps/web/src/composer-rich-text-doc.ts        |  35 +-
 .../evidence/drive-composer-list-markers.mjs  | 684 ------------------
 3 files changed, 79 insertions(+), 712 deletions(-)
 delete mode 100644 scripts/evidence/drive-composer-list-markers.mjs

diff --git a/apps/web/src/composer-block-shortcuts.test.ts b/apps/web/src/composer-block-shortcuts.test.ts
index cc85589203d98..0dda9c5571c15 100644
--- a/apps/web/src/composer-block-shortcuts.test.ts
+++ b/apps/web/src/composer-block-shortcuts.test.ts
@@ -3,7 +3,7 @@ import { closeHistory, redo, undo } from "@tiptap/pm/history";
 import { splitBlock } from "@tiptap/pm/commands";
 import { TextSelection } from "@tiptap/pm/state";
 import StarterKit from "@tiptap/starter-kit";
-import { describe, expect, it, onTestFinished } from "vite-plus/test";
+import { describe, expect, it, onTestFinished, vi } from "vite-plus/test";
 
 import {
   buildDocJson,
@@ -62,6 +62,14 @@ function createEditor(value: string) {
   return editor;
 }
 
+function expectViewMatchesMarkdown(editor: Editor) {
+  const markdown = serializeEditorDoc(editor.state.doc).value;
+  const rebuilt = editor.schema.nodeFromJSON(
+    buildDocJson(markdown, (name) => ({ label: name, description: null })),
+  );
+  expect(editor.state.doc.toString()).toBe(rebuilt.toString());
+}
+
 function press(value: string, spec: string) {
   const editor = createEditor(value);
   const event = chord(spec);
@@ -115,27 +123,32 @@ describe("composer list normalization", () => {
     expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
     expect(editor.state.doc.firstChild?.firstChild?.textContent).toBe("get md");
     expect(serializeEditorDoc(editor.state.doc).value).toBe("- get md\n");
-    expect(
-      editor.state.doc.eq(
-        editor.schema.nodeFromJSON(
-          buildDocJson(serializeEditorDoc(editor.state.doc).value, (name) => ({
-            label: name,
-            description: null,
-          })),
-        ),
-      ),
-    ).toBe(true);
+    expectViewMatchesMarkdown(editor);
   });
 
-  it("converts a dash and space typed before existing text", () => {
-    const editor = createEditor("existing text");
-    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atStart(editor.state.doc)));
-    editor.view.dispatch(editor.state.tr.insertText("-"));
-    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
-    editor.view.dispatch(editor.state.tr.insertText(" "));
-    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
-    expect(editor.state.selection.$from.parentOffset).toBe(0);
-    expect(serializeEditorDoc(editor.state.doc).value).toBe("- existing text");
+  it.each([
+    ["- a\nb\n- c", "- "],
+    ["* a\nb", "* "],
+    ["1. a\nb", "2. "],
+    ["- [ ] a\nb", "- [ ] "],
+  ])("joins the converted line into the neighbouring list in %j", (value, marker) => {
+    const editor = createEditor(value);
+    let paragraph = 0;
+    editor.state.doc.forEach((node, pos) => {
+      if (node.type.name === "paragraph") paragraph = pos + 1;
+    });
+    editor.view.dispatch(editor.state.tr.insertText(marker, paragraph));
+    expect(editor.state.doc.childCount).toBe(1);
+    expectViewMatchesMarkdown(editor);
+  });
+
+  it("keeps a converted line apart from a list with another marker", () => {
+    const editor = createEditor("* a\nb");
+    editor.view.dispatch(
+      editor.state.tr.insertText("- ", editor.state.doc.firstChild!.nodeSize + 1),
+    );
+    expect(editor.state.doc.childCount).toBe(2);
+    expectViewMatchesMarkdown(editor);
   });
 
   it.each(["[link](url)", "[ordinary text]", "[x]text"])(
@@ -192,12 +205,6 @@ describe("composer list normalization", () => {
     expect(editor.state.doc.firstChild?.firstChild?.attrs.checked).toBe(true);
   });
 
-  it("normalizes pasted markers without waiting for another keystroke", () => {
-    const editor = createEditor("existing text");
-    editor.view.dispatch(editor.state.tr.insertText("- ", 1).setMeta("uiEvent", "paste"));
-    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
-  });
-
   it.each(["```\ncode\n```", "- outer\n  - inner", "> quoted"])(
     "does not convert paragraphs inside %j",
     (value) => {
@@ -228,7 +235,18 @@ describe("composer list normalization", () => {
     expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
     editor.view.dispatch(editor.state.tr.insertText("確定", 3, 6).setMeta("composition", 1));
     expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
-    editor.view.dispatch(editor.state.tr.setSelection(TextSelection.atEnd(editor.state.doc)));
+    vi.useFakeTimers();
+    onTestFinished(() => {
+      vi.useRealTimers();
+    });
+    for (const plugin of editor.state.plugins) {
+      plugin.props.handleDOMEvents?.compositionend?.call(
+        plugin,
+        editor.view,
+        new Event("compositionend") as CompositionEvent,
+      );
+    }
+    vi.runAllTimers();
     expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
     expect(serializeEditorDoc(editor.state.doc).value).toBe("- 確定");
     expect(undo(editor.state, editor.view.dispatch)).toBe(true);
diff --git a/apps/web/src/composer-rich-text-doc.ts b/apps/web/src/composer-rich-text-doc.ts
index acfe9bfa1be4e..e694f85bc4549 100644
--- a/apps/web/src/composer-rich-text-doc.ts
+++ b/apps/web/src/composer-rich-text-doc.ts
@@ -29,7 +29,7 @@ import {
   mergeAttributes,
 } from "@tiptap/core";
 import { isHistoryTransaction } from "@tiptap/pm/history";
-import { findWrapping } from "@tiptap/pm/transform";
+import { canJoin, findWrapping } from "@tiptap/pm/transform";
 import { BulletList, ListItem, OrderedList } from "@tiptap/extension-list";
 import { Strike, inputRegex as strikeInputRegex } from "@tiptap/extension-strike";
 import { TaskItem } from "@tiptap/extension-task-item";
@@ -629,6 +629,19 @@ function listNormalizationPlugin(isComposing: () => boolean) {
   const key = new PluginKey("composerListNormalization");
   return new Plugin({
     key,
+    props: {
+      handleDOMEvents: {
+        // ProseMirror tags the DOM flush after compositionend as composition, so nothing else would normalize.
+        compositionend(view) {
+          setTimeout(() => {
+            if (!view.isDestroyed && !view.composing && pending.size > 0) {
+              view.dispatch(view.state.tr);
+            }
+          });
+          return false;
+        },
+      },
+    },
     appendTransaction(transactions, oldState, state) {
       if (transactions.some(isHistoryTransaction)) {
         pending.clear();
@@ -711,6 +724,8 @@ function listNormalizationPlugin(isComposing: () => boolean) {
             : { indent: prefix.indent, marker: prefix.marker, space: prefix.space },
         );
         tr.delete(pos + 3, pos + 3 + markerLength);
+        joinCompatibleLists(tr, pos + tr.doc.nodeAt(pos)!.nodeSize);
+        joinCompatibleLists(tr, pos);
       }
       pending = new Set([...pending].map((pos) => tr.mapping.map(pos, 1)));
       return tr.docChanged ? tr : null;
@@ -718,6 +733,24 @@ function listNormalizationPlugin(isComposing: () => boolean) {
   });
 }
 
+/** Rebuilding from Markdown merges adjacent lists of one type whose markers share a delimiter. */
+function joinCompatibleLists(tr: Transaction, pos: number): void {
+  const $pos = tr.doc.resolve(pos);
+  const before = $pos.nodeBefore;
+  const after = $pos.nodeAfter;
+  const delimiter = (list: ProseMirrorNode) =>
+    String(list.firstChild?.attrs.marker ?? "").slice(-1);
+  if (
+    before &&
+    after &&
+    before.type === after.type &&
+    delimiter(before) === delimiter(after) &&
+    canJoin(tr.doc, pos)
+  ) {
+    tr.join(pos);
+  }
+}
+
 function listKey(prefix: ListLinePrefix): string {
   if (prefix.kind === "task") return "task";
   if (prefix.kind === "ordered") return `ordered:${prefix.marker.slice(-1)}`;
diff --git a/scripts/evidence/drive-composer-list-markers.mjs b/scripts/evidence/drive-composer-list-markers.mjs
deleted file mode 100644
index e292a3b7561be..0000000000000
--- a/scripts/evidence/drive-composer-list-markers.mjs
+++ /dev/null
@@ -1,684 +0,0 @@
-#!/usr/bin/env node
-// Drives the rich-text chat composer through the list-marker fixtures of PR #22997
-// (late-completed Markdown list markers) and records a self-narrating video plus a
-// per-step log, so the same keystrokes can be compared on two revisions.
-//
-// Run against a dev server that is already paired (see `vp run dev` and its pairingUrl):
-//
-//   PLAYWRIGHT_MODULE=<repo>/node_modules/.pnpm/playwright@1.60.0/node_modules/playwright/index.mjs \
-//   node drive-composer-list-markers.mjs \
-//     --base-url http://localhost:5733 --label after --viewport 1440 --theme light \
-//     --rows F1,F2,F6 --storage-state ./state-after.json --out-dir ./out [--pair-url <url>] \
-//     [--stills F1,F14] [--no-video]
-//
-// --pair-url pairs a fresh browser and writes --storage-state; later runs reuse it.
-// Outputs, per run: <label>-<viewport>-<theme>-<tag>.webm/.mp4 (trimmed to the first step),
-// a .json and .md step log with offsets from the start of the trimmed video, and, for rows
-// listed in --stills, a full-page PNG of the row's end state taken under a frozen clock.
-// Never presses plain Enter or Mod+Enter: both send the message.
-
-import * as NodeChildProcess from "node:child_process";
-import * as NodeFS from "node:fs";
-import * as NodePath from "node:path";
-
-const args = Object.fromEntries(
-  process.argv.slice(2).reduce((acc, arg, i, all) => {
-    if (!arg.startsWith("--")) return acc;
-    const next = all[i + 1];
-    acc.push([arg.slice(2), next === undefined || next.startsWith("--") ? true : next]);
-    return acc;
-  }, []),
-);
-const baseUrl = String(args["base-url"] ?? "").replace(/\/$/, "");
-const label = String(args.label ?? "run");
-const viewportWidth = Number(args.viewport ?? 1440);
-const theme = args.theme === "dark" ? "dark" : "light";
-const rowIds = String(args.rows ?? "F1")
-  .split(",")
-  .filter(Boolean);
-const stillRows = new Set(
-  String(args.stills ?? "")
-    .split(",")
-    .filter(Boolean),
-);
-const outDir = NodePath.resolve(String(args["out-dir"] ?? "./out"));
-const storageState = NodePath.resolve(String(args["storage-state"] ?? `./state-${label}.json`));
-const recordVideo = !args["no-video"];
-const tag = String(args.tag ?? rowIds.join("-"));
-const FROZEN_TIME = new Date("2026-10-22T12:00:00Z");
-const EDITOR = '[data-testid="composer-editor"]';
-const DRAFT_KEY = "t3code:composer-drafts:v1";
-const FONT_PREVIEW = '[data-testid="composer-editor"][aria-label="Prompt font preview"]';
-let editorSel = EDITOR;
-if (!baseUrl) throw new Error("--base-url is required");
-NodeFS.mkdirSync(outDir, { recursive: true });
-
-const { chromium } = await import(process.env.PLAYWRIGHT_MODULE ?? "playwright");
-const browser = await chromium.launch();
-const viewport = { width: viewportWidth, height: viewportWidth <= 500 ? 844 : 900 };
-
-if (args["pair-url"]) {
-  const ctx = await browser.newContext({ viewport });
-  const page = await ctx.newPage();
-  await page.goto(String(args["pair-url"]));
-  await page.waitForURL((u) => !u.pathname.startsWith("/pair"), { timeout: 180_000 });
-  await ctx.storageState({ path: storageState });
-  await ctx.close();
-}
-
-const base = `${label}-${viewportWidth}-${theme}-${tag}`;
-const context = await browser.newContext({
-  viewport,
-  deviceScaleFactor: 1,
-  colorScheme: theme,
-  storageState,
-  permissions: ["clipboard-read", "clipboard-write"],
-  ...(recordVideo
-    ? { recordVideo: { dir: NodePath.join(outDir, `.raw-${base}`), size: viewport } }
-    : {}),
-});
-await context.addInitScript(() => {
-  window.__caption = (text) => {
-    let el = document.getElementById("__ev_caption");
-    if (!el) {
-      el = document.createElement("div");
-      el.id = "__ev_caption";
-      el.style.cssText =
-        "position:fixed;top:8px;left:50%;transform:translateX(-50%);z-index:2147483647;" +
-        "pointer-events:none;max-width:92vw;padding:6px 12px;border-radius:8px;" +
-        "font:600 13px/1.35 ui-monospace,monospace;background:#111c;color:#fff;" +
-        "white-space:pre-wrap;box-shadow:0 2px 8px #0005";
-      document.documentElement.appendChild(el);
-    }
-    el.textContent = text;
-  };
-});
-const page = await context.newPage();
-await page.clock.install({ time: FROZEN_TIME });
-const videoStart = Date.now();
-const steps = [];
-let t0 = null;
-let currentRow = "";
-
-const offset = () => ((Date.now() - (t0 ?? Date.now())) / 1000).toFixed(2);
-async function caption(text) {
-  await page.evaluate((t) => window.__caption?.(t), text).catch(() => {});
-}
-async function step(text, fn) {
-  await caption(`${label.toUpperCase()} · ${currentRow} · ${text}`);
-  steps.push({ row: currentRow, t: Number(offset()), step: text });
-  await page.waitForTimeout(350);
-  if (fn) await fn();
-  await page.waitForTimeout(450);
-}
-const type = (text) =>
-  step(`type ${JSON.stringify(text)}`, () => page.keyboard.type(text, { delay: 70 }));
-const press = (key, times = 1) =>
-  step(times > 1 ? `${key} ×${times}` : key, async () => {
-    for (let i = 0; i < times; i++) await page.keyboard.press(key);
-  });
-const pause = (ms = 1100) =>
-  step(`pause ${ms} ms (undo group boundary)`, () => page.waitForTimeout(ms));
-const paste = (text) =>
-  step(`paste ${JSON.stringify(text)}`, async () => {
-    await page.evaluate((t) => navigator.clipboard.writeText(t), text);
-    await page.keyboard.press("Control+V");
-  });
-const cdpInsert = (text) =>
-  step(`CDP Input.insertText ${JSON.stringify(text)}`, async () => {
-    const cdp = await context.newCDPSession(page);
-    await cdp.send("Input.insertText", { text });
-    await cdp.detach();
-  });
-
-async function waitForComposer() {
-  await page.waitForSelector(EDITOR, { timeout: 240_000 });
-  await page.waitForTimeout(1500);
-}
-async function focusComposer() {
-  await page.locator(editorSel).first().click();
-}
-async function reset() {
-  await step("reset composer (Ctrl+A, Backspace)", async () => {
-    await focusComposer();
-    await page.keyboard.press("Control+A");
-    await page.keyboard.press("Backspace");
-  });
-}
-
-// Structure of the composer document plus the persisted draft Markdown.
-async function observe(note = "observe") {
-  await page.waitForTimeout(500);
-  const state = await page.evaluate(
-    ({ sel, key }) => {
-      const root = document.querySelector(sel);
-      const describe = (node) => {
-        const tagName = node.tagName.toLowerCase();
-        if (tagName === "ul" || tagName === "ol") {
-          const kind = node.getAttribute("data-type") === "taskList" ? "taskList" : tagName;
-          const start = node.getAttribute("start");
-          const items = [...node.children].map((li) => {
-            const marker = li.getAttribute("data-marker");
-            const checked = li.getAttribute("data-checked");
-            return `li${marker ? `[marker=${JSON.stringify(marker)}]` : ""}${checked ? `[checked=${checked}]` : ""} ${JSON.stringify(li.textContent)}`;
-          });
-          return `${kind}${start ? `[start=${start}]` : ""}{ ${items.join("; ")} }`;
-        }
-        if (tagName === "p") return `p ${JSON.stringify(node.textContent)}`;
-        return `${tagName} ${JSON.stringify(node.textContent)}`;
-      };
-      const structure = root ? [...root.children].map(describe) : ["<no composer>"];
-      const prompts = [];
-      const walk = (v) => {
-        if (v && typeof v === "object") {
-          for (const [k, x] of Object.entries(v)) {
-            if (k === "prompt" && typeof x === "string" && x) prompts.push(x);
-            else walk(x);
-          }
-        }
-      };
-      try {
-        walk(JSON.parse(localStorage.getItem(key) ?? "null"));
-      } catch {}
-      const toasts = document.querySelectorAll('[data-sonner-toast], [role="alert"]').length;
-      return {
-        structure,
-        draftMarkdown: prompts,
-        focused: !!root?.contains(document.activeElement),
-        toasts,
-      };
-    },
-    { sel: editorSel, key: DRAFT_KEY },
-  );
-  steps.push({ row: currentRow, t: Number(offset()), step: `${note}`, ...state });
-  await caption(`${label.toUpperCase()} · ${currentRow} · ${note}: ${state.structure.join(" | ")}`);
-  await page.waitForTimeout(900);
-  return state;
-}
-async function still(name) {
-  const file = NodePath.join(outDir, `${label}-${viewportWidth}-${theme}-${name}.png`);
-  await caption("");
-  await page.evaluate(() => document.getElementById("__ev_caption")?.remove());
-  await page
-    .locator(EDITOR)
-    .evaluate((el) => el.blur())
-    .catch(() => {});
-  await page.clock.pauseAt(FROZEN_TIME.getTime() + 60_000).catch(() => {});
-  await page.waitForTimeout(300);
-  await page.screenshot({ path: file, fullPage: true });
-  await page.clock.resume().catch(() => {});
-  steps.push({ row: currentRow, t: Number(offset()), step: `still ${NodePath.basename(file)}` });
-}
-async function reload() {
-  await step("reload page", async () => {
-    await page.reload();
-    await waitForComposer();
-  });
-}
-async function setRichText(on) {
-  await step(`Settings → rich text composer ${on ? "ON" : "OFF"}, back to thread`, async () => {
-    const threadUrl = page.url();
-    await page.evaluate(() => {
-      history.pushState({}, "", "/settings/general");
-      dispatchEvent(new PopStateEvent("popstate"));
-    });
-    const toggle = page.getByRole("switch", { name: "Rich text composer" });
-    await toggle.waitFor({ timeout: 30_000 });
-    if ((await toggle.getAttribute("aria-checked")) !== String(on)) await toggle.click();
-    await page.waitForTimeout(600);
-    await page.evaluate((u) => {
-      history.pushState({}, "", u);
-      dispatchEvent(new PopStateEvent("popstate"));
-    }, new URL(threadUrl).pathname);
-    await waitForComposer();
-  });
-}
-async function switchThreadAndBack() {
-  await step("switch to another thread and back", async () => {
-    const threadPath = new URL(page.url()).pathname;
-    const settled = page.getByText(/^Settled/).first();
-    if (await settled.isVisible().catch(() => false)) await settled.click();
-    const rows = page.locator('[data-testid="sidebar-row-slim"], [data-testid="sidebar-row-card"]');
-    const count = await rows.count();
-    for (let i = count - 1; i >= 0; i--) {
-      await rows.nth(i).click();
-      await page.waitForTimeout(800);
-      if (new URL(page.url()).pathname !== threadPath) break;
-    }
-    steps.push({
-      row: currentRow,
-      t: Number(offset()),
-      step: `  on ${new URL(page.url()).pathname}`,
-    });
-    await page.waitForTimeout(800);
-    await page.evaluate((u) => {
-      history.pushState({}, "", u);
-      dispatchEvent(new PopStateEvent("popstate"));
-    }, threadPath);
-    await waitForComposer();
-  });
-}
-
-async function f1Keys() {
-  await type("-existing text");
-  await press("Shift+Enter");
-  await type("second line");
-  await press("Control+Home");
-  await press("ArrowRight");
-  await pause();
-  await press("Space");
-  await observe("after Space");
-  await press("Control+End");
-}
-
-const ROWS = {
-  F1: async () => {
-    await reset();
-    await f1Keys();
-    await observe("end");
-  },
-  F2: async () => {
-    for (const marker of ["*", "+"]) {
-      await reset();
-      await type(" existing");
-      await press("Home");
-      await type(marker);
-      await observe(`end ${marker}`);
-    }
-    await reset();
-    await type(" existing");
-    await press("Home");
-    await type("1");
-    await observe("after 1 alone");
-    await type(")");
-    await observe("end 1)");
-  },
-  "F2-ctrl": async () => {
-    for (const marker of ["*", "+", "1.", "1)"]) {
-      await reset();
-      await type(`${marker}existing`);
-      await press("Home");
-      await press("ArrowRight", marker.length);
-      await press("Space");
-      await observe(`end ${marker}`);
-    }
-  },
-  F3: async () => {
-    for (const digit of ["3", "1"]) {
-      await reset();
-      await type(" existing");
-      await press("Home");
-      await type(digit);
-      await type(".");
-      await observe(`end ${digit}.`);
-    }
-  },
-  F4: async () => {
-    await reset();
-    await type("*x existing");
-    await press("Home");
-    await press("ArrowRight");
-    await press("Delete");
-    await observe("end");
-  },
-  F5: async () => {
-    for (const box of ["[ ]", "[x]"]) {
-      await reset();
-      await type(`-${box} existing`);
-      await press("Home");
-      await press("ArrowRight");
-      await press("Space");
-      await observe(`end (a) ${box}`);
-    }
-    await reset();
-    await type("other");
-    await press("Home");
-    await press("Shift+Enter");
-    await press("ArrowUp");
-    await type("- [ ]");
-    await observe("(b) caret on line");
-    await press("ArrowDown");
-    await observe("(b) after ArrowDown");
-  },
-  F6: async () => {
-    await reset();
-    await f1Keys();
-    await pause();
-    await press("Control+Z");
-    await observe("after undo");
-    await pause();
-    await press("Control+Shift+Z");
-    await observe("after redo");
-    await pause();
-    await press("Control+Z");
-    await observe("after second undo");
-  },
-  F7: async () => {
-    await reset();
-    await type("- ");
-    await observe("(a) after '- '");
-    await type("x");
-    await observe("(a) end");
-    await reset();
-    for (const ch of ["- [", "x", "]"]) {
-      await type(ch);
-      await observe(`(b) after ${JSON.stringify(ch)}`);
-    }
-    await press("Space");
-    await observe("(b) end");
-    await reset();
-    await type("- [l");
-    await observe("(c) after '- [l'");
-    await type("ink](url)");
-    await observe("(c) end");
-    await reset();
-    await type("- [ ]x");
-    await observe("(d) end");
-    await reset();
-    await type("-");
-    await press("ArrowRight");
-    await observe("(e) end");
-  },
-  F8: async () => {
-    await reset();
-    await type("other");
-    await press("Home");
-    await press("Shift+Enter");
-    await press("ArrowUp");
-    await type("- ");
-    await observe("run 1 caret on '- '");
-    await press("ArrowDown");
-    await observe("run 1 end");
-    await reset();
-    await type("other");
-    await press("Home");
-    await press("Shift+Enter");
-    await press("ArrowUp");
-    await type("- ");
-    await press("Home");
-    await press("Shift+Enter");
-    await observe("run 2 after split");
-    await press("ArrowUp");
-    await observe("run 2 end");
-  },
-  "F8-E1": async () => {
-    await reset();
-    await type("- ");
-    await press("Shift+Enter");
-    await observe("end");
-  },
-  F9: async () => {
-    for (const marker of ["- ", "* ", "1. ", "1) ", "- [ ] "]) {
-      await reset();
-      await type("existing text");
-      await press("Home");
-      await paste(marker);
-      await observe(`(a) pasted ${JSON.stringify(marker)}`);
-      await press("Control+Z");
-      await observe("(a) after undo");
-    }
-    for (const [sub, spaces] of [
-      ["b", " "],
-      ["c", "  "],
-    ]) {
-      await reset();
-      await type("-existing");
-      await press("Home");
-      await press("ArrowRight");
-      await pause();
-      await paste(spaces);
-      await observe(`(${sub}) after paste`);
-      await pause();
-      await press("Control+Z");
-      await observe(`(${sub}) after undo`);
-      await pause();
-      await press("Control+Shift+Z");
-      await observe(`(${sub}) after redo`);
-    }
-  },
-  F10: async () => {
-    await reset();
-    await type("text more");
-    await press("ArrowLeft", 4);
-    await type("- ");
-    await observe("(a) end");
-    await reset();
-    await type("a - b");
-    await observe("(b) end");
-    await reset();
-    await type("  - x");
-    await observe("(c) end");
-    await reset();
-    await cdpInsert("\t");
-    await type("1. x");
-    await observe("(d) end");
-  },
-  F11: async () => {
-    await reset();
-    await type("**-**existing");
-    await press("Home");
-    await press("ArrowRight");
-    await press("Space");
-    await observe("(a) end");
-    await reset();
-    await type("`-`existing");
-    await press("Home");
-    await press("ArrowRight");
-    await press("Space");
-    await observe("(b) end");
-    await reset();
-    await type("**- x**");
-    await observe("(c) typed");
-    await reload();
-    await focusComposer();
-    await press("Control+End");
-    await type(" y");
-    await observe("(c) after reload + typing");
-  },
-  F12: async () => {
-    const cases = [
-      ["a", async () => type("- outer")],
-      ["b", async () => type("> quoted")],
-      ["d", async () => type("# Title")],
-    ];
-    for (const [sub, setup] of cases) {
-      await reset();
-      await setup();
-      await press("Home");
-      await type("- ");
-      await observe(`(${sub}) end`);
-    }
-    await reset();
-    await type("```");
-    await press("Shift+Enter");
-    await type("- x");
-    await observe("(c) end");
-  },
-  F13: async () => {
-    await reset();
-    await type("second");
-    await press("Home");
-    await press("Shift+Enter");
-    await press("ArrowUp");
-    await type("- ");
-    await pause();
-    await type("x");
-    await observe("after x");
-    await pause();
-    await press("Control+Z");
-    await observe("after undo");
-    await press("ArrowDown");
-    await press("End");
-    await type(" edit");
-    await observe("end");
-  },
-  F14: async () => {
-    await reset();
-    await f1Keys();
-    await observe("converted state");
-    await switchThreadAndBack();
-    await observe("(a) after thread switch");
-    await reload();
-    await observe("(b) after reload");
-    if (stillRows.has("F14")) await still("F14-after-reload");
-    await setRichText(false);
-    await observe("(c) rich text OFF");
-    await setRichText(true);
-    await observe("(c) rich text ON again");
-  },
-  F15: async () => {
-    await reset();
-    await step("attach compositionstart/compositionend listeners", () =>
-      page.evaluate((sel) => {
-        window.__compositionEvents = [];
-        const root = document.querySelector(sel);
-        for (const name of ["compositionstart", "compositionupdate", "compositionend"])
-          root.addEventListener(name, (e) => window.__compositionEvents.push(`${name}:${e.data}`));
-      }, EDITOR),
-    );
-    const cdp = await context.newCDPSession(page);
-    await step('CDP Input.imeSetComposition "- にほんご"', () =>
-      cdp.send("Input.imeSetComposition", {
-        text: "- にほんご",
-        selectionStart: 6,
-        selectionEnd: 6,
-      }),
-    );
-    await observe("composing");
-    await step('CDP Input.imeSetComposition "- 日本語"', () =>
-      cdp.send("Input.imeSetComposition", { text: "- 日本語", selectionStart: 5, selectionEnd: 5 }),
-    );
-    await step('CDP Input.insertText "- 日本語" (commit)', () =>
-      cdp.send("Input.insertText", { text: "- 日本語" }),
-    );
-    await observe("right after commit");
-    const events = await page.evaluate(() => window.__compositionEvents);
-    steps.push({ row: currentRow, t: Number(offset()), step: "composition events", events });
-    await pause();
-    await press("End");
-    await observe("after End");
-    await press("Control+Z");
-    await observe("after undo");
-    await cdp.detach();
-  },
-  F16b: async () => {
-    const threadPath = new URL(page.url()).pathname;
-    await step("open Settings → Appearance (prompt font preview editor)", async () => {
-      await page.evaluate(() => {
-        history.pushState({}, "", "/settings/appearance");
-        dispatchEvent(new PopStateEvent("popstate"));
-      });
-      await page.locator(FONT_PREVIEW).waitFor({ timeout: 30_000 });
-      await page.locator(FONT_PREVIEW).scrollIntoViewIfNeeded();
-    });
-    editorSel = FONT_PREVIEW;
-    try {
-      await reset();
-      await f1Keys();
-      await observe("end (font preview editor)");
-    } finally {
-      editorSel = EDITOR;
-      await page.evaluate((u) => {
-        history.pushState({}, "", u);
-        dispatchEvent(new PopStateEvent("popstate"));
-      }, threadPath);
-      await waitForComposer();
-    }
-  },
-  F16a: async () => {
-    await setRichText(false);
-    await focusComposer();
-    await reset();
-    await f1Keys();
-    await observe("end (rich text OFF)");
-    await setRichText(true);
-  },
-};
-
-let failed = null;
-try {
-  await page.goto(`${baseUrl}/`);
-  await waitForComposer();
-  const toastClose = page.locator("[data-sonner-toast] button[aria-label*='lose']");
-  if (await toastClose.count())
-    await toastClose
-      .first()
-      .click()
-      .catch(() => {});
-  t0 = Date.now();
-  steps.push({ row: "-", t: 0, step: `thread ${new URL(page.url()).pathname}` });
-  for (const id of rowIds) {
-    currentRow = id;
-    const run = ROWS[id];
-    if (!run) throw new Error(`unknown row ${id}`);
-    steps.push({ row: id, t: Number(offset()), step: "ROW START" });
-    try {
-      await run();
-      if (stillRows.has(id) && id !== "F14") await still(`${id}-end`);
-    } catch (error) {
-      steps.push({ row: id, t: Number(offset()), step: `ERROR ${String(error).split("\n")[0]}` });
-    }
-  }
-  await caption(`${label.toUpperCase()} · done`);
-  await page.waitForTimeout(800);
-} catch (error) {
-  failed = error;
-} finally {
-  // Clear the composer so a leftover draft never sits in the thread.
-  await page
-    .locator(EDITOR)
-    .click()
-    .catch(() => {});
-  await page.keyboard.press("Control+A").catch(() => {});
-  await page.keyboard.press("Backspace").catch(() => {});
-  const video = page.video();
-  await context.close();
-  await browser.close();
-  const log = {
-    label,
-    viewport,
-    theme,
-    url: baseUrl,
-    frozenClock: FROZEN_TIME.toISOString(),
-    rows: rowIds,
-    steps,
-  };
-  NodeFS.writeFileSync(NodePath.join(outDir, `${base}.steps.json`), JSON.stringify(log, null, 2));
-  const md = [
-    `# ${base}`,
-    "",
-    "| row | t (s) | step | structure | draft Markdown |",
-    "|---|---|---|---|---|",
-    ...steps.map(
-      (s) =>
-        `| ${s.row} | ${s.t.toFixed(2)} | ${s.step.replace(/\|/g, "\\|")}${s.events ? ` ${JSON.stringify(s.events)}` : ""} | ${(s.structure ?? []).join(" ⏎ ").replace(/\|/g, "\\|")} | ${s.draftMarkdown ? JSON.stringify(s.draftMarkdown).replace(/\|/g, "\\|") : ""} |`,
-    ),
-  ].join("\n");
-  NodeFS.writeFileSync(NodePath.join(outDir, `${base}.steps.md`), md + "\n");
-  if (video && t0) {
-    const raw = await video.path();
-    const trimStart = ((t0 - videoStart) / 1000).toFixed(2);
-    NodeChildProcess.execFileSync("ffmpeg", [
-      "-y",
-      "-loglevel",
-      "error",
-      "-ss",
-      trimStart,
-      "-i",
-      raw,
-      "-c:v",
-      "libx264",
-      "-pix_fmt",
-      "yuv420p",
-      "-preset",
-      "veryfast",
-      "-crf",
-      "26",
-      "-movflags",
-      "+faststart",
-      NodePath.join(outDir, `${base}.mp4`),
-    ]);
-    NodeFS.rmSync(NodePath.dirname(raw), { recursive: true, force: true });
-  }
-  if (failed) throw failed;
-}

From 2f1053ae6ef0f80aa62461f184c02972c2ad16f4 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Wed, 11 Nov 2026 06:50:14 +0000
Subject: [PATCH 6/6] fix(web): keep list markers restored by Backspace literal

Backspace right after a list input rule runs Tiptap's undoInputRule, an
ordinary transaction, which normalization converted straight back. Skip
normalization for that transaction, and only queue a paragraph when an
edit reaches its marker so typing after a literal marker keeps it.

AI-assisted; verified with the tests and tools listed above.
---
 apps/web/src/composer-block-shortcuts.test.ts | 52 ++++++++++++++++++-
 apps/web/src/composer-rich-text-doc.ts        | 17 ++++--
 2 files changed, 64 insertions(+), 5 deletions(-)

diff --git a/apps/web/src/composer-block-shortcuts.test.ts b/apps/web/src/composer-block-shortcuts.test.ts
index 0dda9c5571c15..d0f369c4ff8da 100644
--- a/apps/web/src/composer-block-shortcuts.test.ts
+++ b/apps/web/src/composer-block-shortcuts.test.ts
@@ -1,4 +1,4 @@
-import { Editor } from "@tiptap/core";
+import { Editor, Extension, InputRule, type Extensions } from "@tiptap/core";
 import { closeHistory, redo, undo } from "@tiptap/pm/history";
 import { splitBlock } from "@tiptap/pm/commands";
 import { TextSelection } from "@tiptap/pm/state";
@@ -34,7 +34,7 @@ function chord(spec: string) {
   } as unknown as KeyboardEvent;
 }
 
-function createEditor(value: string) {
+function createEditor(value: string, extra: Extensions = []) {
   const editor = new Editor({
     extensions: [
       StarterKit.configure({
@@ -52,6 +52,7 @@ function createEditor(value: string) {
       ...ComposerListExtensions,
       ComposerTaskListExtension,
       ComposerTaskItemExtension,
+      ...extra,
     ],
     content: buildDocJson(value, (name) => ({ label: name, description: null })),
   });
@@ -268,6 +269,53 @@ describe("composer list normalization", () => {
     expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
   });
 
+  it("keeps the literal marker that Backspace restores from a list input rule", () => {
+    // Mirrors the composer's `- ` + first character rule; the test editor keeps Tiptap's `- ` rule.
+    const dashRule = Extension.create({
+      name: "dashRule",
+      addInputRules() {
+        return [
+          new InputRule({
+            find: /^- (?<carried>\S)$/,
+            handler: ({ range, match, chain }) => {
+              chain()
+                .deleteRange(range)
+                .wrapInList("bulletList")
+                .command(({ tr }) => {
+                  tr.insertText(match.groups?.carried ?? "");
+                  return true;
+                })
+                .run();
+            },
+          }),
+        ];
+      },
+    });
+    const editor = createEditor("", [dashRule]);
+    const type = (text: string) => {
+      const { from, to } = editor.state.selection;
+      const insert = () => editor.state.tr.insertText(text, from, to);
+      const handled = editor.state.plugins.some((plugin) =>
+        plugin.props.handleTextInput?.call(plugin, editor.view, from, to, text, insert),
+      );
+      if (!handled) editor.view.dispatch(editor.state.tr.insertText(text, from, to));
+    };
+    editor.view.dispatch(editor.state.tr.insertText("- "));
+    type("g");
+    expect(editor.state.doc.firstChild?.type.name).toBe("bulletList");
+    const backspace = chord("Backspace");
+    expect(
+      editor.state.plugins.some((plugin) =>
+        plugin.props.handleKeyDown?.call(plugin, editor.view, backspace),
+      ),
+    ).toBe(true);
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(editor.state.doc.textContent).toBe("- g");
+    type("o");
+    expect(editor.state.doc.firstChild?.type.name).toBe("paragraph");
+    expect(editor.state.doc.textContent).toBe("- go");
+  });
+
   it("preserves formatting and the caret when removing the literal prefix", () => {
     const editor = createEditor("**text**");
     editor.view.dispatch(editor.state.tr.insert(1, editor.schema.text("- ")));
diff --git a/apps/web/src/composer-rich-text-doc.ts b/apps/web/src/composer-rich-text-doc.ts
index e694f85bc4549..6d308cd9226e1 100644
--- a/apps/web/src/composer-rich-text-doc.ts
+++ b/apps/web/src/composer-rich-text-doc.ts
@@ -643,7 +643,11 @@ function listNormalizationPlugin(isComposing: () => boolean) {
       },
     },
     appendTransaction(transactions, oldState, state) {
-      if (transactions.some(isHistoryTransaction)) {
+      // Tiptap's undoInputRule (Backspace right after a rule) restores the typed text on purpose.
+      const undoesInputRule = oldState.plugins.some(
+        (plugin) => plugin.spec.isInputRules && plugin.getState(oldState),
+      );
+      if (undoesInputRule || transactions.some(isHistoryTransaction)) {
         pending.clear();
         return null;
       }
@@ -657,7 +661,10 @@ function listNormalizationPlugin(isComposing: () => boolean) {
       );
       for (const { newRange } of getChangedRanges(changes)) {
         state.doc.nodesBetween(newRange.from, newRange.to, (node, pos) => {
-          if (node.type.name === "paragraph") pending.add(pos);
+          if (node.type.name !== "paragraph") return false;
+          const parsed = parseListPrefix(paragraphText(node));
+          // Typing after a marker left literal keeps it literal; only an edit reaching the marker converts.
+          if (parsed && newRange.from <= pos + 1 + parsed.markerLength) pending.add(pos);
           return false;
         });
       }
@@ -671,7 +678,7 @@ function listNormalizationPlugin(isComposing: () => boolean) {
         if (state.doc.resolve(pos).depth !== 0) continue;
         const node = state.doc.nodeAt(pos);
         if (node?.type.name !== "paragraph") continue;
-        const text = node.textBetween(0, node.content.size, undefined, "\ufffc");
+        const text = paragraphText(node);
         const parsed = parseListPrefix(text);
         // Input rules only introduce unindented top-level lists; keep the same boundary here.
         if (!parsed || parsed.prefix.indent) continue;
@@ -733,6 +740,10 @@ function listNormalizationPlugin(isComposing: () => boolean) {
   });
 }
 
+function paragraphText(node: ProseMirrorNode): string {
+  return node.textBetween(0, node.content.size, undefined, "\ufffc");
+}
+
 /** Rebuilding from Markdown merges adjacent lists of one type whose markers share a delimiter. */
 function joinCompatibleLists(tr: Transaction, pos: number): void {
   const $pos = tr.doc.resolve(pos);