diff --git a/AGENTS.md b/AGENTS.md
index 9d81bd25d..f785f4cff 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -552,6 +552,36 @@ Shared instructions for all AI agents (Claude, Codex, etc.).
     file would be minutes for nothing. Measured clean on adoption, so it is a
     hard failure with no allowlist.
 
+  - **The markdown parser's hostile-input cost is linear, and three layers keep
+    it that way (#1407).** The weekly pathological soak never got past its fifth
+    input class: `a](` × 24000 took 60s to parse and 276s to serialize, and
+    `backtick-runs` ran over twelve minutes. Every cause was an O(n²) or worse
+    walk inside micromark or mdast-util-to-markdown (latest releases), plus one
+    in VMark's own escape scan.
+
+    - `src/utils/markdownPipeline/parser/fastPaths/` — micromark constructs that
+      settle `]` and backtick runs nothing can close, acting only on a PROOF
+      that micromark's own construct would fail, plus micromark's emphasis
+      resolver ported with a per-marker opener list in place of its event
+      walk. `inlineFastPaths.test.ts` diffs the mdast, positions included,
+      against a parser without them over every spec corpus and a fuzz.
+    - `patches/` — `pnpm` patches for the two costs no extension API can reach
+      (micromark's data-token merge, mdast-util-to-markdown's escape lookup).
+      Each is a few lines, commented at the change. **A Dependabot bump of
+      either package fails install until the patch is re-made** (`pnpm patch`
+      → port the change → `pnpm patch-commit`), and that failure is the point:
+      a patch that silently stopped applying would bring the quadratic back.
+    - `__tests__/pathological/pathologicalScaling.test.ts` — asserts a CPU-time
+      growth EXPONENT per class in the PR tier, so a regression fails
+      `check:all` instead of waiting for the soak.
+
+    The whole scale-8 pathological run now takes ~11s (measured 10.8s idle).
+    Two classes stay super-linear, and are what is left of it:
+    `nested-strong-emph` (~5s — micromark re-resolves each matched span, and
+    each match splices the event list) and `nested-brackets` (~2s — label-end
+    serializes the label to look up a definition). Removing either changes
+    what the stock algorithm does, not how fast it finds it.
+
   - **i18n gate has two halves.** `pnpm lint:i18n` checks that every key exists in
     every locale AND that values were actually translated. The second half exists
     because the first cannot see a key copied over with its English value — ~1,160
diff --git a/package.json b/package.json
index 1b1c622dd..14ae816ea 100644
--- a/package.json
+++ b/package.json
@@ -218,6 +218,10 @@
       "js-yaml@4": ">=4.3.2 <5",
       "baseline-browser-mapping": ">=2.11.0 <3",
       "smol-toml": ">=1.7.1 <2"
+    },
+    "patchedDependencies": {
+      "micromark@4.0.2": "patches/micromark@4.0.2.patch",
+      "mdast-util-to-markdown@2.1.2": "patches/mdast-util-to-markdown@2.1.2.patch"
     }
   },
   "devDependencies": {
diff --git a/patches/mdast-util-to-markdown@2.1.2.patch b/patches/mdast-util-to-markdown@2.1.2.patch
new file mode 100644
index 000000000..aff5925de
--- /dev/null
+++ b/patches/mdast-util-to-markdown@2.1.2.patch
@@ -0,0 +1,17 @@
+diff --git a/lib/util/safe.js b/lib/util/safe.js
+index 456fe215ae3d032ffaea4590f0d097bcb9195619..10f82c99cff8123142f230c087e6d09742f2b313 100644
+--- a/lib/util/safe.js
++++ b/lib/util/safe.js
+@@ -56,7 +56,11 @@ export function safe(state, input, config) {
+       const after = 'after' in pattern
+       const position = match.index + (before ? match[1].length : 0)
+ 
+-      if (positions.includes(position)) {
++      // VMark patch (#1407): `infos` gains a key exactly when `positions`
++      // gains the position, so an own-key check is the same test in O(1).
++      // `positions.includes` made escaping O(escapes²) — a text node of 116k
++      // backticks took 15s to serialize.
++      if (Object.hasOwn(infos, position)) {
+         if (infos[position].before && !before) {
+           infos[position].before = false
+         }
diff --git a/patches/micromark@4.0.2.patch b/patches/micromark@4.0.2.patch
new file mode 100644
index 000000000..aa6e4cff8
--- /dev/null
+++ b/patches/micromark@4.0.2.patch
@@ -0,0 +1,121 @@
+diff --git a/dev/lib/initialize/text.js b/dev/lib/initialize/text.js
+index 7192e70a0972e808d779999e57153bf3ed7bfc3a..0eaba5658038c8f1885f1279b8f30ba720a72d65 100644
+--- a/dev/lib/initialize/text.js
++++ b/dev/lib/initialize/text.js
+@@ -113,30 +113,39 @@ function createResolver(extraResolver) {
+ 
+   /** @type {Resolver} */
+   function resolveAllText(events, context) {
+-    let index = -1
+-    /** @type {number | undefined} */
+-    let enter
+-
+     // A rather boring computation (to merge adjacent `data` events) which
+     // improves mm performance by 29%.
+-    while (++index <= events.length) {
+-      if (enter === undefined) {
+-        if (events[index] && events[index][1].type === types.data) {
+-          enter = index
+-          index++
+-        }
+-      } else if (!events[index] || events[index][1].type !== types.data) {
+-        // Don’t do anything if there is one data token.
+-        if (index !== enter + 2) {
+-          events[enter][1].end = events[index - 1][1].end
+-          events.splice(enter + 2, index - enter - 2)
+-          index = enter + 2
+-        }
+-
+-        enter = undefined
++    //
++    // VMark patch (#1407): merge in ONE compacting pass. The original removed
++    // each run with `events.splice`, moving every later event once per run —
++    // O(runs × events), and ~10× slower per step once the list outgrows V8's
++    // regular heap objects. The kept events, the merged token's `end`, and the
++    // returned array are identical.
++    const length = events.length
++    let write = 0
++    let index = 0
++
++    while (index < length) {
++      const event = events[index]
++
++      if (event[1].type !== types.data) {
++        events[write++] = event
++        index++
++        continue
+       }
++
++      // The enter's own exit is at `index + 1`; a run continues from there.
++      let end = index + 2
++      while (end < length && events[end][1].type === types.data) end++
++      // Don’t do anything if there is one data token.
++      if (end !== index + 2) event[1].end = events[end - 1][1].end
++      events[write++] = event
++      if (index + 1 < length) events[write++] = events[index + 1]
++      index = end
+     }
+ 
++    events.length = write
++
+     return extraResolver ? extraResolver(events, context) : events
+   }
+ }
+diff --git a/lib/initialize/text.js b/lib/initialize/text.js
+index b9383cb721b95c68bd0e684da6cbf441ed82b8eb..eac1239a4263cd6945fc36b8db8bb1927659d6f7 100644
+--- a/lib/initialize/text.js
++++ b/lib/initialize/text.js
+@@ -104,28 +104,35 @@ function createResolver(extraResolver) {
+ 
+   /** @type {Resolver} */
+   function resolveAllText(events, context) {
+-    let index = -1;
+-    /** @type {number | undefined} */
+-    let enter;
+-
+     // A rather boring computation (to merge adjacent `data` events) which
+     // improves mm performance by 29%.
+-    while (++index <= events.length) {
+-      if (enter === undefined) {
+-        if (events[index] && events[index][1].type === "data") {
+-          enter = index;
+-          index++;
+-        }
+-      } else if (!events[index] || events[index][1].type !== "data") {
+-        // Don’t do anything if there is one data token.
+-        if (index !== enter + 2) {
+-          events[enter][1].end = events[index - 1][1].end;
+-          events.splice(enter + 2, index - enter - 2);
+-          index = enter + 2;
+-        }
+-        enter = undefined;
++    //
++    // VMark patch (#1407): merge in ONE compacting pass. The original removed
++    // each run with `events.splice`, moving every later event once per run —
++    // O(runs × events), and ~10× slower per step once the list outgrows V8's
++    // regular heap objects. The kept events, the merged token's `end`, and the
++    // returned array are identical.
++    const length = events.length;
++    let write = 0;
++    let index = 0;
++    while (index < length) {
++      const event = events[index];
++      if (event[1].type !== "data") {
++        events[write++] = event;
++        index++;
++        continue;
+       }
++
++      // The enter's own exit is at `index + 1`; a run continues from there.
++      let end = index + 2;
++      while (end < length && events[end][1].type === "data") end++;
++      // Don’t do anything if there is one data token.
++      if (end !== index + 2) event[1].end = events[end - 1][1].end;
++      events[write++] = event;
++      if (index + 1 < length) events[write++] = events[index + 1];
++      index = end;
+     }
++    events.length = write;
+     return extraResolver ? extraResolver(events, context) : events;
+   }
+ }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 911c870fb..1423b900c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -30,6 +30,14 @@ overrides:
   baseline-browser-mapping: '>=2.11.0 <3'
   smol-toml: '>=1.7.1 <2'
 
+patchedDependencies:
+  mdast-util-to-markdown@2.1.2:
+    hash: 2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf
+    path: patches/mdast-util-to-markdown@2.1.2.patch
+  micromark@4.0.2:
+    hash: c4162f5915a6a3308e12ec56d2a8ef6a3a9cbaa7abea611d0ce5957fc4f620ea
+    path: patches/micromark@4.0.2.patch
+
 importers:
 
   .:
@@ -16614,7 +16622,7 @@ snapshots:
 
   markdownlint@0.41.1:
     dependencies:
-      micromark: 4.0.2
+      micromark: 4.0.2(patch_hash=c4162f5915a6a3308e12ec56d2a8ef6a3a9cbaa7abea611d0ce5957fc4f620ea)
       micromark-core-commonmark: 2.0.3
       micromark-extension-directive: 4.0.0
       micromark-extension-gfm-autolink-literal: 2.1.0
@@ -16687,7 +16695,7 @@ snapshots:
       decode-named-character-reference: 1.3.0
       devlop: 1.1.0
       mdast-util-to-string: 4.0.0
-      micromark: 4.0.2
+      micromark: 4.0.2(patch_hash=c4162f5915a6a3308e12ec56d2a8ef6a3a9cbaa7abea611d0ce5957fc4f620ea)
       micromark-util-decode-numeric-character-reference: 2.0.2
       micromark-util-decode-string: 2.0.1
       micromark-util-normalize-identifier: 2.0.1
@@ -16703,7 +16711,7 @@ snapshots:
       devlop: 1.1.0
       escape-string-regexp: 5.0.0
       mdast-util-from-markdown: 2.0.3
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
       micromark-extension-frontmatter: 2.0.0
     transitivePeerDependencies:
       - supports-color
@@ -16721,7 +16729,7 @@ snapshots:
       '@types/mdast': 4.0.4
       devlop: 1.1.0
       mdast-util-from-markdown: 2.0.3
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
       micromark-util-normalize-identifier: 2.0.1
     transitivePeerDependencies:
       - supports-color
@@ -16730,7 +16738,7 @@ snapshots:
     dependencies:
       '@types/mdast': 4.0.4
       mdast-util-from-markdown: 2.0.3
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
     transitivePeerDependencies:
       - supports-color
 
@@ -16740,7 +16748,7 @@ snapshots:
       devlop: 1.1.0
       markdown-table: 3.0.4
       mdast-util-from-markdown: 2.0.3
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
     transitivePeerDependencies:
       - supports-color
 
@@ -16749,7 +16757,7 @@ snapshots:
       '@types/mdast': 4.0.4
       devlop: 1.1.0
       mdast-util-from-markdown: 2.0.3
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
     transitivePeerDependencies:
       - supports-color
 
@@ -16761,7 +16769,7 @@ snapshots:
       mdast-util-gfm-strikethrough: 2.0.0
       mdast-util-gfm-table: 2.0.0
       mdast-util-gfm-task-list-item: 2.0.0
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
     transitivePeerDependencies:
       - supports-color
 
@@ -16772,7 +16780,7 @@ snapshots:
       devlop: 1.1.0
       longest-streak: 3.1.0
       mdast-util-from-markdown: 2.0.3
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
       unist-util-remove-position: 5.0.0
     transitivePeerDependencies:
       - supports-color
@@ -16799,7 +16807,7 @@ snapshots:
       unist-util-visit: 5.1.0
       vfile: 6.0.3
 
-  mdast-util-to-markdown@2.1.2:
+  mdast-util-to-markdown@2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf):
     dependencies:
       '@types/mdast': 4.0.4
       '@types/unist': 3.0.3
@@ -17047,7 +17055,7 @@ snapshots:
 
   micromark-util-types@2.0.2: {}
 
-  micromark@4.0.2:
+  micromark@4.0.2(patch_hash=c4162f5915a6a3308e12ec56d2a8ef6a3a9cbaa7abea611d0ce5957fc4f620ea):
     dependencies:
       '@types/debug': 4.1.13
       debug: 4.4.3
@@ -17976,7 +17984,7 @@ snapshots:
   remark-stringify@11.0.0:
     dependencies:
       '@types/mdast': 4.0.4
-      mdast-util-to-markdown: 2.1.2
+      mdast-util-to-markdown: 2.1.2(patch_hash=2dbee866e6cf244b099fa367885b1e8ad51ff315b895c1ad77581dee0f4206bf)
       unified: 11.0.5
 
   require-directory@2.1.1: {}
diff --git a/src/components/Editor/TiptapEditor.callbacks.test.tsx b/src/components/Editor/TiptapEditor.callbacks.test.tsx
index 84f719eba..d977024a1 100644
--- a/src/components/Editor/TiptapEditor.callbacks.test.tsx
+++ b/src/components/Editor/TiptapEditor.callbacks.test.tsx
@@ -42,6 +42,7 @@ const mocks = vi.hoisted(() => ({
   })),
   useWindowLabel: vi.fn(() => "main"),
   consumeWysiwygPendingNav: vi.fn(() => false),
+  reportUnparseableDocument: vi.fn(),
   // Mock editor returned by useEditor
   mockEditor: null as ReturnType<typeof createMockEditor> | null,
   useEditor: vi.fn(),
@@ -208,7 +209,7 @@ vi.mock("@/stores/documentStore", () => ({
   },
   useRevisionStore: { getState: () => ({ registerEdit: vi.fn(), setRevision: vi.fn(), getRevision: vi.fn(() => null) }) },
   generateRevisionId: () => "rev-test-id",
-  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false }), subscribe: () => () => {} },
+  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false, forcedSourceReason: () => undefined }), subscribe: () => () => {} },
   useUnifiedHistoryStore: { getState: () => ({ documents: {}, createCheckpoint: vi.fn() }), subscribe: () => () => {} },
   useLintStore: { getState: () => ({ diagnosticsByTab: {}, selectedIndexByTab: {}, clearDiagnostics: vi.fn() }), subscribe: () => () => {} },
   useFileLoadStore: { getState: () => ({ active: false }) },
@@ -218,6 +219,10 @@ vi.mock("./wysiwygPendingNav", () => ({
   consumeWysiwygPendingNav: (...args: unknown[]) => mocks.consumeWysiwygPendingNav(...args),
 }));
 
+vi.mock("@/services/editor/unparseableDocument", () => ({
+  reportUnparseableDocument: (...args: unknown[]) => mocks.reportUnparseableDocument(...args),
+}));
+
 vi.mock("./ImageContextMenu", () => ({
   ImageContextMenu: ({ onAction }: { onAction: (a: string) => void }) => (
     <button data-testid="image-ctx" onClick={() => onAction("test")} />
@@ -402,15 +407,17 @@ describe("syncMarkdownToEditor — via onCreate", () => {
     expect(mockTr.setMeta).toHaveBeenCalledWith("addToHistory", false);
   });
 
-  it("handles parse failure in syncMarkdownToEditor gracefully", () => {
+  it("reports an initial parse failure for this tab instead of leaving a blank editor (#1407)", () => {
     const editor = createMockEditor();
     mocks.useEditor.mockReturnValue(editor);
     mocks.getTiptapEditorView.mockReturnValue(null);
+    mocks.reportUnparseableDocument.mockReset();
 
     const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
 
     // parseMarkdown throws
-    mocks.parseMarkdown.mockImplementation(() => { throw new Error("parse fail"); });
+    const failure = new Error("parse fail");
+    mocks.parseMarkdown.mockImplementation(() => { throw failure; });
 
     render(<TiptapEditorInner hidden={false} />);
     const config = mocks.useEditor.mock.calls[mocks.useEditor.mock.calls.length - 1][0];
@@ -421,6 +428,85 @@ describe("syncMarkdownToEditor — via onCreate", () => {
     vi.runAllTimers(); // flush pending timers to prevent bleed into next test
     vi.useRealTimers();
     errorSpy.mockRestore();
+
+    // The failure reaches the user (and Source mode), with the real error so
+    // a nesting refusal can say how deep the document was.
+    expect(mocks.reportUnparseableDocument).toHaveBeenCalledWith("tab-1", failure);
+  });
+
+  it("does not report from a HIDDEN keep-alive editor — it reports when shown (#1407)", () => {
+    // A hidden instance shows the user nothing and takes no edits. Reporting
+    // from it would put a tab the user is reading in Source mode, with a toast,
+    // for a WYSIWYG view they have not asked for; its visibility sync re-parses
+    // and reports if they ever do.
+    const editor = createMockEditor();
+    mocks.useEditor.mockReturnValue(editor);
+    mocks.getTiptapEditorView.mockReturnValue(null);
+    mocks.reportUnparseableDocument.mockReset();
+    mocks.parseMarkdown.mockImplementation(() => { throw new Error("parse fail"); });
+
+    render(<TiptapEditorInner hidden={true} />);
+    const config = mocks.useEditor.mock.calls[mocks.useEditor.mock.calls.length - 1][0];
+    vi.useFakeTimers();
+    config.onCreate({ editor });
+    vi.runAllTimers();
+    vi.useRealTimers();
+
+    expect(mocks.reportUnparseableDocument).not.toHaveBeenCalled();
+  });
+
+  it("does not report a refused content DRIFT from a hidden editor either (#1407, audit round 2)", () => {
+    // The first parse succeeds, the document changes before the deferred work
+    // runs, and the drift re-sync is refused — while the editor is still hidden.
+    const editor = createMockEditor();
+    mocks.useEditor.mockReturnValue(editor);
+    mocks.getTiptapEditorView.mockReturnValue(null);
+    mocks.reportUnparseableDocument.mockReset();
+    mocks.parseMarkdown
+      .mockImplementationOnce(() => ({ type: "doc", content: [] }))
+      .mockImplementationOnce(() => { throw new Error("refused drift"); });
+    mocks.useDocumentContent.mockReturnValue("initial");
+
+    const { rerender } = render(<TiptapEditorInner hidden={true} />);
+    const config = mocks.useEditor.mock.calls[mocks.useEditor.mock.calls.length - 1][0];
+    vi.useFakeTimers();
+    config.onCreate({ editor });
+    mocks.useDocumentContent.mockReturnValue("> refused");
+    rerender(<TiptapEditorInner hidden={true} />);
+    vi.runAllTimers();
+    vi.useRealTimers();
+    mocks.useDocumentContent.mockReturnValue("# hello");
+
+    expect(mocks.reportUnparseableDocument).not.toHaveBeenCalled();
+  });
+
+  it("parses the LATEST content, not a refused snapshot the user already replaced (#1407, audit round 3)", () => {
+    // Mounted with a document the parser refuses; before the deferred parse
+    // runs, the content is repaired and the editor shown. Reporting the stale
+    // snapshot would put the repaired document in Source mode, empty.
+    const editor = createMockEditor();
+    mocks.useEditor.mockReturnValue(editor);
+    mocks.getTiptapEditorView.mockReturnValue(null);
+    mocks.reportUnparseableDocument.mockReset();
+    mocks.parseMarkdown.mockReset();
+    mocks.parseMarkdown
+      .mockImplementationOnce(() => { throw new Error("refused snapshot"); })
+      .mockImplementation(() => ({ type: "doc", content: [] }));
+    mocks.useDocumentContent.mockReturnValue("> refused");
+
+    const { rerender } = render(<TiptapEditorInner hidden={true} />);
+    const config = mocks.useEditor.mock.calls[mocks.useEditor.mock.calls.length - 1][0];
+    vi.useFakeTimers();
+    config.onCreate({ editor });
+    mocks.useDocumentContent.mockReturnValue("# repaired");
+    rerender(<TiptapEditorInner hidden={false} />);
+    vi.runAllTimers();
+    vi.useRealTimers();
+    mocks.useDocumentContent.mockReturnValue("# hello");
+    mocks.parseMarkdown.mockReset();
+    mocks.parseMarkdown.mockImplementation(() => ({ type: "doc", content: [] }));
+
+    expect(mocks.reportUnparseableDocument).not.toHaveBeenCalled();
   });
 });
 
diff --git a/src/components/Editor/TiptapEditor.lifecycle.test.tsx b/src/components/Editor/TiptapEditor.lifecycle.test.tsx
index 54951942e..fa6998997 100644
--- a/src/components/Editor/TiptapEditor.lifecycle.test.tsx
+++ b/src/components/Editor/TiptapEditor.lifecycle.test.tsx
@@ -208,7 +208,7 @@ vi.mock("@/stores/documentStore", () => ({
   },
   useRevisionStore: { getState: () => ({ registerEdit: vi.fn(), setRevision: vi.fn(), getRevision: vi.fn(() => null) }) },
   generateRevisionId: () => "rev-test-id",
-  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false }), subscribe: () => () => {} },
+  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false, forcedSourceReason: () => undefined }), subscribe: () => () => {} },
   useUnifiedHistoryStore: { getState: () => ({ documents: {}, createCheckpoint: vi.fn() }), subscribe: () => () => {} },
   useLintStore: { getState: () => ({ diagnosticsByTab: {}, selectedIndexByTab: {}, clearDiagnostics: vi.fn() }), subscribe: () => () => {} },
   useFileLoadStore: { getState: () => ({ active: false }) },
diff --git a/src/components/Editor/TiptapEditor.sync.test.tsx b/src/components/Editor/TiptapEditor.sync.test.tsx
index 4250ce1d1..b9370449f 100644
--- a/src/components/Editor/TiptapEditor.sync.test.tsx
+++ b/src/components/Editor/TiptapEditor.sync.test.tsx
@@ -42,6 +42,7 @@ const mocks = vi.hoisted(() => ({
   })),
   useWindowLabel: vi.fn(() => "main"),
   consumeWysiwygPendingNav: vi.fn(() => false),
+  reportUnparseableDocument: vi.fn(),
   // Mock editor returned by useEditor
   mockEditor: null as ReturnType<typeof createMockEditor> | null,
   useEditor: vi.fn(),
@@ -208,7 +209,7 @@ vi.mock("@/stores/documentStore", () => ({
   },
   useRevisionStore: { getState: () => ({ registerEdit: vi.fn(), setRevision: vi.fn(), getRevision: vi.fn(() => null) }) },
   generateRevisionId: () => "rev-test-id",
-  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false }), subscribe: () => () => {} },
+  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false, forcedSourceReason: () => undefined }), subscribe: () => () => {} },
   useUnifiedHistoryStore: { getState: () => ({ documents: {}, createCheckpoint: vi.fn() }), subscribe: () => () => {} },
   useLintStore: { getState: () => ({ diagnosticsByTab: {}, selectedIndexByTab: {}, clearDiagnostics: vi.fn() }), subscribe: () => () => {} },
   useFileLoadStore: { getState: () => ({ active: false }) },
@@ -218,6 +219,10 @@ vi.mock("./wysiwygPendingNav", () => ({
   consumeWysiwygPendingNav: (...args: unknown[]) => mocks.consumeWysiwygPendingNav(...args),
 }));
 
+vi.mock("@/services/editor/unparseableDocument", () => ({
+  reportUnparseableDocument: (...args: unknown[]) => mocks.reportUnparseableDocument(...args),
+}));
+
 vi.mock("./ImageContextMenu", () => ({
   ImageContextMenu: ({ onAction }: { onAction: (a: string) => void }) => (
     <button data-testid="image-ctx" onClick={() => onAction("test")} />
@@ -316,20 +321,17 @@ describe("TiptapEditorInner — external content sync effect", () => {
     vi.useRealTimers();
 
     // Set up error scenario (mockImplementationOnce prevents leaking into next test)
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    mocks.parseMarkdown.mockImplementationOnce(() => { throw new Error("sync fail"); });
+    mocks.reportUnparseableDocument.mockReset();
+    const failure = new Error("sync fail");
+    mocks.parseMarkdown.mockImplementationOnce(() => { throw failure; });
     mocks.useDocumentContent.mockReturnValue("# broken");
 
     rerender(<TiptapEditorInner hidden={false} />);
 
-    // Content sync effect fires synchronously (content "# broken" != "# initial", initialized=true)
-    // tiptapError logs as: ("[Tiptap]", " Failed to sync markdown:", error)
-    expect(errorSpy).toHaveBeenCalledWith(
-      "[Tiptap]",
-      expect.stringContaining("Failed to sync markdown"),
-      expect.any(Error)
-    );
-    errorSpy.mockRestore();
+    // Content sync effect fires synchronously (content "# broken" != "# initial", initialized=true).
+    // The failure is reported for this tab (#1407) — Source mode and a message —
+    // instead of only a dev-build log over an editor still showing old content.
+    expect(mocks.reportUnparseableDocument).toHaveBeenCalledWith("tab-1", failure);
   });
 
   it("sets cursor to start when synced without cursor info", () => {
diff --git a/src/components/Editor/TiptapEditor.test.tsx b/src/components/Editor/TiptapEditor.test.tsx
index 70cc0ab97..a37502d10 100644
--- a/src/components/Editor/TiptapEditor.test.tsx
+++ b/src/components/Editor/TiptapEditor.test.tsx
@@ -40,6 +40,7 @@ const mocks = vi.hoisted(() => ({
   })),
   useWindowLabel: vi.fn(() => "main"),
   consumeWysiwygPendingNav: vi.fn(() => false),
+  reportUnparseableDocument: vi.fn(),
   // Mock editor returned by useEditor
   mockEditor: null as ReturnType<typeof createMockEditor> | null,
   useEditor: vi.fn(),
@@ -206,7 +207,7 @@ vi.mock("@/stores/documentStore", () => ({
   },
   useRevisionStore: { getState: () => ({ registerEdit: vi.fn(), setRevision: vi.fn(), getRevision: vi.fn(() => null) }) },
   generateRevisionId: () => "rev-test-id",
-  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false }), subscribe: () => () => {} },
+  useLargeFileSessionStore: { getState: () => ({ isForcedSource: () => false, forcedSourceReason: () => undefined }), subscribe: () => () => {} },
   useUnifiedHistoryStore: { getState: () => ({ documents: {}, createCheckpoint: vi.fn() }), subscribe: () => () => {} },
   useLintStore: { getState: () => ({ diagnosticsByTab: {}, selectedIndexByTab: {}, clearDiagnostics: vi.fn() }), subscribe: () => () => {} },
   useFileLoadStore: { getState: () => ({ active: false }) },
@@ -216,6 +217,10 @@ vi.mock("./wysiwygPendingNav", () => ({
   consumeWysiwygPendingNav: (...args: unknown[]) => mocks.consumeWysiwygPendingNav(...args),
 }));
 
+vi.mock("@/services/editor/unparseableDocument", () => ({
+  reportUnparseableDocument: (...args: unknown[]) => mocks.reportUnparseableDocument(...args),
+}));
+
 vi.mock("./ImageContextMenu", () => ({
   ImageContextMenu: ({ onAction }: { onAction: (a: string) => void }) => (
     <button data-testid="image-ctx" onClick={() => onAction("test")} />
@@ -434,8 +439,9 @@ describe("TiptapEditorInner — onCreate behavior", () => {
   });
 
   it("handles parseMarkdown failure in onCreate gracefully", () => {
+    const failure = new Error("Parse error");
     mocks.parseMarkdown.mockImplementationOnce(() => {
-      throw new Error("Parse error");
+      throw failure;
     });
     const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     const editor = createMockEditor();
@@ -444,9 +450,15 @@ describe("TiptapEditorInner — onCreate behavior", () => {
     render(<TiptapEditorInner />);
     const config = mocks.useEditor.mock.calls[0][0];
 
-    // onCreate schedules the parse asynchronously — should not throw synchronously
+    // onCreate schedules the parse asynchronously — should not throw synchronously.
+    // Run the deferred parse HERE: left pending, the one-shot throw leaked into
+    // whichever later test ran timers next.
+    vi.useFakeTimers();
     expect(() => config.onCreate({ editor })).not.toThrow();
+    vi.runAllTimers();
+    vi.useRealTimers();
     errorSpy.mockRestore();
+    expect(mocks.reportUnparseableDocument).toHaveBeenCalledWith("tab-1", failure);
   });
 
   it("schedules focus and cursor restore when not hidden", () => {
diff --git a/src/components/Editor/TiptapEditor.tsx b/src/components/Editor/TiptapEditor.tsx
index 098ca3dde..3af27de1a 100644
--- a/src/components/Editor/TiptapEditor.tsx
+++ b/src/components/Editor/TiptapEditor.tsx
@@ -9,8 +9,8 @@
  *     with the initial parse.
  *   - Adaptive debounce (100ms–5s) scales with document size: larger docs get longer
  *     delays to reduce serialization frequency without losing keystrokes on unmount.
- *   - Initial parse is deferred via setTimeout(0) so the editor shell renders before the
- *     heavy markdown→PM conversion runs, keeping the UI responsive on large documents.
+ *   - Initial parse is deferred via setTimeout(0) so the shell renders first; a parse that
+ *     fails goes to services/editor/unparseableDocument.ts (Source mode + message, #1407).
  *   - shouldRerenderOnTransaction: false — Tiptap's default full-React-rerender per
  *     transaction is wasted work here since state flows through Zustand selectors.
  *   - content-visibility gated on .cv-idle (off during typing) and only above
@@ -54,7 +54,7 @@ import { useWindowLabel } from "@/contexts/WindowContext";
 import { useFocusedPaneTiptapRegistration } from "@/hooks/useFocusedPaneTiptapRegistration";
 import { extractTiptapContext } from "@/plugins/formatToolbar/tiptapContext";
 import { useImageDragDrop } from "@/hooks/useImageDragDrop";
-import { tiptapError } from "@/utils/debug";
+import { reportUnparseableDocument } from "@/services/editor/unparseableDocument";
 import { consumeWysiwygPendingNav } from "./wysiwygPendingNav";
 import { ImageContextMenu } from "./ImageContextMenu";
 import { useTiptapContentSync } from "./useTiptapContentSync";
@@ -213,14 +213,14 @@ export function TiptapEditorInner({ hidden = false, readOnly = false, preview =
           // fresh value now — otherwise the external-sync effect (gated on
           // editorInitialized) already skipped it and would not refire until
           // the next content change.
-          if (contentRef.current !== contentSnapshot) {
-            syncMarkdownToEditor(
-              editor, contentRef.current, lastExternalContent, preserveLineBreaksRef.current,
-            );
+          if (contentRef.current !== contentSnapshot && !hiddenRef.current) { // hidden: synced when shown
+            syncMarkdownToEditor(editor, contentRef.current, lastExternalContent, preserveLineBreaksRef.current, activeTabId);
           }
         } catch (error) {
-          tiptapError(" Failed to parse initial markdown:", error);
           editorInitialized.current = true; // Unblock external sync even on parse error
+          if (hiddenRef.current) { /* #1407: a hidden editor re-syncs, and reports, when shown */ }
+          else if (contentRef.current !== contentSnapshot) syncMarkdownToEditor(editor, contentRef.current, lastExternalContent, preserveLineBreaksRef.current, activeTabId); // report the LATEST content
+          else reportUnparseableDocument(activeTabId, error);
         } finally {
           // Clear the "Opening large file…" StatusBar indicator once this
           // editor has a doc and is interactive. Scope the clear to the
diff --git a/src/components/Editor/tiptapEditorHelpers.test.ts b/src/components/Editor/tiptapEditorHelpers.test.ts
index 441c625c5..83784a762 100644
--- a/src/components/Editor/tiptapEditorHelpers.test.ts
+++ b/src/components/Editor/tiptapEditorHelpers.test.ts
@@ -4,6 +4,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { Editor } from "@tiptap/core";
 import StarterKit from "@tiptap/starter-kit";
+
+const reportUnparseableDocument = vi.hoisted(() => vi.fn());
+vi.mock("@/services/editor/unparseableDocument", () => ({ reportUnparseableDocument }));
+
 import {
   applySpellcheckForDocSize,
   buildTiptapEditorProps,
@@ -11,7 +15,9 @@ import {
   SPELLCHECK_DISABLE_CHAR_THRESHOLD,
   spellcheckAttrForDocSize,
   suppressCvIdleDuringEdit,
+  syncMarkdownToEditor,
 } from "./tiptapEditorHelpers";
+import { MAX_NESTING_DEPTH, nestingRefusal } from "@/utils/markdownPipeline/nestingDepth";
 
 describe("buildTiptapEditorProps", () => {
   it("snapshots the spellcheck attribute from the doc size", () => {
@@ -249,3 +255,39 @@ describe("suppressCvIdleDuringEdit", () => {
     expect(timeoutRef.current).toBeNull();
   });
 });
+
+describe("syncMarkdownToEditor on a document the parser refuses (#1407)", () => {
+  let editor: Editor;
+
+  beforeEach(() => {
+    reportUnparseableDocument.mockReset();
+    editor = new Editor({ element: document.createElement("div"), extensions: [StarterKit] });
+    editor.commands.setContent("<p>what the user had</p>");
+  });
+
+  afterEach(() => {
+    editor.destroy();
+  });
+
+  it("keeps the editor's content, and reports the refusal for this tab", () => {
+    const lastExternalContent = { current: "what the user had" };
+    const tooDeep = `${"> ".repeat(MAX_NESTING_DEPTH + 1)}a\n`;
+
+    const synced = syncMarkdownToEditor(editor, tooDeep, lastExternalContent, false, "tab-7");
+
+    expect(synced).toBe(false);
+    expect(editor.getText()).toBe("what the user had");
+    // Not marked as synced, so a later successful sync is not skipped.
+    expect(lastExternalContent.current).toBe("what the user had");
+    expect(reportUnparseableDocument).toHaveBeenCalledTimes(1);
+    const [tabId, error] = reportUnparseableDocument.mock.calls[0];
+    expect(tabId).toBe("tab-7");
+    expect(nestingRefusal(error)).toEqual({ depth: MAX_NESTING_DEPTH + 1, limit: MAX_NESTING_DEPTH });
+  });
+
+  it("reports nothing when the content parses", () => {
+    const lastExternalContent = { current: "" };
+    expect(syncMarkdownToEditor(editor, "# fine\n", lastExternalContent, false, "tab-7")).toBe(true);
+    expect(reportUnparseableDocument).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/components/Editor/tiptapEditorHelpers.ts b/src/components/Editor/tiptapEditorHelpers.ts
index ab4cbee9f..fb711ee1e 100644
--- a/src/components/Editor/tiptapEditorHelpers.ts
+++ b/src/components/Editor/tiptapEditorHelpers.ts
@@ -8,6 +8,7 @@
  * and callbacks.
  *
  * @coordinates-with TiptapEditor.tsx — sole consumer; behavior documented there
+ * @coordinates-with services/editor/unparseableDocument.ts — a refused sync lands in Source mode
  * @module components/Editor/tiptapEditorHelpers
  */
 import type { MutableRefObject } from "react";
@@ -18,7 +19,7 @@ import { parseMarkdown } from "@/utils/markdownPipeline";
 import { getTiptapEditorView } from "@/services/editor/tiptapView";
 import { handleTableScrollToSelection } from "@/plugins/tableScroll/scrollGuard";
 import { setCvIdlePreservingViewport } from "./cvIdleViewportLock";
-import { tiptapError } from "@/utils/debug";
+import { reportUnparseableDocument } from "@/services/editor/unparseableDocument";
 
 /**
  * Delay before enabling cursor tracking after editor creation.
@@ -201,12 +202,17 @@ export function suppressCvIdleDuringEdit(
  * Parse markdown and sync it into the editor without touching undo history.
  * Updates lastExternalContent tracking ref on success.
  * Returns true if content was synced, false if already current or on error.
+ *
+ * A document that cannot be parsed is reported for `tabId` (#1407): the editor
+ * keeps its old content, and an edit there would overwrite the new text on
+ * the next flush, so it goes to Source mode with a message instead.
  */
 export function syncMarkdownToEditor(
   editor: TiptapEditor,
   markdown: string,
   lastExternalContent: MutableRefObject<string>,
   preserveLineBreaks: boolean,
+  tabId: string | undefined,
 ): boolean {
   if (markdown === lastExternalContent.current) return false;
   try {
@@ -215,7 +221,7 @@ export function syncMarkdownToEditor(
     lastExternalContent.current = markdown;
     return true;
   } catch (error) {
-    tiptapError(" Failed to sync markdown:", error);
+    reportUnparseableDocument(tabId, error);
     return false;
   }
 }
diff --git a/src/components/Editor/useTiptapContentSync.ts b/src/components/Editor/useTiptapContentSync.ts
index ae02f2616..18cfd6a4f 100644
--- a/src/components/Editor/useTiptapContentSync.ts
+++ b/src/components/Editor/useTiptapContentSync.ts
@@ -64,7 +64,7 @@ export function useTiptapContentSync({
     if (!editorInitialized.current) return;
 
     const synced = syncMarkdownToEditor(
-      editor, content, lastExternalContent, preserveLineBreaksRef.current,
+      editor, content, lastExternalContent, preserveLineBreaksRef.current, activeTabId,
     );
 
     // For fresh document load (no saved cursor position), set cursor to start
@@ -94,7 +94,7 @@ export function useTiptapContentSync({
     if (!editor || !editorInitialized.current) return;
 
     syncMarkdownToEditor(
-      editor, content, lastExternalContent, preserveLineBreaksRef.current,
+      editor, content, lastExternalContent, preserveLineBreaksRef.current, activeTabId,
     );
 
     // A markdown-split preview only needs the content sync — it must not steal
diff --git a/src/components/Editor/useTiptapFlush.test.ts b/src/components/Editor/useTiptapFlush.test.ts
index 6c1b46030..57f3b06de 100644
--- a/src/components/Editor/useTiptapFlush.test.ts
+++ b/src/components/Editor/useTiptapFlush.test.ts
@@ -25,11 +25,18 @@ vi.mock("@/utils/markdownPipeline", () => ({
 import { useSettingsStore } from "@/stores/settingsStore";
 import { useTabStore } from "@/stores/tabStore";
 
-vi.mock("@/stores/documentStore", () => ({
+vi.mock("@/stores/documentStore", async () => ({
   useDocumentStore: { getState: () => ({ getDocument: () => ({ hardBreakStyle: "unknown" }) }) },
+  // The REAL forced-Source marker: the refusal guard below reads it.
+  useLargeFileSessionStore: (
+    await vi.importActual<typeof import("@/stores/documentStore/largeFileSession")>(
+      "@/stores/documentStore/largeFileSession",
+    )
+  ).useLargeFileSessionStore,
 }));
 
 import { useTiptapFlush } from "./useTiptapFlush";
+import { useLargeFileSessionStore } from "@/stores/documentStore";
 
 /** Minimal editor stand-in — the flush only reads schema/state.doc. */
 const editor = {
@@ -37,10 +44,14 @@ const editor = {
   state: { doc: { content: { size: 10 } } },
 } as unknown as TiptapEditor;
 
+/** `tab: null` passes NO activeTabId. A defaulted parameter cannot express that:
+ *  an explicit `undefined` argument takes the default, so the tab-store fallback
+ *  was never reached by the test that claimed to watch it. */
 function setup(
   setContent: (md: string, opts?: { fromUserEdit?: boolean }) => void,
-  activeTabId: string | undefined = "tab-1",
+  tab: string | null = "tab-1",
 ) {
+  const activeTabId = tab ?? undefined;
   return renderHook(() =>
     useTiptapFlush({
       activeTabId,
@@ -62,6 +73,7 @@ beforeEach(() => {
     markdown: { ...useSettingsStore.getState().markdown, preserveBlankLines: false },
   });
   useTabStore.setState({ activeTabId: { main: "tab-1" } });
+  useLargeFileSessionStore.setState({ forcedSourceTabs: {} });
   vi.useFakeTimers();
   vi.clearAllMocks();
   vi.stubGlobal("requestAnimationFrame", vi.fn(() => 1));
@@ -148,7 +160,7 @@ describe("flushToStore user-edit reporting", () => {
   it("falls back to the tab store's active tab when no activeTabId is passed", async () => {
     const { serializeMarkdown } = await import("@/utils/markdownPipeline");
     useTabStore.setState({ activeTabId: { main: "tab-from-store" } });
-    const { result } = setup(vi.fn(), undefined);
+    const { result } = setup(vi.fn(), null);
 
     result.current.flushToStore(editor);
 
@@ -158,3 +170,55 @@ describe("flushToStore user-edit reporting", () => {
     expect(vi.mocked(serializeMarkdown).mock.calls.at(-1)?.[2]).toHaveProperty("hardBreakStyle");
   });
 });
+
+// #1407: once the editor has failed to parse its tab's document, what it holds
+// is NOT that document — it is empty (initial load) or stale (a refused external
+// change). Any write from it would overwrite the real text: the pending edit's
+// debounce, Save's flush, and the unmount flush that runs as the tab switches to
+// Source mode. Reproduced by the audit as the store ending up "stale edit".
+describe("flushToStore after the tab's document was refused", () => {
+  it("writes nothing — not a scheduled edit, not a save or unmount flush", () => {
+    const setContent = vi.fn();
+    const { result } = setup(setContent);
+
+    result.current.scheduleFlush(editor); // a keystroke is pending
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "unparseable");
+    result.current.flushToStore(editor);
+    vi.runAllTimers();
+
+    expect(setContent).not.toHaveBeenCalled();
+  });
+
+  it("still writes for a tab in Source mode only because it is large", () => {
+    const setContent = vi.fn();
+    const { result } = setup(setContent);
+
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "large-file");
+    result.current.flushToStore(editor);
+
+    expect(setContent).toHaveBeenCalledTimes(1);
+  });
+
+  it("writes again once the refusal is cleared", () => {
+    const setContent = vi.fn();
+    const { result } = setup(setContent);
+
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "unparseable");
+    result.current.flushToStore(editor);
+    useLargeFileSessionStore.getState().clearForcedSource("tab-1");
+    result.current.flushToStore(editor);
+
+    expect(setContent).toHaveBeenCalledTimes(1);
+  });
+
+  it("guards the tab-store fallback too", () => {
+    const setContent = vi.fn();
+    useTabStore.setState({ activeTabId: { main: "tab-from-store" } });
+    const { result } = setup(setContent, null);
+
+    useLargeFileSessionStore.getState().markForcedSource("tab-from-store", "unparseable");
+    result.current.flushToStore(editor);
+
+    expect(setContent).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/components/Editor/useTiptapFlush.ts b/src/components/Editor/useTiptapFlush.ts
index 5de9f2387..ebc073024 100644
--- a/src/components/Editor/useTiptapFlush.ts
+++ b/src/components/Editor/useTiptapFlush.ts
@@ -16,6 +16,8 @@
  *     hasn't run yet (#755).
  *   - scheduleFlush uses RAF for small docs (≤100ms tier) and a debounced
  *     timeout for large docs — see getAdaptiveDebounceDelay.
+ *   - A tab whose document the editor could not parse (#1407) gets no write
+ *     at all: the editor holds empty or stale content, not the document.
  *   - Every flush reports whether a USER edit is behind it (userEditPending,
  *     set by scheduleFlush). Auto-save and Save All flush before reading
  *     isDirty, so a flush that claimed to be an edit would dirty a document
@@ -33,7 +35,7 @@ import type { HardBreakStyleOnSave } from "@/utils/linebreakDetection";
 import { serializeMarkdown } from "@/utils/markdownPipeline";
 import { resolveHardBreakStyle } from "@/utils/linebreaks";
 import { useTabStore } from "@/stores/tabStore";
-import { useDocumentStore } from "@/stores/documentStore";
+import { useDocumentStore, useLargeFileSessionStore } from "@/stores/documentStore";
 import { useSettingsStore } from "@/stores/settingsStore";
 import { getAdaptiveDebounceDelay } from "./tiptapEditorHelpers";
 
@@ -91,13 +93,21 @@ export function useTiptapFlush(options: TiptapFlushOptions): TiptapFlushHandle {
         pendingRaf.current = null;
       }
 
+      const tabId = activeTabId ?? useTabStore.getState().activeTabId[windowLabel];
+      // This editor could not parse the tab's document (#1407), so what it
+      // holds is empty or stale — writing it would overwrite the real text.
+      // Covers the pending edit, Save's flush and the unmount flush alike.
+      if (tabId && useLargeFileSessionStore.getState().forcedSourceReason(tabId) === "unparseable") {
+        userEditPending.current = false;
+        return;
+      }
+
       const markdown = serializeMarkdown(editor.schema, editor.state.doc, {
         preserveLineBreaks: preserveLineBreaksRef.current,
         // Read directly from the store (no new ref threaded through the editor
         // chain); capture is unconditional, so toggling needs no reparse.
         preserveBlankLines: useSettingsStore.getState().markdown.preserveBlankLines,
         hardBreakStyle: (() => {
-          const tabId = activeTabId ?? useTabStore.getState().activeTabId[windowLabel];
           /* v8 ignore next -- @preserve reason: no active tabId only if tab store is uninitialized; always set during normal editor lifecycle */
           if (!tabId) return resolveHardBreakStyle("unknown", hardBreakStyleOnSaveRef.current);
           const doc = useDocumentStore.getState().getDocument(tabId);
diff --git a/src/components/StatusBar/SourceModeUpgrade.test.tsx b/src/components/StatusBar/SourceModeUpgrade.test.tsx
index 5ef6591a3..4ef813a43 100644
--- a/src/components/StatusBar/SourceModeUpgrade.test.tsx
+++ b/src/components/StatusBar/SourceModeUpgrade.test.tsx
@@ -50,10 +50,29 @@ describe("SourceModeUpgrade", () => {
     ).toBeInTheDocument();
   });
 
-  it("clicking the action clears the marker but does NOT touch global sourceMode", async () => {
+  it("clicking the action lifts the marker and leaves a WYSIWYG window in WYSIWYG", async () => {
     const user = userEvent.setup();
     setActiveTab("tab-1");
+    useDocumentStore.getState().initDocument("tab-1", "# notes", "/repo/notes.md");
     useLargeFileSessionStore.getState().markForcedSource("tab-1");
+
+    render(<SourceModeUpgrade />);
+    await user.click(
+      screen.getByRole("button", { name: /largeFile\.switchToWysiwygAria/i })
+    );
+
+    expect(useLargeFileSessionStore.getState().isForcedSource("tab-1")).toBe(false);
+    expect(useUIStore.getState().sourceMode).toBe(false);
+  });
+
+  it("clicking the action SWITCHES even when the window itself is in Source mode (#1407)", async () => {
+    // Lifting only the marker used to leave global Source mode on, so the tab
+    // stayed in Source and the button did nothing visible. Audit repro: refuse
+    // a document, turn Source mode on from another tab, come back, click.
+    const user = userEvent.setup();
+    setActiveTab("tab-1");
+    useDocumentStore.getState().initDocument("tab-1", "# notes", "/repo/notes.md");
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "unparseable");
     useUIStore.getState().setSourceMode(true);
 
     render(<SourceModeUpgrade />);
@@ -61,9 +80,25 @@ describe("SourceModeUpgrade", () => {
       screen.getByRole("button", { name: /largeFile\.switchToWysiwygAria/i })
     );
 
-    // Global sourceMode is preserved — only the tab's override is lifted.
-    expect(useUIStore.getState().sourceMode).toBe(true);
     expect(useLargeFileSessionStore.getState().isForcedSource("tab-1")).toBe(false);
+    expect(useUIStore.getState().sourceMode).toBe(false);
+  });
+
+  it("says a refused document is in Source mode because WYSIWYG cannot show it, not because it is large", () => {
+    // #1407: the marker is shared with the large-file path; its label must
+    // not claim the file is large when the parser refused it.
+    setActiveTab("tab-1");
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "unparseable");
+
+    render(<SourceModeUpgrade />);
+
+    expect(screen.getByText("unparseable.openedInSourceMode")).toBeInTheDocument();
+    expect(screen.queryByText("largeFile.openedInSourceMode")).not.toBeInTheDocument();
+    // The way back stays: after reducing the nesting in Source mode, this is
+    // how the user asks for WYSIWYG again.
+    expect(
+      screen.getByRole("button", { name: /largeFile\.switchToWysiwygAria/i })
+    ).toBeInTheDocument();
   });
 
   it("does not render for an unrelated active tab", () => {
diff --git a/src/components/StatusBar/SourceModeUpgrade.tsx b/src/components/StatusBar/SourceModeUpgrade.tsx
index 0f0d4d9f2..694d37ad5 100644
--- a/src/components/StatusBar/SourceModeUpgrade.tsx
+++ b/src/components/StatusBar/SourceModeUpgrade.tsx
@@ -2,9 +2,11 @@
  * Source Mode Upgrade Offer
  *
  * Purpose: Appears in the StatusBar when the active tab was auto-routed to
- * Source mode because of file size. Lets the user explicitly opt into
- * WYSIWYG — clicking the link flips the mode, clears the marker, and the
- * upgrade offer disappears.
+ * Source mode — because of file size, or because the WYSIWYG parser refused
+ * the document (#1407); the label names which. Lets the user explicitly opt
+ * into WYSIWYG — clicking the link flips the mode, clears the marker, and the
+ * upgrade offer disappears. (A refused document is simply refused again, with
+ * a message, until its nesting is reduced.)
  *
  * Visible only when:
  *   - The active tab is in `useLargeFileSessionStore.forcedSourceTabs`.
@@ -16,7 +18,7 @@
  *     already toggled back to WYSIWYG manually, suppress the offer).
  *
  * @coordinates-with stores/documentStore/largeFileSession.ts — reads the marker set.
- * @coordinates-with stores/editorStore.ts — flips sourceMode on click.
+ * @coordinates-with services/history/unifiedHistory.ts — the mode toggle, when the window is in Source mode.
  * @coordinates-with stores/tabStore.ts — reads activeTabId via useTabStore.
  * @coordinates-with stores/documentStore.ts — reads filePath for YAML check.
  * @module components/StatusBar/SourceModeUpgrade
@@ -27,6 +29,8 @@ import { useTranslation } from "react-i18next";
 import { useTabStore } from "@/stores/tabStore";
 import { useLargeFileSessionStore } from "@/stores/documentStore";
 import { useDocumentStore } from "@/stores/documentStore";
+import { useUIStore } from "@/stores/uiStore";
+import { toggleSourceModeWithCheckpoint } from "@/services/history/unifiedHistory";
 import { isYamlFileName } from "@/utils/dropPaths";
 import { useWindowLabel } from "@/contexts/WindowContext";
 
@@ -35,9 +39,10 @@ export function SourceModeUpgrade() {
   const windowLabel = useWindowLabel();
   const activeTabId = useTabStore((s) => s.activeTabId[windowLabel] ?? null);
   /* v8 ignore next 3 -- @preserve defensive `!activeTabId` fallback is not exercised — the StatusBar always has an active tab in tests */
-  const isForcedSource = useLargeFileSessionStore((s) =>
-    activeTabId ? Boolean(s.forcedSourceTabs[activeTabId]) : false
+  const forcedReason = useLargeFileSessionStore((s) =>
+    activeTabId ? s.forcedSourceTabs[activeTabId] : undefined
   );
+  const isForcedSource = forcedReason !== undefined;
   const activeFilePath = useDocumentStore((s) =>
     activeTabId ? s.documents[activeTabId]?.filePath ?? null : null,
   );
@@ -47,14 +52,18 @@ export function SourceModeUpgrade() {
     ? isYamlFileName(activeFilePath.split(/[\\/]/).pop() ?? "")
     : false;
 
-  // The "Switch to WYSIWYG" action clears only this tab's forced-source
-  // marker. The Editor treats the marker as a per-tab override layered on
-  // top of the window-global sourceMode, so other tabs in the same window
-  // keep their mode. Global sourceMode is not flipped.
+  // The "Switch to WYSIWYG" action clears this tab's forced-source marker —
+  // a per-tab override layered on top of the window-global sourceMode. If the
+  // window is ALSO in Source mode (turned on from another tab, say), lifting
+  // the marker alone switches nothing, so the button did nothing visible
+  // (#1407 audit). The ordinary mode toggle then turns the window's Source
+  // mode off, with its checkpoint and per-tab mode record; other tabs keep
+  // their own mode through that record when they are next shown.
   const handleUpgrade = useCallback(() => {
     if (!activeTabId) return;
     useLargeFileSessionStore.getState().clearForcedSource(activeTabId);
-  }, [activeTabId]);
+    if (useUIStore.getState().sourceMode) toggleSourceModeWithCheckpoint(windowLabel);
+  }, [activeTabId, windowLabel]);
 
   if (!isForcedSource) return null;
   // YAML files are forced-source for correctness, not size. Switching
@@ -66,7 +75,9 @@ export function SourceModeUpgrade() {
   return (
     <div className="status-source-upgrade" role="status" aria-live="polite">
       <span className="status-source-upgrade__label">
-        {t("largeFile.openedInSourceMode")}
+        {forcedReason === "unparseable"
+          ? t("unparseable.openedInSourceMode")
+          : t("largeFile.openedInSourceMode")}
       </span>
       <button
         type="button"
diff --git a/src/lib/formats/markdownLargeFile.test.ts b/src/lib/formats/markdownLargeFile.test.ts
index 5e84ff9e5..83aecaa50 100644
--- a/src/lib/formats/markdownLargeFile.test.ts
+++ b/src/lib/formats/markdownLargeFile.test.ts
@@ -75,7 +75,7 @@ describe("maybeMarkLargeMarkdownAsSource", () => {
     maybeMarkLargeMarkdownAsSource("tab-1", "/foo.md", true);
     expect(
       useLargeFileSessionStore.getState().forcedSourceTabs["tab-1"],
-    ).toBe(true);
+    ).toBe("large-file");
   });
 
   it("does not mark non-markdown tabs even when shouldForce is true", () => {
@@ -93,7 +93,7 @@ describe("maybeMarkLargeMarkdownAsSource", () => {
     maybeMarkLargeMarkdownAsSource("tab-1", "/foo.md", true);
     expect(
       useLargeFileSessionStore.getState().forcedSourceTabs["tab-1"],
-    ).toBe(true);
+    ).toBe("large-file");
   });
 
   it("does NOT mark non-markdown extensions when registry is unbootstrapped", () => {
@@ -121,7 +121,7 @@ describe("maybeMarkLargeMarkdownAsSource", () => {
       maybeMarkLargeMarkdownAsSource(tabId, `/foo.${ext}`, true);
       expect(
         useLargeFileSessionStore.getState().forcedSourceTabs[tabId],
-      ).toBe(true);
+      ).toBe("large-file");
     }
   });
 });
diff --git a/src/locales/de/editor.json b/src/locales/de/editor.json
index f8b92faaf..6d26cf22b 100644
--- a/src/locales/de/editor.json
+++ b/src/locales/de/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} Warnungen",
   "splitPane.infoCount_one": "{{count}} Hinweis",
   "splitPane.infoCount_other": "{{count}} Hinweise",
-  "toc.empty": "Keine Überschriften"
+  "toc.empty": "Keine Überschriften",
+  "unparseable.tooDeeplyNested": "Dieses Dokument ist {{depth}} Ebenen tief verschachtelt; WYSIWYG unterstützt bis zu {{limit}}, daher wurde es im Quelltextmodus geöffnet.",
+  "unparseable.parseFailed": "Dieses Dokument konnte nicht in WYSIWYG angezeigt werden und wurde daher im Quelltextmodus geöffnet."
 }
diff --git a/src/locales/de/statusbar.json b/src/locales/de/statusbar.json
index cba511694..0a5a33bcb 100644
--- a/src/locales/de/statusbar.json
+++ b/src/locales/de/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "Tabs nach rechts scrollen",
   "terminal.sessionExited": "{{name}} (beendet)",
   "terminal.backgroundActivity": "Hintergrundaktivität",
-  "terminal.noWorkspaceSession": "Öffnen Sie einen Ordner oder speichern Sie Ihre Datei, um das Terminal zu verwenden"
+  "terminal.noWorkspaceSession": "Öffnen Sie einen Ordner oder speichern Sie Ihre Datei, um das Terminal zu verwenden",
+  "unparseable.openedInSourceMode": "Im Quelltextmodus geöffnet (in WYSIWYG nicht darstellbar)."
 }
diff --git a/src/locales/en/editor.json b/src/locales/en/editor.json
index 8f4c486ad..6428cc53d 100644
--- a/src/locales/en/editor.json
+++ b/src/locales/en/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} warnings",
   "splitPane.infoCount_one": "{{count}} notice",
   "splitPane.infoCount_other": "{{count}} notices",
-  "toc.empty": "No headings"
+  "toc.empty": "No headings",
+  "unparseable.tooDeeplyNested": "This document is nested {{depth}} levels deep; WYSIWYG supports up to {{limit}}, so it opened in Source mode.",
+  "unparseable.parseFailed": "This document could not be displayed in WYSIWYG, so it opened in Source mode."
 }
diff --git a/src/locales/en/statusbar.json b/src/locales/en/statusbar.json
index 3977b0483..10b8aa3c7 100644
--- a/src/locales/en/statusbar.json
+++ b/src/locales/en/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "Scroll tabs right",
   "terminal.sessionExited": "{{name}} (exited)",
   "terminal.backgroundActivity": "Background activity",
-  "terminal.noWorkspaceSession": "Open a folder or save your file to use the terminal"
+  "terminal.noWorkspaceSession": "Open a folder or save your file to use the terminal",
+  "unparseable.openedInSourceMode": "Opened in Source mode (cannot be displayed in WYSIWYG)."
 }
diff --git a/src/locales/es/editor.json b/src/locales/es/editor.json
index e89bcb191..59ee4406f 100644
--- a/src/locales/es/editor.json
+++ b/src/locales/es/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} advertencias",
   "splitPane.infoCount_one": "{{count}} aviso",
   "splitPane.infoCount_other": "{{count}} avisos",
-  "toc.empty": "Sin encabezados"
+  "toc.empty": "Sin encabezados",
+  "unparseable.tooDeeplyNested": "Este documento tiene {{depth}} niveles de anidamiento; WYSIWYG admite hasta {{limit}}, así que se abrió en modo Fuente.",
+  "unparseable.parseFailed": "Este documento no se pudo mostrar en WYSIWYG, así que se abrió en modo Fuente."
 }
diff --git a/src/locales/es/statusbar.json b/src/locales/es/statusbar.json
index 33c20f17c..97f6be38f 100644
--- a/src/locales/es/statusbar.json
+++ b/src/locales/es/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "Desplazar pestañas a la derecha",
   "terminal.sessionExited": "{{name}} (finalizado)",
   "terminal.backgroundActivity": "Actividad en segundo plano",
-  "terminal.noWorkspaceSession": "Abre una carpeta o guarda tu archivo para usar la terminal"
+  "terminal.noWorkspaceSession": "Abre una carpeta o guarda tu archivo para usar la terminal",
+  "unparseable.openedInSourceMode": "Abierto en modo Fuente (no se puede mostrar en WYSIWYG)."
 }
diff --git a/src/locales/fr/editor.json b/src/locales/fr/editor.json
index acd705358..2863ab1af 100644
--- a/src/locales/fr/editor.json
+++ b/src/locales/fr/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} avertissements",
   "splitPane.infoCount_one": "{{count}} notification",
   "splitPane.infoCount_other": "{{count}} notifications",
-  "toc.empty": "Aucun titre"
+  "toc.empty": "Aucun titre",
+  "unparseable.tooDeeplyNested": "Ce document comporte {{depth}} niveaux d'imbrication ; le mode WYSIWYG en accepte au plus {{limit}}, il a donc été ouvert en mode Source.",
+  "unparseable.parseFailed": "Ce document n'a pas pu être affiché en WYSIWYG ; il a donc été ouvert en mode Source."
 }
diff --git a/src/locales/fr/statusbar.json b/src/locales/fr/statusbar.json
index 382557515..56c6885f5 100644
--- a/src/locales/fr/statusbar.json
+++ b/src/locales/fr/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "Faire défiler les onglets vers la droite",
   "terminal.sessionExited": "{{name}} (terminé)",
   "terminal.backgroundActivity": "Activité en arrière-plan",
-  "terminal.noWorkspaceSession": "Ouvrez un dossier ou enregistrez votre fichier pour utiliser le terminal"
+  "terminal.noWorkspaceSession": "Ouvrez un dossier ou enregistrez votre fichier pour utiliser le terminal",
+  "unparseable.openedInSourceMode": "Ouvert en mode Source (impossible à afficher en WYSIWYG)."
 }
diff --git a/src/locales/it/editor.json b/src/locales/it/editor.json
index 0e3f2f68a..ed0687365 100644
--- a/src/locales/it/editor.json
+++ b/src/locales/it/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} avvisi",
   "splitPane.infoCount_one": "{{count}} notifica",
   "splitPane.infoCount_other": "{{count}} notifiche",
-  "toc.empty": "Nessuna intestazione"
+  "toc.empty": "Nessuna intestazione",
+  "unparseable.tooDeeplyNested": "Questo documento ha {{depth}} livelli di annidamento; WYSIWYG ne supporta al massimo {{limit}}, quindi è stato aperto in modalità Sorgente.",
+  "unparseable.parseFailed": "Impossibile visualizzare questo documento in WYSIWYG, quindi è stato aperto in modalità Sorgente."
 }
diff --git a/src/locales/it/statusbar.json b/src/locales/it/statusbar.json
index d2b87c37d..eff64255d 100644
--- a/src/locales/it/statusbar.json
+++ b/src/locales/it/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "Scorri le schede a destra",
   "terminal.sessionExited": "{{name}} (terminato)",
   "terminal.backgroundActivity": "Attività in background",
-  "terminal.noWorkspaceSession": "Apri una cartella o salva il file per usare il terminale"
+  "terminal.noWorkspaceSession": "Apri una cartella o salva il file per usare il terminale",
+  "unparseable.openedInSourceMode": "Aperto in modalità Sorgente (non visualizzabile in WYSIWYG)."
 }
diff --git a/src/locales/ja/editor.json b/src/locales/ja/editor.json
index 6c1f64893..c58b470a0 100644
--- a/src/locales/ja/editor.json
+++ b/src/locales/ja/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}}件の警告",
   "splitPane.infoCount_one": "{{count}}件の情報",
   "splitPane.infoCount_other": "{{count}}件の情報",
-  "toc.empty": "見出しがありません"
+  "toc.empty": "見出しがありません",
+  "unparseable.tooDeeplyNested": "このドキュメントは {{depth}} 階層までネストされています。WYSIWYG で表示できるのは {{limit}} 階層までのため、ソースモードで開きました。",
+  "unparseable.parseFailed": "このドキュメントは WYSIWYG で表示できなかったため、ソースモードで開きました。"
 }
diff --git a/src/locales/ja/statusbar.json b/src/locales/ja/statusbar.json
index fcc7129d6..9cba7460a 100644
--- a/src/locales/ja/statusbar.json
+++ b/src/locales/ja/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "タブを右にスクロール",
   "terminal.sessionExited": "{{name}}（終了済み）",
   "terminal.backgroundActivity": "バックグラウンドの動作",
-  "terminal.noWorkspaceSession": "ターミナルを使用するには、フォルダを開くかファイルを保存してください"
+  "terminal.noWorkspaceSession": "ターミナルを使用するには、フォルダを開くかファイルを保存してください",
+  "unparseable.openedInSourceMode": "ソースモードで開きました（WYSIWYG で表示できません）。"
 }
diff --git a/src/locales/ko/editor.json b/src/locales/ko/editor.json
index 385a429a4..c8dad868c 100644
--- a/src/locales/ko/editor.json
+++ b/src/locales/ko/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "경고 {{count}}개",
   "splitPane.infoCount_one": "알림 {{count}}개",
   "splitPane.infoCount_other": "알림 {{count}}개",
-  "toc.empty": "제목 없음"
+  "toc.empty": "제목 없음",
+  "unparseable.tooDeeplyNested": "이 문서는 {{depth}}단계까지 중첩되어 있습니다. WYSIWYG는 최대 {{limit}}단계까지 지원하므로 소스 모드로 열었습니다.",
+  "unparseable.parseFailed": "이 문서를 WYSIWYG로 표시할 수 없어 소스 모드로 열었습니다."
 }
diff --git a/src/locales/ko/statusbar.json b/src/locales/ko/statusbar.json
index fff68924d..e93d9f156 100644
--- a/src/locales/ko/statusbar.json
+++ b/src/locales/ko/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "탭을 오른쪽으로 스크롤",
   "terminal.sessionExited": "{{name}} (종료됨)",
   "terminal.backgroundActivity": "백그라운드 활동",
-  "terminal.noWorkspaceSession": "터미널을 사용하려면 폴더를 열거나 파일을 저장하세요"
+  "terminal.noWorkspaceSession": "터미널을 사용하려면 폴더를 열거나 파일을 저장하세요",
+  "unparseable.openedInSourceMode": "소스 모드로 열림(WYSIWYG로 표시할 수 없음)."
 }
diff --git a/src/locales/pt-BR/editor.json b/src/locales/pt-BR/editor.json
index cf1f87f76..7abc09404 100644
--- a/src/locales/pt-BR/editor.json
+++ b/src/locales/pt-BR/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} avisos",
   "splitPane.infoCount_one": "{{count}} notificação",
   "splitPane.infoCount_other": "{{count}} notificações",
-  "toc.empty": "Sem títulos"
+  "toc.empty": "Sem títulos",
+  "unparseable.tooDeeplyNested": "Este documento tem {{depth}} níveis de aninhamento; o WYSIWYG suporta até {{limit}}, então ele foi aberto no modo Fonte.",
+  "unparseable.parseFailed": "Não foi possível exibir este documento no WYSIWYG, então ele foi aberto no modo Fonte."
 }
diff --git a/src/locales/pt-BR/statusbar.json b/src/locales/pt-BR/statusbar.json
index f3e7efbe0..effce01cc 100644
--- a/src/locales/pt-BR/statusbar.json
+++ b/src/locales/pt-BR/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "Rolar abas para a direita",
   "terminal.sessionExited": "{{name}} (encerrado)",
   "terminal.backgroundActivity": "Atividade em segundo plano",
-  "terminal.noWorkspaceSession": "Abra uma pasta ou salve seu arquivo para usar o terminal"
+  "terminal.noWorkspaceSession": "Abra uma pasta ou salve seu arquivo para usar o terminal",
+  "unparseable.openedInSourceMode": "Aberto no modo Fonte (não pode ser exibido no WYSIWYG)."
 }
diff --git a/src/locales/zh-CN/editor.json b/src/locales/zh-CN/editor.json
index 2fd4615b7..bd873d473 100644
--- a/src/locales/zh-CN/editor.json
+++ b/src/locales/zh-CN/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} 个警告",
   "splitPane.infoCount_one": "{{count}} 个提示",
   "splitPane.infoCount_other": "{{count}} 个提示",
-  "toc.empty": "没有标题"
+  "toc.empty": "没有标题",
+  "unparseable.tooDeeplyNested": "此文档嵌套了 {{depth}} 层，WYSIWYG 模式最多支持 {{limit}} 层，因此已以源码模式打开。",
+  "unparseable.parseFailed": "此文档无法在 WYSIWYG 模式下显示，因此已以源码模式打开。"
 }
diff --git a/src/locales/zh-CN/statusbar.json b/src/locales/zh-CN/statusbar.json
index 4b1cb2b59..bb5636d65 100644
--- a/src/locales/zh-CN/statusbar.json
+++ b/src/locales/zh-CN/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "向右滚动标签页",
   "terminal.sessionExited": "{{name}}（已退出）",
   "terminal.backgroundActivity": "后台活动",
-  "terminal.noWorkspaceSession": "打开文件夹或保存您的文件以使用终端"
+  "terminal.noWorkspaceSession": "打开文件夹或保存您的文件以使用终端",
+  "unparseable.openedInSourceMode": "已以源码模式打开（无法在 WYSIWYG 模式下显示）。"
 }
diff --git a/src/locales/zh-TW/editor.json b/src/locales/zh-TW/editor.json
index cbb42a3a2..e1025613b 100644
--- a/src/locales/zh-TW/editor.json
+++ b/src/locales/zh-TW/editor.json
@@ -339,5 +339,7 @@
   "splitPane.warningCount_other": "{{count}} 個警告",
   "splitPane.infoCount_one": "{{count}} 個提示",
   "splitPane.infoCount_other": "{{count}} 個提示",
-  "toc.empty": "沒有標題"
+  "toc.empty": "沒有標題",
+  "unparseable.tooDeeplyNested": "此文件巢狀了 {{depth}} 層，WYSIWYG 模式最多支援 {{limit}} 層，因此已以原始碼模式開啟。",
+  "unparseable.parseFailed": "此文件無法在 WYSIWYG 模式下顯示，因此已以原始碼模式開啟。"
 }
diff --git a/src/locales/zh-TW/statusbar.json b/src/locales/zh-TW/statusbar.json
index f2ab523f5..520584152 100644
--- a/src/locales/zh-TW/statusbar.json
+++ b/src/locales/zh-TW/statusbar.json
@@ -99,5 +99,6 @@
   "scrollTabsRight": "向右捲動分頁",
   "terminal.sessionExited": "{{name}}（已退出）",
   "terminal.backgroundActivity": "背景活動",
-  "terminal.noWorkspaceSession": "請開啟資料夾或儲存檔案以使用終端機"
+  "terminal.noWorkspaceSession": "請開啟資料夾或儲存檔案以使用終端機",
+  "unparseable.openedInSourceMode": "已以原始碼模式開啟（無法在 WYSIWYG 模式下顯示）。"
 }
diff --git a/src/services/editor/unparseableDocument.test.ts b/src/services/editor/unparseableDocument.test.ts
new file mode 100644
index 000000000..52e7481dd
--- /dev/null
+++ b/src/services/editor/unparseableDocument.test.ts
@@ -0,0 +1,95 @@
+// @vitest-environment node
+/**
+ * #1407 — a document the WYSIWYG parser refuses must land in Source mode with
+ * a message, never in a blank rich-text editor.
+ *
+ * Before this, the editor caught the parse failure, logged it to the console
+ * and carried on with an EMPTY document — editable, and flushed to the store on
+ * the first keystroke, so typing into it would have saved over the file the
+ * user just opened. A 16382-level corpus
+ * file refused by the nesting guard (#1374) takes exactly that path.
+ *
+ * @coordinates-with unparseableDocument.ts
+ * @module services/editor/unparseableDocument.test
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockToastError = vi.fn();
+vi.mock("@/services/ime/imeToast", () => ({
+  imeToast: { error: (...a: unknown[]) => mockToastError(...a), info: vi.fn(), success: vi.fn() },
+}));
+
+import { reportUnparseableDocument } from "./unparseableDocument";
+import { useLargeFileSessionStore } from "@/stores/documentStore";
+import { MAX_NESTING_DEPTH } from "@/utils/markdownPipeline/nestingDepth";
+import { parseMarkdown } from "@/utils/markdownPipeline/adapter";
+import { testSchema } from "@/utils/markdownPipeline/testSchema";
+
+function refusalFromParser(depth: number): unknown {
+  try {
+    parseMarkdown(testSchema, `${"> ".repeat(depth)}a\n`);
+  } catch (error) {
+    return error;
+  }
+  throw new Error("expected the parser to refuse");
+}
+
+beforeEach(() => {
+  mockToastError.mockReset();
+  useLargeFileSessionStore.setState({ forcedSourceTabs: {} });
+});
+
+describe("reportUnparseableDocument", () => {
+  it("puts a too-deep document in Source mode and says how deep, and the limit", () => {
+    reportUnparseableDocument("tab-1", refusalFromParser(MAX_NESTING_DEPTH + 382));
+
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBe("unparseable");
+    expect(mockToastError).toHaveBeenCalledTimes(1);
+    const message = String(mockToastError.mock.calls[0][0]);
+    expect(message).toContain(String(MAX_NESTING_DEPTH + 382));
+    expect(message).toContain(String(MAX_NESTING_DEPTH));
+    expect(message).toMatch(/Source mode/);
+  });
+
+  it("puts any OTHER parse failure in Source mode too, with a general message", () => {
+    reportUnparseableDocument("tab-1", new Error("[MarkdownPipeline] Parse failed: boom"));
+
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBe("unparseable");
+    expect(mockToastError).toHaveBeenCalledTimes(1);
+    const message = String(mockToastError.mock.calls[0][0]);
+    expect(message).toMatch(/Source mode/);
+    // The pipeline's internal wording is not the user's message.
+    expect(message).not.toContain("MarkdownPipeline");
+  });
+
+  it("reports once when several editors of one tab fail on the same document", () => {
+    // A split view mounts a preview and an editable pane over one document.
+    const error = refusalFromParser(MAX_NESTING_DEPTH + 1);
+    reportUnparseableDocument("tab-1", error);
+    reportUnparseableDocument("tab-1", error);
+
+    expect(mockToastError).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-marks a tab already in Source mode for its size, without a second toast", () => {
+    // The user is already looking at Source mode, so no toast. But the reason
+    // must become the refusal: it is what stops the refused editor's writes.
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "large-file");
+    reportUnparseableDocument("tab-1", refusalFromParser(MAX_NESTING_DEPTH + 1));
+
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBe("unparseable");
+    expect(mockToastError).not.toHaveBeenCalled();
+  });
+
+  it("still tells the user when the editor has no tab to put in Source mode", () => {
+    reportUnparseableDocument(undefined, refusalFromParser(MAX_NESTING_DEPTH + 1));
+
+    expect(useLargeFileSessionStore.getState().forcedSourceTabs).toEqual({});
+    expect(mockToastError).toHaveBeenCalledTimes(1);
+  });
+
+  it("reports a thrown non-Error value instead of throwing on it", () => {
+    expect(() => reportUnparseableDocument("tab-1", "boom")).not.toThrow();
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBe("unparseable");
+  });
+});
diff --git a/src/services/editor/unparseableDocument.ts b/src/services/editor/unparseableDocument.ts
new file mode 100644
index 000000000..97e7aa061
--- /dev/null
+++ b/src/services/editor/unparseableDocument.ts
@@ -0,0 +1,61 @@
+/**
+ * Purpose: land a document the WYSIWYG parser refuses in Source mode, and tell
+ * the user why, instead of leaving them a blank rich-text editor (#1407).
+ *
+ * The editor used to catch the failure, log it to the console — nowhere a user
+ * looks — and carry on with an EMPTY document. That editor was live: the first
+ * keystroke flushed the empty document to the store, so typing would have
+ * saved over the file the user had just opened. The nesting guard
+ * (#1374) refuses documents past `MAX_NESTING_DEPTH` by design, so this path is
+ * reachable from any sufficiently deep file.
+ *
+ * Source mode shows the text as it is and needs no parse, so it is the one
+ * place such a document is both visible and safely editable. The per-tab
+ * forced-Source marker already exists for large files; it carries the reason,
+ * so the status bar can say the true one.
+ *
+ * Key decisions:
+ *   - ONE report per tab. A split view parses the same document in more than
+ *     one editor; the marker doubles as the "already told them" flag.
+ *   - A tab already in Source mode gets no toast — the user is looking at it —
+ *     but a SIZE reason becomes the refusal, because the reason is what stops
+ *     writes (below).
+ *   - Any parse failure, not only the nesting refusal. A blank editor that can
+ *     overwrite the file is the same hazard whatever the cause; the nesting
+ *     refusal just gets the more specific message.
+ *   - The marker is also what stops the refused editor WRITING: its content is
+ *     empty or stale, so `useTiptapFlush` drops every flush for the tab while
+ *     it carries the `unparseable` reason — the pending keystroke, Save, and
+ *     the unmount flush that runs as the tab switches to Source mode.
+ *
+ * @coordinates-with components/Editor/TiptapEditor.tsx — initial parse
+ * @coordinates-with components/Editor/tiptapEditorHelpers.ts — external sync
+ * @coordinates-with components/Editor/useTiptapFlush.ts — no writes while refused
+ * @coordinates-with stores/documentStore/largeFileSession.ts — the marker
+ * @coordinates-with components/StatusBar/SourceModeUpgrade.tsx — the status line
+ * @module services/editor/unparseableDocument
+ */
+import i18n from "@/i18n";
+import { imeToast } from "@/services/ime/imeToast";
+import { useLargeFileSessionStore } from "@/stores/documentStore";
+import { tiptapError } from "@/utils/debug";
+import { nestingRefusal } from "@/utils/markdownPipeline/nestingDepth";
+
+/** Report that the WYSIWYG editor for `tabId` could not parse its document. */
+export function reportUnparseableDocument(tabId: string | undefined, error: unknown): void {
+  tiptapError(" Document could not be parsed; falling back to Source mode:", error);
+
+  if (tabId !== undefined) {
+    const session = useLargeFileSessionStore.getState();
+    const already = session.forcedSourceReason(tabId);
+    if (already !== "unparseable") session.markForcedSource(tabId, "unparseable");
+    if (already !== undefined) return; // already showing Source mode: no second toast
+  }
+
+  const refusal = nestingRefusal(error);
+  imeToast.error(
+    refusal
+      ? i18n.t("editor:unparseable.tooDeeplyNested", { depth: refusal.depth, limit: refusal.limit })
+      : i18n.t("editor:unparseable.parseFailed"),
+  );
+}
diff --git a/src/stores/documentStore/largeFileSession.ts b/src/stores/documentStore/largeFileSession.ts
index 4e5636412..c02f91ded 100644
--- a/src/stores/documentStore/largeFileSession.ts
+++ b/src/stores/documentStore/largeFileSession.ts
@@ -1,25 +1,36 @@
 /**
  * Large-file session state — tracks which tabs were auto-opened in Source
- * mode because the file exceeded the WYSIWYG threshold. Used to prevent
- * unintended mode flips during the session.
+ * mode, and why: the file exceeded the WYSIWYG threshold, or the WYSIWYG
+ * parser refused it (#1407). Used to prevent unintended mode flips during the
+ * session, and to tell the user the real reason.
  *
  * @module stores/documentStore/largeFileSession
  */
 
 import { create } from "zustand";
 
+/**
+ * Why a tab was put in Source mode for the user.
+ *
+ * - `large-file`: over the size threshold; WYSIWYG would work, slowly.
+ * - `unparseable`: the WYSIWYG parser refused the document (for example it
+ *   nests past the limit), so WYSIWYG would be a blank editor.
+ */
+type ForcedSourceReason = "large-file" | "unparseable";
+
 interface LargeFileSessionState {
-  /** Tab IDs that were auto-opened in Source mode because of size. */
-  forcedSourceTabs: Record<string, true>;
-  markForcedSource: (tabId: string) => void;
+  /** Tab IDs that were auto-opened in Source mode, with the reason. */
+  forcedSourceTabs: Record<string, ForcedSourceReason>;
+  markForcedSource: (tabId: string, reason?: ForcedSourceReason) => void;
   clearForcedSource: (tabId: string) => void;
   isForcedSource: (tabId: string) => boolean;
+  forcedSourceReason: (tabId: string) => ForcedSourceReason | undefined;
 }
 
 export const useLargeFileSessionStore = create<LargeFileSessionState>((set, get) => ({
   forcedSourceTabs: {},
-  markForcedSource: (tabId) =>
-    set((state) => ({ forcedSourceTabs: { ...state.forcedSourceTabs, [tabId]: true } })),
+  markForcedSource: (tabId, reason = "large-file") =>
+    set((state) => ({ forcedSourceTabs: { ...state.forcedSourceTabs, [tabId]: reason } })),
   clearForcedSource: (tabId) =>
     set((state) => {
       if (!state.forcedSourceTabs[tabId]) return state;
@@ -28,4 +39,5 @@ export const useLargeFileSessionStore = create<LargeFileSessionState>((set, get)
       return { forcedSourceTabs: next };
     }),
   isForcedSource: (tabId) => Boolean(get().forcedSourceTabs[tabId]),
+  forcedSourceReason: (tabId) => get().forcedSourceTabs[tabId],
 }));
diff --git a/src/stores/largeFileSessionStore.test.ts b/src/stores/largeFileSessionStore.test.ts
index e887d211d..05af200cc 100644
--- a/src/stores/largeFileSessionStore.test.ts
+++ b/src/stores/largeFileSessionStore.test.ts
@@ -36,4 +36,27 @@ describe("documentStore", () => {
     useLargeFileSessionStore.getState().markForcedSource("tab-1");
     expect(Object.keys(useLargeFileSessionStore.getState().forcedSourceTabs)).toEqual(["tab-1"]);
   });
+
+  // #1407: the marker also lands a document the WYSIWYG parser refused, and the
+  // status line must say which — "(large file)" is wrong for a refusal.
+  it("markForcedSource defaults to the large-file reason, as every size caller means", () => {
+    useLargeFileSessionStore.getState().markForcedSource("tab-1");
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBe("large-file");
+  });
+
+  it("records an unparseable document as its own reason, per tab", () => {
+    const s = useLargeFileSessionStore.getState();
+    s.markForcedSource("tab-1", "unparseable");
+    s.markForcedSource("tab-2");
+    expect(useLargeFileSessionStore.getState().isForcedSource("tab-1")).toBe(true);
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBe("unparseable");
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-2")).toBe("large-file");
+  });
+
+  it("has no reason for a tab that is not forced, including after clearing", () => {
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBeUndefined();
+    useLargeFileSessionStore.getState().markForcedSource("tab-1", "unparseable");
+    useLargeFileSessionStore.getState().clearForcedSource("tab-1");
+    expect(useLargeFileSessionStore.getState().forcedSourceReason("tab-1")).toBeUndefined();
+  });
 });
diff --git a/src/test/arbitraryMarkdown.test.ts b/src/test/arbitraryMarkdown.test.ts
new file mode 100644
index 000000000..217611650
--- /dev/null
+++ b/src/test/arbitraryMarkdown.test.ts
@@ -0,0 +1,54 @@
+// @vitest-environment node
+/**
+ * #1407 — the sweep-side classification of the nesting refusal.
+ *
+ * The OSS-Fuzz soak died on a corpus file nested 16382 levels deep because it
+ * treated the pipeline's designed refusal as a crash. The helper under test is
+ * the one place a sweep decides which is which, so both halves are pinned:
+ * a refusal comes back as data, and every other failure still throws.
+ *
+ * @coordinates-with arbitraryMarkdown.ts
+ * @module test/arbitraryMarkdown.test
+ */
+import { describe, it, expect } from "vitest";
+import type { Schema } from "@tiptap/pm/model";
+import { parseArbitraryMarkdown } from "./arbitraryMarkdown";
+import { MAX_NESTING_DEPTH } from "@/utils/markdownPipeline/nestingDepth";
+import { testSchema } from "@/utils/markdownPipeline/testSchema";
+
+describe("parseArbitraryMarkdown", () => {
+  it("returns the document for ordinary markdown", () => {
+    const outcome = parseArbitraryMarkdown(testSchema, "# Title\n\nbody 中文\n");
+    expect(outcome.kind).toBe("parsed");
+    expect(outcome.kind === "parsed" && outcome.doc.childCount).toBe(2);
+  });
+
+  it("returns an empty document for empty input", () => {
+    const outcome = parseArbitraryMarkdown(testSchema, "");
+    expect(outcome.kind).toBe("parsed");
+  });
+
+  it.each([
+    ["blockquotes", `${"> ".repeat(MAX_NESTING_DEPTH + 1)}a\n`, MAX_NESTING_DEPTH + 1],
+    ["lists", Array.from({ length: MAX_NESTING_DEPTH + 5 }, (_, i) => `${"  ".repeat(i)}- a`).join("\n"), MAX_NESTING_DEPTH + 5],
+  ])("returns a refusal, with its numbers, for too-deep %s", (_shape, markdown, depth) => {
+    expect(parseArbitraryMarkdown(testSchema, markdown)).toEqual({
+      kind: "refused",
+      refusal: { depth, limit: MAX_NESTING_DEPTH },
+    });
+  });
+
+  it("parses a document exactly at the limit", () => {
+    const outcome = parseArbitraryMarkdown(testSchema, `${"> ".repeat(MAX_NESTING_DEPTH)}a\n`);
+    expect(outcome.kind).toBe("parsed");
+  });
+
+  it("rethrows every other failure", () => {
+    const exploding = new Proxy({} as Schema, {
+      get() {
+        throw new Error("schema exploded");
+      },
+    });
+    expect(() => parseArbitraryMarkdown(exploding, "a paragraph\n")).toThrow(/schema exploded/);
+  });
+});
diff --git a/src/test/arbitraryMarkdown.ts b/src/test/arbitraryMarkdown.ts
new file mode 100644
index 000000000..1079d7c69
--- /dev/null
+++ b/src/test/arbitraryMarkdown.ts
@@ -0,0 +1,41 @@
+/**
+ * Purpose: parse ARBITRARY markdown in a fuzz, soak or pathological sweep, and
+ * tell the pipeline's one deliberate refusal apart from a crash.
+ *
+ * `parseMarkdown` refuses a document nested deeper than `MAX_NESTING_DEPTH`
+ * (#1374): past that depth the parser's own dependencies overflow the stack, so
+ * the refusal is the designed outcome, not a defect. A sweep over hostile input
+ * must therefore count a refusal as "handled" — the OSS-Fuzz soak failed on a
+ * 16382-level corpus file precisely because it treated the refusal as a crash
+ * (#1407) — while every OTHER throw stays a failure.
+ *
+ * Both sweeps share this one classification so they cannot drift apart. It is
+ * by TYPE along the `cause` chain (`nestingRefusal`), never by message text.
+ *
+ * Use it only on the INPUT of a sweep. A refusal when re-parsing the pipeline's
+ * own serialized output would be a real defect, so round-trip legs must call
+ * `parseMarkdown` directly and let it throw.
+ *
+ * @coordinates-with utils/markdownPipeline/nestingDepth.ts — the refusal
+ * @coordinates-with test/externalCorpora.soak.test.ts — the OSS-Fuzz sweep
+ * @coordinates-with utils/markdownPipeline/__tests__/pathological/runCases.ts
+ * @module test/arbitraryMarkdown
+ */
+import type { Node as PMNode, Schema } from "@tiptap/pm/model";
+import { parseMarkdown } from "@/utils/markdownPipeline/adapter";
+import { nestingRefusal, type NestingRefusal } from "@/utils/markdownPipeline/nestingDepth";
+
+export type ArbitraryParseOutcome =
+  | { kind: "parsed"; doc: PMNode }
+  | { kind: "refused"; refusal: NestingRefusal };
+
+/** Parse `markdown`; a nesting refusal is returned, anything else is thrown. */
+export function parseArbitraryMarkdown(schema: Schema, markdown: string): ArbitraryParseOutcome {
+  try {
+    return { kind: "parsed", doc: parseMarkdown(schema, markdown) };
+  } catch (error) {
+    const refusal = nestingRefusal(error);
+    if (!refusal) throw error;
+    return { kind: "refused", refusal };
+  }
+}
diff --git a/src/test/externalCorpora.soak.test.ts b/src/test/externalCorpora.soak.test.ts
index e2affa46a..709ce3546 100644
--- a/src/test/externalCorpora.soak.test.ts
+++ b/src/test/externalCorpora.soak.test.ts
@@ -22,6 +22,7 @@ import StarterKit from "@tiptap/starter-kit";
 import { gunzipSync } from "node:zlib";
 import "@/utils/markdownPipeline/dialect";
 import { parseMarkdown, serializeMarkdown } from "@/utils/markdownPipeline/adapter";
+import { parseArbitraryMarkdown } from "./arbitraryMarkdown";
 
 const schema = getSchema([StarterKit]);
 
@@ -108,6 +109,7 @@ describe("OSS-Fuzz cmark corpus soak (best-effort bucket)", () => {
     const files = readdirSync(join(dir, "corpus")).slice(0, 500);
     expect(files.length).toBeGreaterThan(100);
     const oscillating: string[] = [];
+    const refused: string[] = [];
     for (const file of files) {
       const bytes = readFileSync(join(dir, "corpus", file));
       const text = bytes.toString("utf8");
@@ -117,17 +119,33 @@ describe("OSS-Fuzz cmark corpus soak (best-effort bucket)", () => {
       // inputs hit that class, so a small, LOUDLY-REPORTED tolerance keeps
       // the weekly soak signal instead of permanently red. Fixing the
       // ledgered defects shrinks this to zero.
-      const md1 = serializeMarkdown(schema, parseMarkdown(schema, text));
+      //
+      // A document nested past MAX_NESTING_DEPTH is REFUSED by design (#1374),
+      // and the corpus has one 16382 levels deep (#1407) — that is handled,
+      // not a crash. Only the input may be refused: the re-parses below read
+      // the pipeline's own output, where a refusal would be a real defect.
+      const first = parseArbitraryMarkdown(schema, text);
+      if (first.kind === "refused") {
+        refused.push(`${file} (${first.refusal.depth} levels)`);
+        continue;
+      }
+      const md1 = serializeMarkdown(schema, first.doc);
       const md2 = serializeMarkdown(schema, parseMarkdown(schema, md1));
       const md3 = serializeMarkdown(schema, parseMarkdown(schema, md2));
       if (md3 !== md2) oscillating.push(file);
     }
+    if (refused.length > 0) {
+      console.warn(`[SOAK] ${refused.length}/${files.length} fuzz inputs refused as too deeply nested: ${refused.join(", ")}`);
+    }
+    const checked = files.length - refused.length;
+    // The sample is only worth its name if the refusal did not eat it.
+    expect(checked, "fuzz inputs actually round-tripped").toBeGreaterThan(100);
     if (oscillating.length > 0) {
       console.warn(
-        `[SOAK] ${oscillating.length}/${files.length} fuzz inputs oscillate (known escape-growth class): ` +
+        `[SOAK] ${oscillating.length}/${checked} fuzz inputs oscillate (known escape-growth class): ` +
           oscillating.slice(0, 10).join(", "),
       );
     }
-    expect(oscillating.length / files.length, "oscillating fraction").toBeLessThanOrEqual(0.02);
+    expect(oscillating.length / checked, "oscillating fraction").toBeLessThanOrEqual(0.02);
   });
 });
diff --git a/src/utils/markdownPipeline/__tests__/pathological/pathological.test.ts b/src/utils/markdownPipeline/__tests__/pathological/pathological.test.ts
index 70db84afe..4ef1d498f 100644
--- a/src/utils/markdownPipeline/__tests__/pathological/pathological.test.ts
+++ b/src/utils/markdownPipeline/__tests__/pathological/pathological.test.ts
@@ -22,7 +22,8 @@ import { describe, it, expect } from "vitest";
 import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { pathologicalCases } from "./pathologicalCases";
+import { pathologicalCases, pathologicalScale } from "./pathologicalCases";
+import { MAX_NESTING_DEPTH } from "../../nestingDepth";
 import { LIVENESS_TIMEOUT_MS } from "../../../../../vitest.shared";
 
 const here = dirname(fileURLToPath(import.meta.url));
@@ -62,6 +63,8 @@ interface CaseReport {
   starting?: boolean;
   parseMs?: number;
   serializeMs?: number;
+  refusedMs?: number;
+  refusedDepth?: number;
   done?: boolean;
 }
 
@@ -118,7 +121,9 @@ describe("pathological inputs (killable child process)", () => {
     const { res, lines } = runChild({}, WALL_CEILING_MS);
 
     const started = lines.filter((l) => l.starting && l.name).map((l) => l.name);
-    const finished = new Set(lines.filter((l) => l.parseMs !== undefined).map((l) => l.name));
+    const parsed = lines.filter((l) => l.parseMs !== undefined).map((l) => l.name);
+    const refused = lines.filter((l) => l.refusedMs !== undefined).map((l) => l.name);
+    const finished = new Set([...parsed, ...refused]);
     const lastStarted = started.at(-1);
 
     expect(
@@ -129,8 +134,16 @@ describe("pathological inputs (killable child process)", () => {
     expect(res.status, `child failed\nstderr: ${res.stderr}`).toBe(0);
     expect(lines.some((l) => l.done)).toBe(true);
 
-    const expected = pathologicalCases(1).map((c) => c.name);
-    expect([...finished].sort()).toEqual([...expected].sort());
+    // Every class must come back — parsed, or refused as too deeply nested.
+    // Which of the two is decided by the case's DECLARED container depth at
+    // the scale the child ran, so a refusal nobody expected fails here instead
+    // of passing as "finished". The soak's scale 8 refuses the two container
+    // classes; counting only parsed classes made that a failure (#1407).
+    const cases = pathologicalCases(pathologicalScale());
+    const deep = (c: (typeof cases)[number]) => c.containerDepth > MAX_NESTING_DEPTH;
+    expect([...refused].sort()).toEqual(cases.filter(deep).map((c) => c.name).sort());
+    expect([...parsed].sort()).toEqual(cases.filter((c) => !deep(c)).map((c) => c.name).sort());
+    expect(finished.size).toBe(cases.length);
   }, WALL_CEILING_MS + 30_000);
 
   it("SELF-TEST: a deliberate busy loop is killed and reported, not hung", () => {
diff --git a/src/utils/markdownPipeline/__tests__/pathological/pathologicalCases.ts b/src/utils/markdownPipeline/__tests__/pathological/pathologicalCases.ts
index cc0bf25d4..7d8c402d4 100644
--- a/src/utils/markdownPipeline/__tests__/pathological/pathologicalCases.ts
+++ b/src/utils/markdownPipeline/__tests__/pathological/pathologicalCases.ts
@@ -21,6 +21,19 @@ export interface PathologicalCase {
   markdown: string;
   /** Also run the parse→ProseMirror→markdown leg. */
   serialize: boolean;
+  /**
+   * How deeply the input nests CONTAINERS (blockquotes, lists), stated from
+   * the generator rather than measured by the guard — so a case above
+   * `MAX_NESTING_DEPTH` is one the parent EXPECTS to be refused, and a refusal
+   * of any other case is a failure rather than a quiet pass.
+   */
+  containerDepth: number;
+}
+
+/** The scale a run uses: `PATHOLOGICAL_SCALE`, read in ONE place so the child
+ *  that generates the inputs and the parent that judges them cannot disagree. */
+export function pathologicalScale(): number {
+  return Number(process.env.PATHOLOGICAL_SCALE ?? "1");
 }
 
 export function pathologicalCases(scale = 1): PathologicalCase[] {
@@ -35,46 +48,55 @@ export function pathologicalCases(scale = 1): PathologicalCase[] {
       name: "nested-brackets",
       markdown: `${"[".repeat(n(2000))}a${"]".repeat(n(2000))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "nested-strong-emph",
       markdown: `${"*a **a ".repeat(n(300))}b${" a** a*".repeat(n(300))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "emph-closers-without-openers",
       markdown: `${"a_ ".repeat(n(3000))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "emph-openers-without-closers",
       markdown: `${"_a ".repeat(n(3000))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "link-closers-with-openers",
       markdown: `${"a](".repeat(n(3000))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "backtick-runs",
       markdown: `${backtickRuns(n(250))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "unclosed-inline-links",
       markdown: `${"[a](<b".repeat(n(2000))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "deep-blockquotes",
       markdown: `${"> ".repeat(n(500))}a\n`,
       serialize: true,
+      containerDepth: n(500),
     },
     {
       name: "deep-lists",
       markdown: Array.from({ length: n(200) }, (_, i) => `${"  ".repeat(i)}- a`).join("\n") + "\n",
       serialize: true,
+      containerDepth: n(200),
     },
     {
       // Deep mdast NESTING (not just long delimiter runs): alternating
@@ -84,6 +106,7 @@ export function pathologicalCases(scale = 1): PathologicalCase[] {
       name: "deep-inline-nesting",
       markdown: `${"*_".repeat(n(1500))}x${"_*".repeat(n(1500))}\n`,
       serialize: true,
+      containerDepth: 0,
     },
     {
       name: "many-link-references",
@@ -91,6 +114,7 @@ export function pathologicalCases(scale = 1): PathologicalCase[] {
         Array.from({ length: n(1000) }, (_, i) => `[ref${i}]: /url${i}`).join("\n") +
         `\n\n${Array.from({ length: n(1000) }, (_, i) => `[ref${i}]`).join(" ")}\n`,
       serialize: true,
+      containerDepth: 0,
     },
   ];
 }
diff --git a/src/utils/markdownPipeline/__tests__/pathological/pathologicalScaling.test.ts b/src/utils/markdownPipeline/__tests__/pathological/pathologicalScaling.test.ts
new file mode 100644
index 000000000..c1f7fd127
--- /dev/null
+++ b/src/utils/markdownPipeline/__tests__/pathological/pathologicalScaling.test.ts
@@ -0,0 +1,195 @@
+// @vitest-environment node
+/**
+ * #1407 — the pathological classes must scale LINEARLY with input size.
+ *
+ * The soak tier runs these classes at cmark's full sizes inside a killable
+ * child, weekly. That is the only place a super-linear parse or serialize was
+ * ever visible, and it was visible as a HANG: `link-closers-with-openers`
+ * alone took 60s to parse and 276s to serialize at soak scale, against a 300s
+ * wall ceiling for the whole suite. This file brings the property into the PR
+ * tier, where it is cheap.
+ *
+ * It asserts a GROWTH EXPONENT, never a duration. Wall-clock bounds flake
+ * under contention (`../performance.test.ts` is opt-in for exactly that
+ * reason), and a busy machine slows a small run and a large run alike. What
+ * contention cannot do is turn cost ∝ n into cost ∝ n²: for an 8× larger input
+ * that is the difference between ~8× and ~64× the CPU time, so the exponent
+ * separates them with a wide margin on both sides. Three things keep the
+ * measurement honest under load:
+ *
+ *   - CPU time of this process (`process.cpuUsage`), not wall time, so being
+ *     descheduled costs nothing. Vitest runs each file in its own fork.
+ *   - Small and large runs are INTERLEAVED and the minimum of each is kept, so
+ *     a burst of contention or a GC pause inflates one sample, not the answer.
+ *   - A warm-up parse first, so JIT compilation is not billed to the small run
+ *     (which would make growth look better or worse than it is).
+ *
+ * Fixed overhead per call (processor lookup, content analysis) can only pull
+ * the exponent DOWN, so it can hide nothing the bound is meant to catch.
+ *
+ * @coordinates-with pathologicalCases.ts — the soak-tier shapes these mirror
+ * @coordinates-with ../../parser/fastPaths/ — the linear decisions under test
+ * @coordinates-with ../../serializerCosmetics.ts — the linear escape scan
+ * @coordinates-with patches/micromark@4.0.2.patch — linear data-token merge
+ * @coordinates-with patches/mdast-util-to-markdown@2.1.2.patch — linear escaping
+ * @module utils/markdownPipeline/__tests__/pathological/pathologicalScaling.test
+ */
+import { describe, it, expect } from "vitest";
+import { getSchema } from "@tiptap/core";
+import StarterKit from "@tiptap/starter-kit";
+import "../../dialect";
+import { parseMarkdown, serializeMarkdown } from "../../adapter";
+
+const schema = getSchema([StarterKit]);
+
+/** Linear is 1, quadratic is 2. Measured with the fixes: 1.04–1.18 under a
+ *  load average above 150. Without them: 1.82–2.35 for every case except
+ *  `backtick-runs`, which carries its own bound below. */
+const MAX_EXPONENT = 1.35;
+
+interface ScalingCase {
+  name: string;
+  /** Build the input for size parameter `n`. */
+  make: (n: number) => string;
+  small: number;
+  large: number;
+  /** Measure parse alone — for a parser property whose input must be big. */
+  parseOnly?: boolean;
+  /** A tighter bound, for a class whose broken growth is below quadratic. */
+  maxExponent?: number;
+}
+
+const backtickRuns = (n: number): string => {
+  let out = "";
+  for (let i = 1; i <= n; i += 1) out += `e${"`".repeat(i)}`;
+  return `${out}\n`;
+};
+
+const CASES: ScalingCase[] = [
+  {
+    // `]` with no opener anywhere: every one used to walk the whole paragraph.
+    name: "link-closers-with-openers",
+    make: (n) => `${"a](".repeat(n)}\n`,
+    small: 500,
+    large: 4000,
+  },
+  {
+    // Parses linearly, but its SERIALIZED form escapes every `[` — so the
+    // cosmetic pass re-parses a paragraph of openerless `]`.
+    name: "unclosed-inline-links",
+    make: (n) => `${"[a](<b".repeat(n)}\n`,
+    small: 400,
+    large: 3200,
+  },
+  {
+    // A balanced image label is where the footnote-call scan stops — so it
+    // must not turn every later `]` back into a walk to it.
+    name: "link-closers-after-an-image",
+    make: (n) => `![x] ${"a](".repeat(n)}\n`,
+    small: 500,
+    large: 4000,
+  },
+  {
+    // …including an image label that LOOKS like a footnote call while
+    // footnotes are defined, so the footnote-call check has something to look
+    // up. A later `]` still cannot complete that call (its label would contain
+    // a bare `]`, which no definition label can), so it must not reintroduce
+    // the walk either.
+    name: "link-closers-after-a-footnote-like-image",
+    make: (n) => `![^y] ${"a](".repeat(n)}\n\n[^x]: note\n`,
+    small: 500,
+    large: 4000,
+  },
+  {
+    // Real links between the stray `]`s: each one rewrites the event list, so
+    // the opener index must re-index from the link — not from the start of
+    // the paragraph, which would put the quadratic walk back one link at a time.
+    name: "link-closers-between-links",
+    make: (n) => `${"[a](b) ] ".repeat(n)}\n`,
+    small: 300,
+    large: 2400,
+  },
+  {
+    // Every `_` closes and none opens: each used to walk back to the start.
+    name: "emph-closers-without-openers",
+    make: (n) => `${"a_ ".repeat(n)}\n`,
+    small: 500,
+    large: 4000,
+  },
+  {
+    // Runs of distinct lengths never close, so each opener scanned to the end
+    // of the paragraph. And every backtick is escaped on the way out, which is
+    // where remark-stringify's escaping was quadratic in the escape count.
+    // Input size grows with n², so these sizes are a ~16× size step — and the
+    // broken scan costs n³, i.e. size^1.5, not size². Measured: 1.04–1.11
+    // fixed, 1.41–1.48 broken, so the bound sits between them.
+    name: "backtick-runs",
+    make: backtickRuns,
+    small: 120,
+    large: 480,
+    maxExponent: 1.25,
+  },
+  {
+    // Ordinary escaped prose — what the serializer's conservative output looks
+    // like. micromark merged adjacent data tokens with one `splice` per run,
+    // each moving the rest of the paragraph's events: harmless until the event
+    // list outgrows V8's regular heap objects, then ~10× per 1.3× more text.
+    // So this case needs a paragraph past that size (~100 KB), and measures
+    // parse alone to keep the cost of doing so down.
+    name: "escaped-prose",
+    make: (n) => `${"\\*ab c".repeat(n)}\n`,
+    small: 6000,
+    large: 24000,
+    parseOnly: true,
+  },
+];
+
+function roundTrip(markdown: string): void {
+  serializeMarkdown(schema, parseMarkdown(schema, markdown));
+}
+
+function parseOnce(markdown: string): void {
+  parseMarkdown(schema, markdown);
+}
+
+function cpuMs(fn: () => void): number {
+  const start = process.cpuUsage();
+  fn();
+  const used = process.cpuUsage(start);
+  return (used.user + used.system) / 1000;
+}
+
+/** Minimum CPU cost of small and large inputs, interleaved. */
+function measure(
+  run: (markdown: string) => void,
+  small: string,
+  large: string,
+): { small: number; large: number } {
+  run(small); // warm-up: JIT and processor caches
+  let bestSmall = Number.POSITIVE_INFINITY;
+  let bestLarge = Number.POSITIVE_INFINITY;
+  for (let round = 0; round < 3; round += 1) {
+    bestSmall = Math.min(bestSmall, cpuMs(() => run(small)));
+    bestLarge = Math.min(bestLarge, cpuMs(() => run(large)));
+    bestSmall = Math.min(bestSmall, cpuMs(() => run(small)));
+  }
+  return { small: bestSmall, large: bestLarge };
+}
+
+describe("pathological inputs scale linearly (#1407)", () => {
+  it.each(CASES)("$name: cost grows linearly with input size", (c) => {
+    const small = c.make(c.small);
+    const large = c.make(c.large);
+    const cost = measure(c.parseOnly ? parseOnce : roundTrip, small, large);
+    // A floor on the small sample keeps a sub-millisecond reading from
+    // manufacturing a huge ratio out of timer resolution.
+    const smallCost = Math.max(cost.small, 1);
+    const exponent = Math.log(cost.large / smallCost) / Math.log(large.length / small.length);
+    expect(
+      exponent,
+      `${c.name}: ${small.length} chars → ${cost.small.toFixed(1)}ms, ` +
+        `${large.length} chars → ${cost.large.toFixed(1)}ms ` +
+        `(exponent ${exponent.toFixed(2)}; 1 is linear, 2 is quadratic)`,
+    ).toBeLessThan(c.maxExponent ?? MAX_EXPONENT);
+  }, 600_000);
+});
diff --git a/src/utils/markdownPipeline/__tests__/pathological/runCases.ts b/src/utils/markdownPipeline/__tests__/pathological/runCases.ts
index e1776b2a4..287d70b05 100644
--- a/src/utils/markdownPipeline/__tests__/pathological/runCases.ts
+++ b/src/utils/markdownPipeline/__tests__/pathological/runCases.ts
@@ -18,7 +18,8 @@
  * the spec gates on the (already-nasty, small) spec corpora.
  *
  * Protocol: one JSON line per completed case on stdout
- * (`{"name","parseMs","serializeMs"}`), `{"done":true}` at the end. The
+ * (`{"name","parseMs","serializeMs"}`, or `{"name","refusedMs","refusedDepth"}`
+ * for a nesting refusal), `{"done":true}` at the end. The
  * PARENT owns all judgement; a case that hangs simply never prints, and the
  * last-started name (printed BEFORE running) identifies the culprit.
  *
@@ -30,9 +31,9 @@
 import { getSchema } from "@tiptap/core";
 import StarterKit from "@tiptap/starter-kit";
 import "../../dialect";
-import { parseMarkdown, serializeMarkdown } from "../../adapter";
-import { isNestingTooDeep } from "../../nestingDepth";
-import { pathologicalCases } from "./pathologicalCases";
+import { serializeMarkdown } from "../../adapter";
+import { parseArbitraryMarkdown } from "@/test/arbitraryMarkdown";
+import { pathologicalCases, pathologicalScale } from "./pathologicalCases";
 
 if (process.env.HANG_PROBE === "1") {
   console.log(JSON.stringify({ name: "hang-probe", starting: true }));
@@ -41,32 +42,30 @@ if (process.env.HANG_PROBE === "1") {
   }
 }
 
-const scale = Number(process.env.PATHOLOGICAL_SCALE ?? "1");
+const scale = pathologicalScale();
 const schema = getSchema([StarterKit]);
 
 for (const testCase of pathologicalCases(scale)) {
   console.log(JSON.stringify({ name: testCase.name, starting: true }));
   const t0 = performance.now();
-  let doc;
-  try {
-    doc = parseMarkdown(schema, testCase.markdown);
-  } catch (error) {
-    // A nesting refusal is a PASS here, and the only tolerated throw. This
-    // suite's contract is liveness — no hang, no stack overflow — and the
-    // guard added for #1374 satisfies it deliberately rather than by luck.
-    // At scale 1 `deep-blockquotes` is 500 levels and parses; at the soak's
-    // scale 8 it is 4000 and is refused. Any OTHER error still propagates and
-    // fails the run, which is what keeps this from swallowing real defects.
-    if (!isNestingTooDeep(error)) throw error;
+  // A nesting refusal is a defined outcome here, and the only tolerated one.
+  // This suite's contract is liveness — no hang, no stack overflow — and the
+  // guard added for #1374 satisfies it deliberately rather than by luck. At
+  // scale 1 `deep-blockquotes` is 500 levels and parses; at the soak's scale 8
+  // it is 4000 and is refused. Any OTHER error still propagates and fails the
+  // run. The PARENT decides whether a refusal was expected for this case.
+  const outcome = parseArbitraryMarkdown(schema, testCase.markdown);
+  if (outcome.kind === "refused") {
     console.log(
       JSON.stringify({
         name: testCase.name,
         refusedMs: Math.round(performance.now() - t0),
-        refused: "nesting",
+        refusedDepth: outcome.refusal.depth,
       }),
     );
     continue;
   }
+  const doc = outcome.doc;
   const parseMs = performance.now() - t0;
   let serializeMs = 0;
   if (testCase.serialize) {
diff --git a/src/utils/markdownPipeline/dialect.test.ts b/src/utils/markdownPipeline/dialect.test.ts
index 82e24a405..1052b75d4 100644
--- a/src/utils/markdownPipeline/dialect.test.ts
+++ b/src/utils/markdownPipeline/dialect.test.ts
@@ -131,6 +131,7 @@ describe("the deltas between modes are the declared ones", () => {
     expect(namesFor("inline-summary")).toEqual([
       "remarkParse",
       "remarkGfm",
+      "remarkInlineFastPaths",
       "remarkDepthLimit",
       "remarkCustomInline",
     ]);
diff --git a/src/utils/markdownPipeline/dialectDescriptors.ts b/src/utils/markdownPipeline/dialectDescriptors.ts
index 9316e520f..c89a4660f 100644
--- a/src/utils/markdownPipeline/dialectDescriptors.ts
+++ b/src/utils/markdownPipeline/dialectDescriptors.ts
@@ -56,6 +56,7 @@ import {
   remarkDepthLimit,
   type ContentAnalysis,
 } from "./parser/remarkPlugins";
+import { remarkInlineFastPaths } from "./parser/fastPaths/remarkInlineFastPaths";
 
 /**
  * The parse dialects. Each answers a different question, so each runs a
@@ -136,6 +137,13 @@ export const DIALECT: readonly PluginDescriptor[] = [
       "every mode, or `~x~` would become deletion in one dialect and subscript " +
       "in another for the same text.",
   },
+  {
+    name: "remarkInlineFastPaths",
+    plugin: remarkInlineFastPaths,
+    modes: { document: "always", "source-position": "always", "details-body": "always", "inline-summary": "always" },
+    reason: "Linear-time `]`, backtick and emphasis closers that cannot match (#1407). Tree-identical, " +
+      "so every mode. Right after GFM: its emphasis wrapper must sit directly behind micromark's own.",
+  },
   {
     name: "remarkDisableSetextHeadings",
     plugin: remarkDisableSetextHeadings,
diff --git a/src/utils/markdownPipeline/nestingDepth.test.ts b/src/utils/markdownPipeline/nestingDepth.test.ts
index 1b76fa04f..a65368f73 100644
--- a/src/utils/markdownPipeline/nestingDepth.test.ts
+++ b/src/utils/markdownPipeline/nestingDepth.test.ts
@@ -31,7 +31,14 @@
  * @module utils/markdownPipeline/nestingDepth.test
  */
 import { describe, it, expect } from "vitest";
-import { MAX_NESTING_DEPTH, maxContainerDepth, checkNestingDepth } from "./nestingDepth";
+import {
+  MAX_NESTING_DEPTH,
+  maxContainerDepth,
+  checkNestingDepth,
+  nestingRefusal,
+} from "./nestingDepth";
+import { parseMarkdown } from "./adapter";
+import { testSchema } from "./testSchema";
 
 describe("maxContainerDepth", () => {
   it("is zero for ordinary prose", () => {
@@ -118,3 +125,44 @@ describe("checkNestingDepth", () => {
     expect(MAX_NESTING_DEPTH).toBeGreaterThanOrEqual(500);
   });
 });
+
+describe("nestingRefusal (#1407)", () => {
+  const tooDeep = `${"> ".repeat(MAX_NESTING_DEPTH + 7)}a\n`;
+
+  function thrownBy(fn: () => unknown): unknown {
+    try {
+      fn();
+    } catch (error) {
+      return error;
+    }
+    throw new Error("expected a throw");
+  }
+
+  it("reads the depth and the limit off the guard's own error", () => {
+    const error = thrownBy(() => checkNestingDepth(tooDeep));
+    expect(nestingRefusal(error)).toEqual({ depth: MAX_NESTING_DEPTH + 7, limit: MAX_NESTING_DEPTH });
+  });
+
+  it("finds it through parseMarkdown's wrapper, where callers actually meet it", () => {
+    const error = thrownBy(() => parseMarkdown(testSchema, tooDeep));
+    expect(error).toBeInstanceOf(Error);
+    expect(nestingRefusal(error)).toEqual({ depth: MAX_NESTING_DEPTH + 7, limit: MAX_NESTING_DEPTH });
+  });
+
+  it.each([
+    ["an unrelated error", new Error("boom")],
+    ["an error that merely SAYS it is a nesting refusal", new Error("Nesting is 5000 levels deep")],
+    ["a thrown string", "Nesting is 5000 levels deep"],
+    ["undefined", undefined],
+    ["null", null],
+  ])("is undefined for %s", (_label, error) => {
+    expect(nestingRefusal(error)).toBeUndefined();
+  });
+
+  it("terminates on a cyclic cause chain", () => {
+    const a = new Error("a");
+    const b = new Error("b", { cause: a });
+    (a as { cause?: unknown }).cause = b;
+    expect(nestingRefusal(a)).toBeUndefined();
+  });
+});
diff --git a/src/utils/markdownPipeline/nestingDepth.ts b/src/utils/markdownPipeline/nestingDepth.ts
index 05224d5ef..b11284ff3 100644
--- a/src/utils/markdownPipeline/nestingDepth.ts
+++ b/src/utils/markdownPipeline/nestingDepth.ts
@@ -154,7 +154,7 @@ export function maxContainerDepth(markdown: string): number {
  * otherwise have to match prose through a wrapper — which breaks the first
  * time the wording is edited.
  *
- * Module-local on purpose. `isNestingTooDeep` is the interface, and it is the
+ * Module-local on purpose. `nestingRefusal` is the interface, and it is the
  * one callers should use: a bare `instanceof` would miss the case the wrapper
  * creates, where the refusal arrives as the `cause` of a generic parse error.
  */
@@ -170,18 +170,32 @@ class NestingTooDeepError extends Error {
   }
 }
 
-/** Is `error` — or anything it wraps — a nesting refusal? */
-export function isNestingTooDeep(error: unknown): boolean {
+/** What a nesting refusal reports: how deep the document was, and the limit. */
+export interface NestingRefusal {
+  depth: number;
+  limit: number;
+}
+
+/**
+ * The nesting refusal `error` is — or wraps — or undefined.
+ *
+ * Classified by TYPE along the `cause` chain, never by message: an error that
+ * merely says "Nesting is 5000 levels deep" is not one. Callers that must tell
+ * a deliberate refusal from a crash (the fuzz soaks, the editor's parse
+ * failure path) need the numbers too, to say what happened.
+ */
+export function nestingRefusal(error: unknown): NestingRefusal | undefined {
   let cursor: unknown = error;
   // Bounded: a cause chain is short, and an accidental cycle must not hang the
   // caller that is already handling a failure.
   for (let i = 0; i < 10 && cursor instanceof Error; i += 1) {
-    if (cursor instanceof NestingTooDeepError) return true;
+    if (cursor instanceof NestingTooDeepError) return { depth: cursor.depth, limit: cursor.limit };
     cursor = (cursor as { cause?: unknown }).cause;
   }
-  return false;
+  return undefined;
 }
 
+
 /** Throw if `markdown` nests deeper than the parser can survive. */
 export function checkNestingDepth(markdown: string): void {
   const depth = maxContainerDepth(markdown);
diff --git a/src/utils/markdownPipeline/parser/fastPaths/attentionFastPath.ts b/src/utils/markdownPipeline/parser/fastPaths/attentionFastPath.ts
new file mode 100644
index 000000000..73339b6c3
--- /dev/null
+++ b/src/utils/markdownPipeline/parser/fastPaths/attentionFastPath.ts
@@ -0,0 +1,237 @@
+/**
+ * Purpose: resolve `*`/`_` emphasis without walking every closer back to the
+ * start of the paragraph.
+ *
+ * micromark resolves attention in one `resolveAll` pass: for every sequence
+ * that can close, it walks back EVENT BY EVENT to the nearest sequence that can
+ * open with the same marker (and passes the rule of three). A closer with
+ * nothing to find walks all the way, so the cost is O(closers × events):
+ *
+ *   - `a_ ` × 24000, where every `_` closes and none opens: 27s to parse and
+ *     44s to serialize at the soak's scale (#1407);
+ *   - `*_` × 12000 `x` `_*` × 12000, where earlier matches CONSUME the only
+ *     candidate openers, so two of every three closers walk to the start:
+ *     117s to parse.
+ *
+ * This is micromark-core-commonmark 2.0.3's `resolveAllAttention`, ported with
+ * one change: the walk. Instead of every event, a closer scans a per-marker
+ * list of the opener sequences still present before it — exactly the events
+ * the walk would stop at — nearest first, applying the stock test to each.
+ * The match it finds, and everything done with it (the tokens, the points, the
+ * inner span resolved through `insideSpan`, the splice, where the loop resumes)
+ * is the stock code, line for line.
+ *
+ * Why the list is exact: an opener enters the list when the loop passes its
+ * exit event, which it does for every event before a closer. A match removes
+ * the opener if fully used and every list entry inside the matched span — the
+ * span's sequences become data, and the stock walk would skip them. Entries
+ * below the opener keep their indices: the splice starts at the opener.
+ *
+ * Mechanism: `attention` is disabled by name and this wrapper takes its place
+ * at `*` and `_`. It tokenizes with micromark's own `attention` tokenizer,
+ * looked up from the parser rather than imported. Link text inside a label is
+ * still resolved by the stock resolver through `insideSpan`, as before.
+ *
+ * PLACE matters, unlike for the `]` and backtick fast paths: this wrapper
+ * SUCCEEDS, so whichever construct micromark tries first at `_` wins. GFM's
+ * email autolink is registered ahead of `attention` there, and a wrapper added
+ * in front of both turned `(_A_@_.A` from a link into emphasis — the
+ * equivalence test (`inlineFastPaths.test.ts`) caught exactly that. So the
+ * wrapper is added AFTER, and refuses loudly to run anywhere but directly
+ * behind the disabled stock construct, where the order of everything
+ * micromark tries is unchanged.
+ *
+ * Known limitations: every match still re-resolves its inner span and splices
+ * the event list, as stock does, so deeply NESTED matched emphasis stays
+ * quadratic in its depth; and openers the rule of three skips are re-scanned by
+ * each later closer, where cmark keeps a per-class floor.
+ *
+ * @coordinates-with micromarkTypes.ts — the tokenizer API slice used here
+ * @coordinates-with remarkInlineFastPaths.ts — registers this construct
+ * @module utils/markdownPipeline/parser/fastPaths/attentionFastPath
+ */
+import type {
+  Construct,
+  Effects,
+  Event,
+  ParseContext,
+  Point,
+  Resolver,
+  State,
+  Token,
+  TokenizeContext,
+} from "./micromarkTypes";
+
+const ASTERISK = 42;
+const UNDERSCORE = 95;
+export const STOCK_ATTENTION = "attention";
+const NAME = "vmarkAttention";
+/** micromark-util-chunked's bound on arguments passed to one native splice. */
+const SPLICE_CHUNK = 10_000;
+
+const placementChecked = new WeakSet<ParseContext>();
+
+/** Everything micromark registered at `code`, disabled or not, in try order. */
+function registeredAt(parser: ParseContext, code: number): Construct[] {
+  const registered = parser.constructs.text[code];
+  return Array.isArray(registered) ? registered : registered ? [registered] : [];
+}
+
+/**
+ * micromark's own `attention` construct, found by name in the parser — after
+ * confirming, once per parser, that the wrapper sits in its place.
+ *
+ * Returns undefined when there is no stock construct to wrap: then nothing was
+ * disabled by that name either, and declining is exactly the stock behaviour.
+ */
+function stockAttention(parser: ParseContext): Construct | undefined {
+  const stock = registeredAt(parser, ASTERISK).find((c) => c.name === STOCK_ATTENTION);
+  if (!stock || placementChecked.has(parser)) return stock;
+  const disabled = parser.constructs.disable.null ?? [];
+  for (const code of [ASTERISK, UNDERSCORE]) {
+    const list = registeredAt(parser, code);
+    const from = list.indexOf(stock);
+    const to = list.findIndex((c) => c.name === NAME);
+    const between = list.slice(from + 1, to);
+    if (from < 0 || to < from || between.some((c) => !(c.name && disabled.includes(c.name)))) {
+      throw new Error(
+        `[MarkdownPipeline] ${NAME} is not directly behind micromark's attention at ` +
+          `character ${code}; it would change which construct wins there. Register ` +
+          `remarkInlineFastPaths before any plugin that appends constructs at * or _.`,
+      );
+    }
+  }
+  placementChecked.add(parser);
+  return stock;
+}
+
+function tokenizeAttention(this: TokenizeContext, effects: Effects, ok: State, nok: State): State {
+  const stock = stockAttention(this.parser);
+  if (!stock) return nok;
+  return stock.tokenize.call(this, effects, ok, nok);
+}
+
+/** micromark-util-chunked `splice`: the same result, chunked for huge inserts. */
+function spliceEvents(list: Event[], start: number, remove: number, items: Event[]): void {
+  if (items.length < SPLICE_CHUNK) {
+    list.splice(start, remove, ...items);
+    return;
+  }
+  if (remove) list.splice(start, remove);
+  for (let chunk = 0; chunk < items.length; chunk += SPLICE_CHUNK) {
+    list.splice(start + chunk, 0, ...items.slice(chunk, chunk + SPLICE_CHUNK));
+  }
+}
+
+/** micromark-util-resolve-all: each distinct resolver once, in order. */
+function resolveAllOnce(constructs: ReadonlyArray<{ resolveAll?: Resolver }>, events: Event[], context: TokenizeContext): Event[] {
+  const called: Resolver[] = [];
+  let result = events;
+  for (const construct of constructs) {
+    const resolve = construct.resolveAll;
+    if (resolve && !called.includes(resolve)) {
+      result = resolve(result, context);
+      called.push(resolve);
+    }
+  }
+  return result;
+}
+
+function movePoint(point: Point, offset: number): void {
+  point.column += offset;
+  point.offset += offset;
+  point._bufferIndex += offset;
+}
+
+const size = (token: Token): number => token.end.offset - token.start.offset;
+
+function resolveAllAttention(events: Event[], context: TokenizeContext): Event[] {
+  /** Marker code → ascending exit-event indices of sequences that can open. */
+  const openers = new Map<number, number[]>();
+  const markers = new WeakMap<Token, number>();
+  const markerOf = (token: Token): number => {
+    let marker = markers.get(token);
+    if (marker === undefined) {
+      marker = context.sliceSerialize(token).charCodeAt(0);
+      markers.set(token, marker);
+    }
+    return marker;
+  };
+
+  let index = -1;
+  while (++index < events.length) {
+    const [kind, closer] = events[index];
+    if (closer.type !== "attentionSequence") continue;
+    if (kind === "exit") {
+      if (closer._open) {
+        const list = openers.get(markerOf(closer));
+        if (list) list.push(index);
+        else openers.set(markerOf(closer), [index]);
+      }
+      continue;
+    }
+    if (!closer._close) continue;
+    const candidates = openers.get(markerOf(closer));
+    if (!candidates) continue;
+
+    for (let k = candidates.length - 1; k >= 0; k -= 1) {
+      const open = candidates[k];
+      const opener = events[open][1];
+      // Stock's walk stops only at these; a stale entry is skipped the same way.
+      if (events[open][0] !== "exit" || opener.type !== "attentionSequence" || !opener._open) continue;
+      if ((opener._close || closer._open) && size(closer) % 3 && !((size(opener) + size(closer)) % 3)) {
+        continue;
+      }
+
+      // From here to the splice: micromark's resolver, unchanged.
+      const use = size(opener) > 1 && size(closer) > 1 ? 2 : 1;
+      const start = { ...opener.end };
+      const end = { ...closer.start };
+      movePoint(start, -use);
+      movePoint(end, use);
+      const openingSequence: Token = { type: use > 1 ? "strongSequence" : "emphasisSequence", start, end: { ...opener.end } };
+      const closingSequence: Token = { type: use > 1 ? "strongSequence" : "emphasisSequence", start: { ...closer.start }, end };
+      const text: Token = { type: use > 1 ? "strongText" : "emphasisText", start: { ...opener.end }, end: { ...closer.start } };
+      const group: Token = { type: use > 1 ? "strong" : "emphasis", start: { ...openingSequence.start }, end: { ...closingSequence.end } };
+      opener.end = { ...openingSequence.start };
+      closer.start = { ...closingSequence.end };
+
+      let nextEvents: Event[] = [];
+      if (size(opener)) nextEvents.push(["enter", opener, context], ["exit", opener, context]);
+      nextEvents.push(["enter", group, context], ["enter", openingSequence, context], ["exit", openingSequence, context], ["enter", text, context]);
+      nextEvents = nextEvents.concat(resolveAllOnce(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));
+      nextEvents.push(["exit", text, context], ["enter", closingSequence, context], ["exit", closingSequence, context], ["exit", group, context]);
+      const offset = size(closer) ? 2 : 0;
+      if (offset) nextEvents.push(["enter", closer, context], ["exit", closer, context]);
+
+      // Every list, not just this marker's: the splice rewrites everything
+      // after the opener, so an entry past it names an event inside the span
+      // — now data — and, left in place, could alias a later sequence at a
+      // shifted index out of order. A spent opener leaves too.
+      for (const list of openers.values()) {
+        while (list.length > 0 && (list.at(-1) as number) > open) list.pop();
+      }
+      if (!size(opener)) candidates.pop();
+
+      spliceEvents(events, open - 1, index - open + 3, nextEvents);
+      index = open + nextEvents.length - offset - 2;
+      break;
+    }
+  }
+
+  // Remove remaining sequences.
+  for (const [, token] of events) {
+    if (token.type === "attentionSequence") token.type = "data";
+  }
+  return events;
+}
+
+/** Takes `attention`'s place at `*` and `_`; see the header. */
+export const attentionWithoutFutileWalks: Construct = {
+  name: NAME,
+  add: "after",
+  tokenize: tokenizeAttention,
+  resolveAll(events, context) {
+    return stockAttention(context.parser) ? resolveAllAttention(events, context) : events;
+  },
+};
diff --git a/src/utils/markdownPipeline/parser/fastPaths/codeTextFastPath.ts b/src/utils/markdownPipeline/parser/fastPaths/codeTextFastPath.ts
new file mode 100644
index 000000000..d8401fd42
--- /dev/null
+++ b/src/utils/markdownPipeline/parser/fastPaths/codeTextFastPath.ts
@@ -0,0 +1,150 @@
+/**
+ * Purpose: settle a backtick run that no later run can close in O(run length),
+ * instead of letting micromark scan to the end of the paragraph to find that
+ * out.
+ *
+ * micromark's `codeText` starts at a run of k backticks and consumes forward
+ * until a run of EXACTLY k backticks, or the end of the paragraph. When no such
+ * run exists it fails — and every other unmatched opener pays the same scan.
+ * Runs of distinct lengths therefore cost O(openers × paragraph), which for
+ * the soak's `backtick-runs` class is cubic in the number of runs: it had not
+ * finished after twelve minutes at soak scale (#1407). cmark fixed the same
+ * class by remembering, per run length, where the last such run was.
+ *
+ * So does this construct, registered ahead of `codeText`:
+ *
+ *   1. Until a memo exists, an opener scans exactly as far as `codeText` will:
+ *      to its first closing run, or to the end of the paragraph. It records
+ *      the start offset of the last run of each length on the way, and then
+ *      defers, so `codeText` runs exactly as before. Only a scan that reached
+ *      the end leaves its record behind as the memo.
+ *   2. Every LATER opener of length k looks up the last run of length k. If it
+ *      starts after the opener, `codeText` will close on some run of length k,
+ *      so this defers. If not, `codeText` must fail, so the run is consumed as
+ *      plain data — which is what the text tokenizer does with it anyway once
+ *      `codeText` fails.
+ *
+ * Why never read further than `codeText`: a lookahead that crosses a line
+ * ending reaches a chunk the subtokenizer has not written yet, and the
+ * container skip it defines on the next line is then applied to the lookahead's
+ * point instead of the real one. That moved a text node's end by a column in a
+ * list continuation (audit counterexample: `*<TAB>` then two lines of code spans).
+ * The skipped scans in step 2 cannot do the same: a memo exists only after a
+ * scan reached the end, and by then every chunk and every skip is in place.
+ *
+ * Why the memo is exact: `codeText` closes on the first MAXIMAL run of exactly
+ * the opener's length after the opener, and nothing inside a code span can end
+ * it early. Runs after the opener are delimited by non-backtick characters, so
+ * a scan from any earlier point segments them identically. The one run whose
+ * segmentation can differ is the opener's own (after an escaped backtick), and
+ * `start > opener` excludes it.
+ *
+ * `previous` is copied from `codeText` so this construct never changes which
+ * characters the text tokenizer treats as a break. `inlineFastPaths.test.ts`
+ * diffs the mdast, positions included, against the stock parser.
+ *
+ * @coordinates-with micromarkTypes.ts — the tokenizer API slice used here
+ * @coordinates-with remarkInlineFastPaths.ts — registers this construct
+ * @module utils/markdownPipeline/parser/fastPaths/codeTextFastPath
+ */
+import {
+  onlyModelledConstructs,
+  type Code,
+  type Construct,
+  type Effects,
+  type Event,
+  type ParseContext,
+  type State,
+  type TokenizeContext,
+} from "./micromarkTypes";
+
+const GRAVE_ACCENT = 96;
+const NAME = "vmarkInertCodeTextSequence";
+const CODE_TEXT = "codeText";
+const MODELLED: ReadonlySet<string> = new Set([NAME, CODE_TEXT]);
+
+/** Backtick runs after the paragraph's first opener, by length. */
+interface RunMemo {
+  /** Offset of the opener whose scan built this memo. */
+  from: number;
+  /** Run length → start offset of the LAST run of that length. */
+  lastStart: Map<number, number>;
+}
+
+const memos = new WeakMap<Event[], RunMemo>();
+const modelledAtGrave = new WeakMap<ParseContext, boolean>();
+
+/** `codeText`'s own `previous`: a run starts where the previous character is
+ *  not a backtick, or where that backtick was escaped. */
+function previousAllowsCodeText(this: TokenizeContext, code: Code): boolean {
+  return code !== GRAVE_ACCENT || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+
+function tokenizeInertCodeTextSequence(
+  this: TokenizeContext,
+  effects: Effects,
+  ok: State,
+  nok: State,
+): State {
+  if (!onlyModelledConstructs(modelledAtGrave, this.parser, GRAVE_ACCENT, MODELLED)) return nok;
+
+  // `now` is a closure over the tokenizer, not a method, so it needs no `this`.
+  const { events, now } = this;
+  const opener = now().offset;
+  const known = memos.get(events);
+  const memo = known && known.from <= opener ? known : undefined;
+  const recording: RunMemo = { from: opener, lastStart: new Map() };
+  let size = 0;
+  let runStart = 0;
+  let runSize = 0;
+  return openingRun;
+
+  function openingRun(code: Code): State | undefined {
+    if (code === GRAVE_ACCENT) {
+      if (size === 0) effects.enter("data");
+      effects.consume(code);
+      size += 1;
+      return openingRun;
+    }
+    if (!memo) return scanBetween(code);
+    const last = memo.lastStart.get(size);
+    if (last !== undefined && last > opener) return nok(code); // codeText will close
+    effects.exit("data");
+    return ok(code);
+  }
+
+  /** Record every later run to the end of the paragraph, then defer. */
+  function scanBetween(code: Code): State | undefined {
+    if (code === null) {
+      memos.set(events, recording);
+      return nok(code);
+    }
+    if (code === GRAVE_ACCENT) {
+      runStart = now().offset;
+      runSize = 0;
+      return scanRun(code);
+    }
+    effects.consume(code);
+    return scanBetween;
+  }
+
+  function scanRun(code: Code): State | undefined {
+    if (code === GRAVE_ACCENT) {
+      effects.consume(code);
+      runSize += 1;
+      return scanRun;
+    }
+    // A closing run: `codeText` will stop here, so stop here too, and leave no
+    // memo — a scan must never read further than `codeText`'s own would.
+    if (runSize === size) return nok(code);
+    recording.lastStart.set(runSize, runStart);
+    return scanBetween(code);
+  }
+}
+
+/** Registered at a backtick, ahead of micromark's `codeText`. */
+export const inertCodeTextSequence: Construct = {
+  name: NAME,
+  previous: previousAllowsCodeText,
+  tokenize: tokenizeInertCodeTextSequence,
+};
diff --git a/src/utils/markdownPipeline/parser/fastPaths/inlineFastPaths.test.ts b/src/utils/markdownPipeline/parser/fastPaths/inlineFastPaths.test.ts
new file mode 100644
index 000000000..3f633de84
--- /dev/null
+++ b/src/utils/markdownPipeline/parser/fastPaths/inlineFastPaths.test.ts
@@ -0,0 +1,168 @@
+// @vitest-environment node
+/**
+ * #1407 — the inline fast paths must never change a parse.
+ *
+ * Each fast path settles a character only on a proof that micromark's own
+ * construct would fail there, so a parser with the fast paths must produce the
+ * SAME mdast as one without — node for node, and position for position. This
+ * file checks exactly that, three ways:
+ *
+ *   1. every example of every vendored spec corpus (CommonMark, GFM, and the
+ *      rest of the registry) — the constructs' documented behaviour;
+ *   2. hand-picked inputs at each fast path's decision boundary — the cases a
+ *      wrong proof would get wrong first;
+ *   3. a seeded fuzz over an alphabet dense in `[`, `]`, `![`, `^`, backticks,
+ *      `*` and `_` — the interactions nobody thought to write down.
+ *
+ * That they make anything FASTER is the other half of the contract, and lives
+ * in `__tests__/pathological/pathologicalScaling.test.ts`.
+ *
+ * @coordinates-with remarkInlineFastPaths.ts — the plugin under test
+ * @coordinates-with ../../__tests__/spec/corpusRegistry.ts — the corpora
+ * @module utils/markdownPipeline/parser/fastPaths/inlineFastPaths.test
+ */
+import { describe, it, expect } from "vitest";
+import fc from "fast-check";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkFrontmatter from "remark-frontmatter";
+import { remarkInlineFastPaths } from "./remarkInlineFastPaths";
+import { CORPORA, loadExamples } from "../../__tests__/spec/corpusRegistry";
+
+const stock = unified()
+  .use(remarkParse)
+  .use(remarkGfm, { singleTilde: false })
+  .use(remarkMath)
+  .use(remarkFrontmatter, ["yaml"]);
+
+const fast = unified()
+  .use(remarkParse)
+  .use(remarkGfm, { singleTilde: false })
+  .use(remarkInlineFastPaths)
+  .use(remarkMath)
+  .use(remarkFrontmatter, ["yaml"]);
+
+/** What the comparison needs from a processor: parsing, and nothing else. */
+interface Parses {
+  parse(markdown: string): unknown;
+  data(): unknown;
+}
+
+/** The syntax tree with positions, as a comparable string. */
+function tree(processor: Parses, markdown: string): string {
+  return JSON.stringify(processor.parse(markdown));
+}
+
+function expectSameTree(markdown: string): void {
+  expect(tree(fast, markdown), JSON.stringify(markdown)).toBe(tree(stock, markdown));
+}
+
+const BRACKET_BOUNDARIES = [
+  "[a](b)", "[a]", "[a][]", "[a][b]\n\n[b]: /u", "[a]\n\n[a]: /u", "![a](b)", "![a]",
+  "[![a](b)](c)", "[a [b](c) d](e)", "[a](b]c)", "\\[a](b)", "a]", "]", "]]]", "[]", "[](x)",
+  "![]()", "[a\nb](c)", "[`a]`](b)", "`[a`](b)", "<a title=\"]\">x</a>]", "<https://x.y/]>",
+  "[a](<b]>)", "*[a*](b)", "[中文](链接)", "[😀]\n\n[😀]: /e", "a](a](a](", "[a](<b[a](<b",
+  "> [a\n> ](b)", "- [a\n  ](b)", "| a | [b |\n|---|---|\n| ] | c](d) |", "[a] ]\n\n[a]: /u",
+  "[a](b) ] [c](d) ]", "[a [b] c](d)", "[[a]](b)", "![[a](b)](c) ]", "![a] ] ]",
+  // Footnote calls and the potential call behind a balanced image label.
+  "[^1]\n\n[^1]: note", "![^1]\n\n[^1]: note", "![ ^1]\n\n[^1]: note", "![\t^1]\n\n[^1]: note",
+  "![\n^1]\n\n[^1]: note", "![x] a] b]\n\n[^1]: note", "![^1] ] ]\n\n[^1]: note",
+  "![^2]\n\n[^1]: note", "![^1\n\n[^1]: note", "![ ]\n\n[^1]: note", "![^1] [^1]\n\n[^1]: note",
+  "[^1] ] ![^1]\n\n[^1]: note", "![x] [^1]\n\n[^1]: note",
+  // A LATER `]` behind a balanced `![^…` can never complete a footnote call —
+  // its label would hold a bare `]`, and no definition label can. These are the
+  // spellings that argument has to survive: escaped brackets and backslash
+  // runs in the definition, in the call, and between them.
+  "![^y] a] b]\n\n[^x]: note", "![^a] ]\n\n[^a\\]]: note", "![^a\\] ]\n\n[^a\\]]: note",
+  "![^a\\\\] ]\n\n[^a\\\\]: note", "![^a] b]\n\n[^a]b]: note", "![^\\]] ]\n\n[^\\]]: note",
+  "![^a]\\] ]\n\n[^a]: note", "![^a `]` ] c]\n\n[^a]: note", "![^a] ]\n\n[^a]: note\n[^a] ]: n",
+];
+
+const BACKTICK_BOUNDARIES = [
+  "`a`", "``a``", "`a``", "``a`", "` `` `", "\\`a`", "\\``a``", "`a\nb`", "e`e``e```",
+  "`` ` ``", "```a```", "a ` b ` c ` d", "`a` `b`", "``` `a` ```", "`[a](b)`", "\\\\`a`",
+  "` a`b` `", "> `a\n> b`", "`a`\n\n`b`", "`é`", "``中``", "`\t`", "`a` ``b`` `c", "``a` `b``",
+  "`a\\`b`", "\\`\\``a`", "e`e``e```e``e`", "`", "``", "a`", "`\n`", "- `a\n  b`",
+  "| `a | b` |\n|---|---|\n| `c` | d |", "<code>`</code>`", "[`](`)", "*`a*`",
+  // Container continuations: a lookahead reading past the line ending moved a
+  // text node's end by a column (audit counterexamples).
+  "*\t`x`\n\t`x`", "1. \n\t]]\n  `x`_\n\t`x`", "> `a`\n> `b`\n> `", "- `a\n\t`b`\n  ``c",
+];
+
+const EMPHASIS_BOUNDARIES = [
+  "a_ a_ a_", "*a*", "**a**", "_a_", "a*b*c", "a_b_c", "*a_", "_a*", "***a***", "*a **b** c*",
+  "**a*", "a** b*", "* a *", "a_ _b_", "_a_ b_", "*a* b* c*", "foo*bar*", "__a__", "_ a_",
+  "a* *b", "*a\n*", "[*a](b*)", "*[a*](b)", "`*a`*", "\\*a*", "a**b**c**", "*(*a*)*",
+  "_(_a_)_", "a ** b", "**a*b***", "a* b* *c", "a_ b_ _c_", "*a**b*", "a***b* c**",
+  "中*文*", "a*😀*b", "_a_\n\n_b", "a_ *b* c_", "a* _b_ c*",
+];
+
+describe("inline fast paths leave every parse unchanged (#1407)", () => {
+  it("on every vendored spec corpus example", () => {
+    let checked = 0;
+    for (const entry of CORPORA) {
+      for (const example of loadExamples(entry)) {
+        expectSameTree(example.markdown);
+        checked += 1;
+      }
+    }
+    // Non-vacuity: the registry is large; a loader that returned nothing
+    // would otherwise pass this with zero comparisons.
+    expect(checked).toBeGreaterThan(600);
+  });
+
+  it.each(BRACKET_BOUNDARIES)("at a `]` decision boundary: %j", expectSameTree);
+
+  it.each(BACKTICK_BOUNDARIES)("at a backtick decision boundary: %j", expectSameTree);
+
+  it.each(EMPHASIS_BOUNDARIES)("at an emphasis decision boundary: %j", expectSameTree);
+
+  it("defers to a catch-all construct another extension registers for EVERY character", () => {
+    // micromark tries `text.null` constructs at every code, after the code's
+    // own list. A fast path that only read the list for `]` and backtick would
+    // settle a character such a construct was about to claim. (Audit finding.)
+    const claimsBracketsAndBackticks = {
+      name: "testCatchAll",
+      tokenize(effects: { enter(t: string): void; exit(t: string): void; consume(c: number): void }, ok: unknown, nok: (c: number) => unknown) {
+        return (code: number) => {
+          if (code !== 93 && code !== 96) return nok(code);
+          effects.enter("htmlText");
+          effects.enter("htmlTextData");
+          effects.consume(code);
+          effects.exit("htmlTextData");
+          effects.exit("htmlText");
+          return ok;
+        };
+      },
+    };
+    const withCatchAll = (processor: Parses): Parses => {
+      const data = processor.data() as { micromarkExtensions?: unknown[] };
+      (data.micromarkExtensions ??= []).push({ text: { null: [claimsBracketsAndBackticks] } });
+      return processor;
+    };
+    const stockWith = withCatchAll(unified().use(remarkParse).use(remarkGfm, { singleTilde: false }));
+    const fastWith = withCatchAll(unified().use(remarkParse).use(remarkGfm, { singleTilde: false }).use(remarkInlineFastPaths));
+    for (const markdown of ["a ] b", "a ` b", "a](a](", "e`e``e```", "*a*"]) {
+      expect(tree(fastWith, markdown), JSON.stringify(markdown)).toBe(tree(stockWith, markdown));
+    }
+  });
+
+  const SEED = Number(process.env.FAST_PATH_SEED ?? "1407");
+  const TOKENS = [
+    "[", "]", "![", "(", ")", "<", ">", "^", " ", "\t", "\n", "\n\n", "a", "b", "\\", "`", "``",
+    "*", "**", "_", "__", ":", "/", "中", "😀", "[^1]", "[^1]: n\n\n", "[a]: /u\n\n", "> ", "- ",
+    "\\\\", "\\]", "![^1", "[^1\\]]: n\n\n",
+  ];
+  const document = fc.array(fc.constantFrom(...TOKENS), { maxLength: 40 }).map((t) => t.join(""));
+
+  it(`on fuzzed delimiter-dense documents (seed ${SEED})`, () => {
+    fc.assert(
+      fc.property(document, (markdown) => {
+        expect(tree(fast, markdown)).toBe(tree(stock, markdown));
+      }),
+      { numRuns: 3000, seed: SEED },
+    );
+  }, 120_000);
+});
diff --git a/src/utils/markdownPipeline/parser/fastPaths/labelEndFastPath.ts b/src/utils/markdownPipeline/parser/fastPaths/labelEndFastPath.ts
new file mode 100644
index 000000000..ac742a2e9
--- /dev/null
+++ b/src/utils/markdownPipeline/parser/fastPaths/labelEndFastPath.ts
@@ -0,0 +1,166 @@
+/**
+ * Purpose: settle a `]` that nothing can close in O(1) amortized, instead of
+ * letting micromark walk back through the whole paragraph to find that out.
+ *
+ * Two constructs are tried at every `]` in text, and both begin with a
+ * backward scan over every event tokenized so far:
+ *
+ *   - `labelEnd` (micromark-core-commonmark) walks back to the nearest label
+ *     start that is not yet balanced;
+ *   - `gfmPotentialFootnoteCall` (micromark-extension-gfm-footnote) walks back
+ *     to the nearest label image, link or footnote call.
+ *
+ * When the paragraph has no opener, both walks reach its start and fail — so
+ * `a](` repeated n times costs O(n²). Measured at the soak's scale (#1407):
+ * 60s to parse, and 276s to serialize, because the serializer's cosmetic pass
+ * re-parses its output twice.
+ *
+ * This construct runs FIRST at `]`. It keeps an incremental index of the label
+ * starts in the event list, and consumes the `]` as plain data exactly when no
+ * unbalanced `labelLink`/`labelImage` exists. Both stock constructs must then
+ * fail:
+ *
+ *   - `labelEnd` needs an unbalanced label start, by definition.
+ *   - The potential footnote call needs a balanced `![` whose label, from the
+ *     `![` to this `]`, names a defined footnote. A `![` is balanced only by a
+ *     `]` that label-end tried and rejected — an unescaped `]` that is then
+ *     INSIDE the label of every later `]`. A footnote definition label cannot
+ *     contain an unescaped `]` (gfm's own definition tokenizer ends the label
+ *     there), so no later `]` can complete that call. The one `]` that can is
+ *     the one that balances the `![` — and at that `]` the `![` is still an
+ *     unbalanced opener, so this construct defers.
+ *
+ * Anything else defers to the stock constructs, which then run exactly as
+ * before. So the fast path can only make a parse FASTER; it cannot make one
+ * different — `inlineFastPaths.test.ts` diffs the mdast, positions included,
+ * against the stock parser over every vendored spec corpus, the spellings the
+ * footnote argument has to survive, and a seeded fuzz.
+ *
+ * Key decisions:
+ *   - PROOF, NOT REIMPLEMENTATION. Resources, references, `_inactive` links,
+ *     definitions — all of it stays in micromark. Only "can this `]` close
+ *     anything at all?" is answered here, and only the NO answer is acted on.
+ *   - WATCHES, NOT TRUST. A deferred `]` may let a stock construct succeed and
+ *     splice the events from the label start it matched — label-end from the
+ *     nearest unbalanced opener, the footnote call from that same `![`. Both
+ *     resolvers put a NEW event at that index, so the index records the event
+ *     there and re-indexes from it when it changes. Nothing else rewrites
+ *     events below the scanned mark during text tokenization; a tail check
+ *     backstops that claim by rebuilding from zero rather than trusting it.
+ *   - UNKNOWN CONSTRUCTS DEFER. If anything but the two modelled constructs is
+ *     registered at `]`, the fast path cannot prove inertness and never fires.
+ *
+ * Known limitation: when a candidate opener DOES exist, stock `labelEnd`
+ * serializes the whole label text to look up a definition — O(label length)
+ * per `]`, so `[` × n followed by `]` × n stays quadratic. That cost is the
+ * lookup itself, not the scan, and removing it would mean changing which
+ * labels can match a definition.
+ *
+ * @coordinates-with micromarkTypes.ts — the tokenizer API slice used here
+ * @coordinates-with remarkInlineFastPaths.ts — registers this construct
+ * @module utils/markdownPipeline/parser/fastPaths/labelEndFastPath
+ */
+import {
+  onlyModelledConstructs,
+  type Construct,
+  type Effects,
+  type Event,
+  type ParseContext,
+  type State,
+  type TokenizeContext,
+} from "./micromarkTypes";
+
+const RIGHT_SQUARE_BRACKET = 93;
+const NAME = "vmarkInertLabelEnd";
+const MODELLED: ReadonlySet<string> = new Set([NAME, "labelEnd", "gfmPotentialFootnoteCall"]);
+
+/** Tokens `labelEnd` accepts as an opener (when not `_balanced`). */
+const LABEL_STARTS: ReadonlySet<string> = new Set(["labelLink", "labelImage"]);
+
+interface Watch {
+  index: number;
+  event: Event;
+}
+
+/** Incremental index over ONE tokenizer's event list. */
+interface OpenerIndex {
+  /** Events `[0, scanned)` are reflected in `openers`. */
+  scanned: number;
+  /** `events[scanned - 1]` when indexed — the backstop's sentinel. */
+  tail: Event | undefined;
+  /** Ascending enter-event indices of label starts not yet seen balanced. */
+  openers: number[];
+  /** Where a deferred `]` could have let a stock resolver splice. */
+  watches: Watch[];
+}
+
+const indexes = new WeakMap<Event[], OpenerIndex>();
+const modelledAtBracket = new WeakMap<ParseContext, boolean>();
+
+/** Bring the index up to date with `events`, re-indexing whatever changed. */
+function syncIndex(events: Event[]): OpenerIndex {
+  let index = indexes.get(events);
+  if (!index) {
+    index = { scanned: 0, tail: undefined, openers: [], watches: [] };
+    indexes.set(events, index);
+  }
+
+  let from = index.scanned;
+  for (const watch of index.watches) {
+    if (events[watch.index] !== watch.event) from = Math.min(from, watch.index);
+  }
+  index.watches = [];
+  const untouched =
+    from === index.scanned &&
+    (index.scanned === 0 || (index.scanned <= events.length && events[index.scanned - 1] === index.tail));
+  if (!untouched && from === index.scanned) from = 0; // backstop: an unexplained rewrite
+  from = Math.min(from, events.length);
+
+  if (from < index.scanned) {
+    while (index.openers.length > 0 && (index.openers.at(-1) as number) >= from) index.openers.pop();
+    index.scanned = from;
+  }
+  for (let i = index.scanned; i < events.length; i += 1) {
+    const [kind, token] = events[i];
+    if (kind === "enter" && LABEL_STARTS.has(token.type)) index.openers.push(i);
+  }
+  index.scanned = events.length;
+  index.tail = events[events.length - 1];
+  return index;
+}
+
+function tokenizeInertLabelEnd(
+  this: TokenizeContext,
+  effects: Effects,
+  ok: State,
+  nok: State,
+): State {
+  if (!onlyModelledConstructs(modelledAtBracket, this.parser, RIGHT_SQUARE_BRACKET, MODELLED)) {
+    return nok;
+  }
+  const { events } = this;
+  const index = syncIndex(events);
+
+  // A label start that failed to match is marked balanced, permanently.
+  while (index.openers.length > 0 && events[index.openers.at(-1) as number][1]._balanced) {
+    index.openers.pop();
+  }
+  const opener = index.openers.at(-1);
+  if (opener !== undefined) {
+    index.watches.push({ index: opener, event: events[opener] });
+    return nok;
+  }
+
+  return function inertBracket(code) {
+    effects.enter("data");
+    effects.consume(code);
+    effects.exit("data");
+    return ok;
+  };
+}
+
+/** Registered at `]`, ahead of micromark's own constructs. */
+export const inertLabelEnd: Construct = {
+  name: NAME,
+  tokenize: tokenizeInertLabelEnd,
+};
diff --git a/src/utils/markdownPipeline/parser/fastPaths/micromarkTypes.ts b/src/utils/markdownPipeline/parser/fastPaths/micromarkTypes.ts
new file mode 100644
index 000000000..6f54fdc46
--- /dev/null
+++ b/src/utils/markdownPipeline/parser/fastPaths/micromarkTypes.ts
@@ -0,0 +1,115 @@
+/**
+ * Purpose: the slice of micromark's tokenizer API the inline fast paths touch,
+ * declared locally, plus the one lookup they all need — "which constructs
+ * would micromark try at this character?"
+ *
+ * Local rather than imported from `micromark-util-types`: that package is a
+ * transitive dependency, and adding it to reach six interfaces would put a
+ * version pin on the parser's internals for no runtime gain. These are
+ * STRUCTURAL: a field micromark renames shows up as a fast path that stops
+ * firing — which the scaling test catches — or one that fires wrongly — which
+ * the equivalence test catches.
+ *
+ * @coordinates-with labelEndFastPath.ts
+ * @coordinates-with codeTextFastPath.ts
+ * @coordinates-with attentionFastPath.ts
+ * @module utils/markdownPipeline/parser/fastPaths/micromarkTypes
+ */
+
+/** A character code: a UTF-16 unit, a negative virtual code, or null (EOF). */
+export type Code = number | null;
+
+export interface Point {
+  line: number;
+  column: number;
+  offset: number;
+  _index: number;
+  _bufferIndex: number;
+}
+
+export interface Token {
+  type: string;
+  start: Point;
+  end: Point;
+  _open?: boolean;
+  _close?: boolean;
+  _balanced?: boolean;
+}
+
+export type Event = [kind: "enter" | "exit", token: Token, context: TokenizeContext];
+
+export type State = (code: Code) => State | undefined;
+
+export type Resolver = (events: Event[], context: TokenizeContext) => Event[];
+
+export interface Effects {
+  enter: (type: string) => Token;
+  exit: (type: string) => Token;
+  consume: (code: Code) => void;
+}
+
+export interface Construct {
+  name?: string;
+  add?: "before" | "after";
+  previous?: (this: TokenizeContext, code: Code) => boolean;
+  tokenize: (this: TokenizeContext, effects: Effects, ok: State, nok: State) => State;
+  resolveAll?: Resolver;
+}
+
+export interface ParseContext {
+  constructs: {
+    /** By character code, plus `null`: constructs tried at EVERY code. */
+    text: Record<number | "null", Construct | Construct[] | undefined>;
+    disable: { null?: string[] };
+    /** Resolvers micromark runs over the text inside a matched span. */
+    insideSpan: { null: ReadonlyArray<{ resolveAll?: Resolver }> };
+  };
+}
+
+export interface TokenizeContext {
+  events: Event[];
+  parser: ParseContext;
+  previous: Code;
+  now: () => Point;
+  sliceSerialize: (token: Pick<Token, "start" | "end">) => string;
+}
+
+/** A micromark syntax extension: constructs keyed by character code. */
+export interface SyntaxExtension {
+  text?: Record<number, Construct[]>;
+  disable?: { null: string[] };
+}
+
+const asList = (entry: Construct | Construct[] | undefined): Construct[] =>
+  Array.isArray(entry) ? entry : entry ? [entry] : [];
+
+/**
+ * Constructs micromark would TRY at `code` in text: the code's own list, then
+ * the `null` list it tries at every code — minus anything disabled.
+ */
+function activeTextConstructs(parser: ParseContext, code: number): Construct[] {
+  const { text, disable } = parser.constructs;
+  const disabled = disable.null ?? [];
+  return [...asList(text[code]), ...asList(text.null)].filter((c) => !(c.name && disabled.includes(c.name)));
+}
+
+/**
+ * Whether every construct micromark would try at `code` is one a fast path
+ * models. An unmodelled construct means a fast path cannot prove the character
+ * is inert, so it must defer — which is always correct, only slower.
+ *
+ * Cached per parser: the construct table is fixed once a parser exists.
+ */
+export function onlyModelledConstructs(
+  cache: WeakMap<ParseContext, boolean>,
+  parser: ParseContext,
+  code: number,
+  modelled: ReadonlySet<string>,
+): boolean {
+  let answer = cache.get(parser);
+  if (answer === undefined) {
+    answer = activeTextConstructs(parser, code).every((c) => c.name !== undefined && modelled.has(c.name));
+    cache.set(parser, answer);
+  }
+  return answer;
+}
diff --git a/src/utils/markdownPipeline/parser/fastPaths/remarkInlineFastPaths.ts b/src/utils/markdownPipeline/parser/fastPaths/remarkInlineFastPaths.ts
new file mode 100644
index 000000000..711ae7998
--- /dev/null
+++ b/src/utils/markdownPipeline/parser/fastPaths/remarkInlineFastPaths.ts
@@ -0,0 +1,51 @@
+/**
+ * Purpose: register micromark fast paths that make three classes of hostile
+ * inline markdown parse in linear time, without changing what any document
+ * parses to (#1407).
+ *
+ * | Fast path | Stock cost it removes |
+ * |---|---|
+ * | `inertLabelEnd` at `]` | a walk to the paragraph start per `]` that nothing can close |
+ * | `inertCodeTextSequence` at a backtick | a scan to the paragraph end per unclosable run |
+ * | `attentionWithoutFutileWalks` at `*`/`_` | a walk to the paragraph start per closer with no opener |
+ *
+ * Each one acts only on a PROOF that micromark's own construct would fail, and
+ * otherwise defers to it, so the tree is identical — the equivalence tests diff
+ * the mdast, positions included, against a parser without this plugin. The
+ * fast paths take the characters micromark would have left as plain data, and
+ * nothing else.
+ *
+ * Why this lives in VMark rather than being waited for upstream: the costs are
+ * inside micromark (latest versions at the time of writing), and a document
+ * that takes minutes to open is a frozen editor now. The pathological soak had
+ * never reached these classes before — an earlier stack overflow ended the run
+ * first — so they were never measured, not recently introduced.
+ *
+ * @coordinates-with labelEndFastPath.ts
+ * @coordinates-with codeTextFastPath.ts
+ * @coordinates-with attentionFastPath.ts
+ * @coordinates-with ../../dialectDescriptors.ts — registers this in every mode
+ * @module utils/markdownPipeline/parser/fastPaths/remarkInlineFastPaths
+ */
+import type { Plugin } from "unified";
+import type { Root } from "mdast";
+import { attentionWithoutFutileWalks, STOCK_ATTENTION } from "./attentionFastPath";
+import { inertCodeTextSequence } from "./codeTextFastPath";
+import { inertLabelEnd } from "./labelEndFastPath";
+import type { SyntaxExtension } from "./micromarkTypes";
+
+/** The micromark syntax extension this plugin registers. */
+const inlineFastPathsExtension: SyntaxExtension = {
+  text: {
+    42: [attentionWithoutFutileWalks],
+    93: [inertLabelEnd],
+    95: [attentionWithoutFutileWalks],
+    96: [inertCodeTextSequence],
+  },
+  disable: { null: [STOCK_ATTENTION] },
+};
+
+export const remarkInlineFastPaths: Plugin<[], Root> = function remarkInlineFastPaths() {
+  const data = this.data() as { micromarkExtensions?: unknown[] };
+  (data.micromarkExtensions ??= []).push(inlineFastPathsExtension);
+};
diff --git a/src/utils/markdownPipeline/plugins/detailsBodyParser.ts b/src/utils/markdownPipeline/plugins/detailsBodyParser.ts
index 5d0c440ee..6952fe005 100644
--- a/src/utils/markdownPipeline/plugins/detailsBodyParser.ts
+++ b/src/utils/markdownPipeline/plugins/detailsBodyParser.ts
@@ -31,6 +31,7 @@ import remarkParse from "remark-parse";
 import remarkGfm from "remark-gfm";
 import remarkMath from "remark-math";
 import remarkFrontmatter from "remark-frontmatter";
+import { remarkInlineFastPaths } from "../parser/fastPaths/remarkInlineFastPaths";
 import { remarkDepthLimit } from "../parser/remarkPlugins";
 import { remarkCustomInline } from "./customInline";
 import { remarkResolveReferences } from "./resolveReferences";
@@ -61,6 +62,7 @@ function buildDefaultBodyProcessor(): DetailsBodyProcessor {
   return unified()
     .use(remarkParse)
     .use(remarkGfm, { singleTilde: false })
+    .use(remarkInlineFastPaths)
     .use(remarkMath)
     .use(remarkDepthLimit)
     .use(remarkFrontmatter, ["yaml"])
diff --git a/src/utils/markdownPipeline/serializer.ts b/src/utils/markdownPipeline/serializer.ts
index 70693b7ad..58ccba313 100644
--- a/src/utils/markdownPipeline/serializer.ts
+++ b/src/utils/markdownPipeline/serializer.ts
@@ -36,11 +36,8 @@ import { remarkCustomInline, remarkDetailsBlock, remarkWikiLinks, tocToMarkdown
 import { handleImage, handleLink, blankLinesJoin } from "./serializerHandlers";
 import type { MarkdownPipelineOptions } from "./types";
 import { parseMarkdownToMdast } from "./parser";
-import {
-  applyCosmeticPass,
-  buildCodeRanges,
-  replaceOutsideCode,
-} from "./serializerCosmetics";
+import { applyCosmeticPass } from "./serializerCosmetics";
+import { buildCodeRanges, replaceOutsideCode } from "./serializerCodeRanges";
 
 /**
  * Build the unified processor configured for VMark markdown serialization.
diff --git a/src/utils/markdownPipeline/serializerCodeRanges.ts b/src/utils/markdownPipeline/serializerCodeRanges.ts
new file mode 100644
index 000000000..02f07e0bf
--- /dev/null
+++ b/src/utils/markdownPipeline/serializerCodeRanges.ts
@@ -0,0 +1,88 @@
+/**
+ * Serialized-markdown code ranges — where the post-stringify passes must not
+ * rewrite text.
+ *
+ * Purpose: the cosmetic pass and the hard-break pass both edit the string
+ * remark-stringify produced, and both must leave fenced code blocks and inline
+ * code spans alone. This module answers "is this offset inside code?" for
+ * them, from one sorted range list.
+ *
+ * Split out of `serializerCosmetics.ts` to keep it within its size budget.
+ *
+ * @coordinates-with serializerCosmetics.ts — skips escapes inside code
+ * @coordinates-with serializer.ts — the hard-break pass
+ * @module utils/markdownPipeline/serializerCodeRanges
+ */
+
+/**
+ * Build sorted, merged character ranges for fenced code blocks and inline
+ * code spans. Ranges are non-overlapping and sorted by start, enabling
+ * O(log N) `isInsideCode` lookups during escape processing.
+ */
+export function buildCodeRanges(markdown: string): Array<[number, number]> {
+  const raw: Array<[number, number]> = [];
+  const fenceRe = /^(`{3,}|~{3,}).*\n([\s\S]*?\n)\1\s*$/gm;
+  let fm: RegExpExecArray | null;
+  while ((fm = fenceRe.exec(markdown))) {
+    raw.push([fm.index, fm.index + fm[0].length]);
+  }
+  // Only treat unescaped backticks as code-span boundaries. Without this,
+  // serialized plain text such as `[\`LICENSE\`]\(./LICENSE).` would falsely
+  // register `\`LICENSE\`` as an inline code range, blocking later escape
+  // stripping on the contained `\``.
+  const inlineRe = /(?<!\\)`[^`]+?(?<!\\)`/g;
+  let im: RegExpExecArray | null;
+  while ((im = inlineRe.exec(markdown))) {
+    raw.push([im.index, im.index + im[0].length]);
+  }
+  if (raw.length <= 1) return raw;
+  raw.sort((a, b) => a[0] - b[0]);
+  const merged: Array<[number, number]> = [raw[0]];
+  for (let i = 1; i < raw.length; i++) {
+    const last = merged[merged.length - 1];
+    const [s, e] = raw[i];
+    if (s <= last[1]) {
+      if (e > last[1]) last[1] = e;
+    } else {
+      merged.push([s, e]);
+    }
+  }
+  return merged;
+}
+
+/**
+ * Binary-search a sorted, non-overlapping ranges array for whether `offset`
+ * falls inside any range. O(log N) vs the previous O(N) `Array.some`.
+ */
+export function isInsideCodeRange(
+  ranges: Array<[number, number]>,
+  offset: number
+): boolean {
+  let lo = 0;
+  let hi = ranges.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const [s, e] = ranges[mid];
+    if (s <= offset) {
+      if (offset < e) return true;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return false;
+}
+
+/** Apply a regex replacement only outside code blocks and inline code. */
+export function replaceOutsideCode(
+  markdown: string,
+  re: RegExp,
+  replacement: string,
+  ranges: Array<[number, number]>
+): string {
+  return markdown.replace(re, (match, ...args) => {
+    const offset = args[args.length - 2] as number;
+    if (isInsideCodeRange(ranges, offset)) return match;
+    return match.replace(re, replacement);
+  });
+}
diff --git a/src/utils/markdownPipeline/serializerCosmetics.ts b/src/utils/markdownPipeline/serializerCosmetics.ts
index dc500def7..7d5b3c770 100644
--- a/src/utils/markdownPipeline/serializerCosmetics.ts
+++ b/src/utils/markdownPipeline/serializerCosmetics.ts
@@ -10,10 +10,12 @@
  *
  * @coordinates-with serializer.ts — the only caller
  * @coordinates-with parser.ts — the re-parse used to verify each edit
+ * @coordinates-with serializerCodeRanges.ts — where edits must not reach
  * @module utils/markdownPipeline/serializerCosmetics
  */
 
 import { parseMarkdownToMdast } from "./parser";
+import { buildCodeRanges, isInsideCodeRange } from "./serializerCodeRanges";
 
 /**
  * Strip unnecessary backslash escapes added by remark-stringify.
@@ -60,79 +62,6 @@ export const BLOCK_START_GUARD: ReadonlySet<string> = new Set(
   [...BLOCK_START_CHARS].filter((c) => UNESCAPABLE_CHARS.has(c)),
 );
 
-/**
- * Build sorted, merged character ranges for fenced code blocks and inline
- * code spans. Ranges are non-overlapping and sorted by start, enabling
- * O(log N) `isInsideCode` lookups during escape processing.
- */
-export function buildCodeRanges(markdown: string): Array<[number, number]> {
-  const raw: Array<[number, number]> = [];
-  const fenceRe = /^(`{3,}|~{3,}).*\n([\s\S]*?\n)\1\s*$/gm;
-  let fm: RegExpExecArray | null;
-  while ((fm = fenceRe.exec(markdown))) {
-    raw.push([fm.index, fm.index + fm[0].length]);
-  }
-  // Only treat unescaped backticks as code-span boundaries. Without this,
-  // serialized plain text such as `[\`LICENSE\`]\(./LICENSE).` would falsely
-  // register `\`LICENSE\`` as an inline code range, blocking later escape
-  // stripping on the contained `\``.
-  const inlineRe = /(?<!\\)`[^`]+?(?<!\\)`/g;
-  let im: RegExpExecArray | null;
-  while ((im = inlineRe.exec(markdown))) {
-    raw.push([im.index, im.index + im[0].length]);
-  }
-  if (raw.length <= 1) return raw;
-  raw.sort((a, b) => a[0] - b[0]);
-  const merged: Array<[number, number]> = [raw[0]];
-  for (let i = 1; i < raw.length; i++) {
-    const last = merged[merged.length - 1];
-    const [s, e] = raw[i];
-    if (s <= last[1]) {
-      if (e > last[1]) last[1] = e;
-    } else {
-      merged.push([s, e]);
-    }
-  }
-  return merged;
-}
-
-/**
- * Binary-search a sorted, non-overlapping ranges array for whether `offset`
- * falls inside any range. O(log N) vs the previous O(N) `Array.some`.
- */
-function isInsideCodeRange(
-  ranges: Array<[number, number]>,
-  offset: number
-): boolean {
-  let lo = 0;
-  let hi = ranges.length - 1;
-  while (lo <= hi) {
-    const mid = (lo + hi) >> 1;
-    const [s, e] = ranges[mid];
-    if (s <= offset) {
-      if (offset < e) return true;
-      lo = mid + 1;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  return false;
-}
-
-/** Apply a regex replacement only outside code blocks and inline code. */
-export function replaceOutsideCode(
-  markdown: string,
-  re: RegExp,
-  replacement: string,
-  ranges: Array<[number, number]>
-): string {
-  return markdown.replace(re, (match, ...args) => {
-    const offset = args[args.length - 2] as number;
-    if (isInsideCodeRange(ranges, offset)) return match;
-    return match.replace(re, replacement);
-  });
-}
-
 /** One pending cosmetic replacement on the serialized string. */
 interface CosmeticEdit {
   start: number;
@@ -177,21 +106,34 @@ function collectEntityEdits(
   return edits;
 }
 
-/** Collect candidate escape strips, applying the same guards as before. */
+/**
+ * Collect candidate escape strips, applying the same guards as before.
+ *
+ * "Only whitespace before it on its line" is tracked in ONE forward pass. It
+ * was a `lastIndexOf` + `slice` per escape, which walks back to the line start
+ * each time — O(n²) on a long line of escapes, and every hostile inline class
+ * serializes to exactly that (#1407). `\s` is the set `trimStart` removes.
+ */
 function collectEscapeEdits(
   markdown: string,
   ranges: Array<[number, number]>
 ): CosmeticEdit[] {
   const edits: CosmeticEdit[] = [];
   const re = new RegExp(SAFE_UNESCAPE_RE.source, "g");
+  let scanned = 0;
+  let lineStart = 0;
+  let lastInk = -1; // last non-whitespace index before `scanned`
   let m: RegExpExecArray | null;
   while ((m = re.exec(markdown))) {
     const offset = m.index;
+    for (; scanned < offset; scanned += 1) {
+      const ch = markdown[scanned];
+      if (ch === "\n") lineStart = scanned + 1;
+      else if (!/\s/.test(ch)) lastInk = scanned;
+    }
     if (isInsideCodeRange(ranges, offset)) continue;
     const char = m[1];
-    const lineStart = markdown.lastIndexOf("\n", offset - 1) + 1;
-    const beforeOnLine = markdown.slice(lineStart, offset).trimStart();
-    if (beforeOnLine === "" && BLOCK_START_GUARD.has(char)) continue;
+    if (lastInk < lineStart && BLOCK_START_GUARD.has(char)) continue;
     edits.push({ start: offset, end: offset + 2, replacement: char });
   }
   return edits;
diff --git a/website/de/guide/large-files.md b/website/de/guide/large-files.md
index 79165ee94..621600fd8 100644
--- a/website/de/guide/large-files.md
+++ b/website/de/guide/large-files.md
@@ -25,6 +25,7 @@ Das Parsen ist nicht der Flaschenhals — es ist die View-Konstruktion von Prose
 
 - **Beim Öffnen einer großen Datei in WYSIWYG:** Ein unbestimmter Spinner mit der Beschriftung *„Große Datei wird geöffnet (N MB)…"* erscheint links in der Statusleiste, während der Editor geladen wird. Er verschwindet, sobald der Editor interaktiv ist.
 - **Datei automatisch im Quellmodus geöffnet:** Die Statusleiste zeigt *„Im Quellmodus geöffnet (große Datei)."* mit einem Link **Zu WYSIWYG wechseln**. Ein Klick auf den Link wechselt den aktiven Tab in den WYSIWYG-Modus. Wird die Datei geschlossen und erneut geöffnet, kehrt sie in den Quellmodus zurück — die Übersteuerung gilt pro Sitzung.
+- **Dokument, das WYSIWYG nicht darstellen kann:** Ein Dokument mit Zitaten oder Listen, die mehr als 1000 Ebenen tief verschachtelt sind, lässt sich unabhängig von seiner Größe nicht als Rich Text einlesen. Es öffnet sich im Quellmodus mit einer Meldung, die die Tiefe nennt, und die Statusleiste zeigt *„Im Quelltextmodus geöffnet (in WYSIWYG nicht darstellbar)."* Verringern Sie die Verschachtelung und verwenden Sie dann **Zu WYSIWYG wechseln**.
 
 ## Einstellungen
 
diff --git a/website/es/guide/large-files.md b/website/es/guide/large-files.md
index 26a299782..3f44d2b03 100644
--- a/website/es/guide/large-files.md
+++ b/website/es/guide/large-files.md
@@ -25,6 +25,7 @@ El parseo no es el cuello de botella — lo es la construcción de la vista de P
 
 - **Al abrir un archivo grande en WYSIWYG:** aparece un spinner indeterminado con la etiqueta *"Abriendo archivo grande (N MB)…"* a la izquierda de la barra de estado mientras se monta el editor. Desaparece tan pronto como el editor está interactivo.
 - **Archivo abierto en modo Fuente automáticamente:** la barra de estado muestra *"Abierto en modo Fuente (archivo grande)."* con un enlace **Cambiar a WYSIWYG**. Al pulsar el enlace, la pestaña activa pasa a WYSIWYG. Cerrar y volver a abrir el archivo lo devuelve al modo Fuente — la sustitución es por sesión.
+- **Documento que WYSIWYG no puede mostrar:** un documento con citas o listas anidadas más de 1000 niveles no se puede analizar como texto enriquecido, sea cual sea su tamaño. Se abre en modo Fuente con un mensaje que indica la profundidad, y la barra de estado muestra *"Abierto en modo Fuente (no se puede mostrar en WYSIWYG)."* Reduce el anidamiento y luego usa **Cambiar a WYSIWYG**.
 
 ## Configuración
 
diff --git a/website/fr/guide/large-files.md b/website/fr/guide/large-files.md
index 308693d46..30507d839 100644
--- a/website/fr/guide/large-files.md
+++ b/website/fr/guide/large-files.md
@@ -25,6 +25,7 @@ L'analyse n'est pas le goulot d'étranglement — c'est la construction de la vu
 
 - **Ouverture d'un fichier volumineux en WYSIWYG&nbsp;:** un indicateur indéterminé avec le libellé *«&nbsp;Ouverture du fichier volumineux (N Mo)…&nbsp;»* apparaît à gauche de la barre d'état pendant le montage de l'éditeur. Il disparaît dès que l'éditeur devient interactif.
 - **Fichier ouvert automatiquement en mode Source&nbsp;:** la barre d'état affiche *«&nbsp;Ouvert en mode Source (fichier volumineux).&nbsp;»* avec un lien **Basculer en WYSIWYG**. Cliquer sur le lien fait passer l'onglet actif en WYSIWYG. Fermer puis rouvrir le fichier rétablit le mode Source — le contournement est limité à la session.
+- **Document que le WYSIWYG ne peut pas afficher&nbsp;:** un document dont les citations ou les listes sont imbriquées sur plus de 1000 niveaux ne peut pas être analysé en texte enrichi, quelle que soit sa taille. Il s'ouvre en mode Source avec un message indiquant la profondeur, et la barre d'état affiche *«&nbsp;Ouvert en mode Source (impossible à afficher en WYSIWYG).&nbsp;»* Réduisez l'imbrication, puis utilisez **Basculer en WYSIWYG**.
 
 ## Paramètres
 
diff --git a/website/guide/large-files.md b/website/guide/large-files.md
index 1a28a03d3..e275e7510 100644
--- a/website/guide/large-files.md
+++ b/website/guide/large-files.md
@@ -25,6 +25,7 @@ Parsing is not the bottleneck — it is ProseMirror's view construction. Moving
 
 - **Opening a large file in WYSIWYG:** an indeterminate spinner with the label *"Opening large file (N MB)…"* appears at the left of the status bar while the editor mounts. It disappears as soon as the editor is interactive.
 - **File opened in Source mode automatically:** the status bar shows *"Opened in Source mode (large file)."* with a **Switch to WYSIWYG** link. Clicking the link flips the active tab to WYSIWYG. Closing and reopening the file returns to Source mode — the override is per-session.
+- **Document WYSIWYG cannot display:** a document with blockquotes or lists nested more than 1000 levels deep cannot be parsed as rich text, whatever its size. It opens in Source mode with a message saying how deep it is, and the status bar shows *"Opened in Source mode (cannot be displayed in WYSIWYG)."* Reduce the nesting, then use **Switch to WYSIWYG**.
 
 ## Settings
 
diff --git a/website/it/guide/large-files.md b/website/it/guide/large-files.md
index fb04ec60a..f8d2ef2bd 100644
--- a/website/it/guide/large-files.md
+++ b/website/it/guide/large-files.md
@@ -25,6 +25,7 @@ Il collo di bottiglia non è il parsing — è la costruzione della view di Pros
 
 - **Apertura di un file grande in WYSIWYG:** uno spinner indeterminato con l'etichetta *"Apertura file grande (N MB)…"* compare a sinistra della barra di stato mentre l'editor si monta. Sparisce non appena l'editor è interattivo.
 - **File aperto automaticamente in modalità Sorgente:** la barra di stato mostra *"Aperto in modalità Sorgente (file grande)."* con un collegamento **Passa a WYSIWYG**. Cliccando il collegamento la scheda attiva passa a WYSIWYG. Chiudendo e riaprendo il file si torna in modalità Sorgente — l'override vale solo per la sessione.
+- **Documento che WYSIWYG non può visualizzare:** un documento con citazioni o elenchi annidati per più di 1000 livelli non può essere analizzato come testo formattato, qualunque sia la sua dimensione. Si apre in modalità Sorgente con un messaggio che indica la profondità, e la barra di stato mostra *"Aperto in modalità Sorgente (non visualizzabile in WYSIWYG)."* Riduci l'annidamento, poi usa **Passa a WYSIWYG**.
 
 ## Impostazioni
 
diff --git a/website/ja/guide/large-files.md b/website/ja/guide/large-files.md
index db35b7a54..1a96e4de0 100644
--- a/website/ja/guide/large-files.md
+++ b/website/ja/guide/large-files.md
@@ -25,6 +25,7 @@ VMark はファイルを開く前にサイズで分類します:
 
 - **WYSIWYG で大きなファイルを開いているとき:** エディタがマウントされる間、ステータスバーの左側に *「大きなファイルを開いています（N MB）…」* というラベル付きの不確定なスピナーが表示されます。エディタが操作可能になるとすぐに消えます。
 - **ファイルが自動的にソースモードで開かれたとき:** ステータスバーに *「ソースモードで開きました（大きなファイル）。」* と **WYSIWYG に切り替え** リンクが表示されます。リンクをクリックするとアクティブなタブが WYSIWYG に切り替わります。ファイルを閉じて開き直すとソースモードに戻ります — このオーバーライドはセッション単位です。
+- **WYSIWYG で表示できないドキュメント:** 引用やリストが 1000 階層を超えてネストされたドキュメントは、ファイルサイズに関係なくリッチテキストとして解析できません。ネストの深さを示すメッセージとともにソースモードで開き、ステータスバーに *「ソースモードで開きました（WYSIWYG で表示できません）。」* と表示されます。ネストを減らしてから **WYSIWYG に切り替え** を使ってください。
 
 ## 設定
 
diff --git a/website/ko/guide/large-files.md b/website/ko/guide/large-files.md
index cef6e4bf7..2ff166528 100644
--- a/website/ko/guide/large-files.md
+++ b/website/ko/guide/large-files.md
@@ -25,6 +25,7 @@ VMark는 파일을 열기 전에 크기에 따라 분류합니다:
 
 - **WYSIWYG에서 대용량 파일 열기:** 에디터가 마운트되는 동안 상태 표시줄 왼쪽에 *"대용량 파일을 여는 중 (N MB)…"* 라벨과 함께 무한 스피너가 표시됩니다. 에디터가 상호작용 가능해지면 사라집니다.
 - **자동으로 소스 모드에서 열린 파일:** 상태 표시줄에 *"소스 모드에서 열렸습니다 (대용량 파일)."* 와 **WYSIWYG으로 전환** 링크가 표시됩니다. 링크를 클릭하면 활성 탭이 WYSIWYG으로 전환됩니다. 파일을 닫고 다시 열면 소스 모드로 돌아갑니다 — 재정의는 세션별로 적용됩니다.
+- **WYSIWYG로 표시할 수 없는 문서:** 인용문이나 목록이 1000단계를 넘게 중첩된 문서는 파일 크기와 관계없이 서식 있는 텍스트로 분석할 수 없습니다. 중첩 깊이를 알려 주는 메시지와 함께 소스 모드로 열리며, 상태 표시줄에 *"소스 모드로 열림(WYSIWYG로 표시할 수 없음)."* 이 표시됩니다. 중첩을 줄인 뒤 **WYSIWYG으로 전환** 을 사용하세요.
 
 ## 설정
 
diff --git a/website/pt-BR/guide/large-files.md b/website/pt-BR/guide/large-files.md
index 3f895e490..2202b8a4c 100644
--- a/website/pt-BR/guide/large-files.md
+++ b/website/pt-BR/guide/large-files.md
@@ -25,6 +25,7 @@ O parsing não é o gargalo — é a construção da view do ProseMirror. Mover
 
 - **Abrir um arquivo grande em WYSIWYG:** um spinner indeterminado com o rótulo *"Abrindo arquivo grande (N MB)…"* aparece à esquerda da barra de status enquanto o editor é montado. Ele desaparece assim que o editor fica interativo.
 - **Arquivo aberto automaticamente em modo Fonte:** a barra de status mostra *"Aberto em modo Fonte (arquivo grande)."* com um link **Mudar para WYSIWYG**. Clicar no link alterna a aba ativa para WYSIWYG. Fechar e reabrir o arquivo retorna ao modo Fonte — o override é por sessão.
+- **Documento que o WYSIWYG não consegue exibir:** um documento com citações ou listas aninhadas em mais de 1000 níveis não pode ser analisado como texto formatado, qualquer que seja o tamanho. Ele abre no modo Fonte com uma mensagem informando a profundidade, e a barra de status mostra *"Aberto no modo Fonte (não pode ser exibido no WYSIWYG)."* Reduza o aninhamento e depois use **Mudar para WYSIWYG**.
 
 ## Configurações
 
diff --git a/website/zh-CN/guide/large-files.md b/website/zh-CN/guide/large-files.md
index 171845f51..8fc4f87e5 100644
--- a/website/zh-CN/guide/large-files.md
+++ b/website/zh-CN/guide/large-files.md
@@ -25,6 +25,7 @@ VMark 在打开文件之前会先按文件大小分级：
 
 - **以 WYSIWYG 打开大文件时：** 状态栏左侧会出现一个不确定进度的转圈，标签为 *"正在打开大文件（N MB）…"*，直到编辑器挂载完成、可交互为止才消失。
 - **文件被自动以源码模式打开时：** 状态栏会显示 *"以源码模式打开（大文件）。"*，并附上一个 **切换到 WYSIWYG** 链接。点击该链接会把当前标签页翻到 WYSIWYG。关闭并重新打开该文件后，会回到源码模式 —— 该覆盖只在当前会话内生效。
+- **WYSIWYG 无法显示的文档：** 引用块或列表嵌套超过 1000 层的文档，无论文件大小，都无法解析为富文本。它会以源码模式打开，并弹出提示说明嵌套深度；状态栏显示 *"已以源码模式打开（无法在 WYSIWYG 模式下显示）。"*。减少嵌套层级后，再点击 **切换到 WYSIWYG**。
 
 ## 设置
 
diff --git a/website/zh-TW/guide/large-files.md b/website/zh-TW/guide/large-files.md
index 7506a8cda..88a9d3226 100644
--- a/website/zh-TW/guide/large-files.md
+++ b/website/zh-TW/guide/large-files.md
@@ -25,6 +25,7 @@ VMark 會在開啟前先依大小將檔案分級：
 
 - **以 WYSIWYG 開啟大型檔案時：** 狀態列左側會顯示一個不確定進度的轉圈動畫，搭配文字 *「正在開啟大型檔案(N MB)…」*，直到編輯器準備就緒才消失。
 - **大型檔案被自動以原始碼模式開啟時：** 狀態列會出現 *「已以原始碼模式開啟(大型檔案)。」*，並附上 **切換到 WYSIWYG** 連結。點擊連結會將目前分頁切換到 WYSIWYG。關閉再重新開啟此檔案會回到原始碼模式 —— 這個覆寫只在當下這個工作階段內有效。
+- **WYSIWYG 無法顯示的文件：** 引言或清單巢狀超過 1000 層的文件，無論檔案大小，都無法解析為格式文字。它會以原始碼模式開啟，並跳出提示說明巢狀深度；狀態列會出現 *「已以原始碼模式開啟（無法在 WYSIWYG 模式下顯示）。」*。減少巢狀層級後，再點擊 **切換到 WYSIWYG**。
 
 ## 設定