@helping-ai-workflow/md2doc 3.13.1 → 3.14.0

package/lib/editor/client.js

@@ -236,6 +236,57 @@
     return { lines: r.lines, blocks, op, newStartLine };
   }
 
+  // v3.14.0 T1: where a transient paragraph's lines land when it is
+  // committed. `anchorBlockId` is the real block the transient sits after
+  // (the `data-block-id` of transientAnchorEl() in the browser half), or
+  // null when nothing precedes it. Three cases, each ONE op:
+  //   * anchored — exactly commitBlockInsertion(), blank-line rules included.
+  //   * null with blocks present — the transient opens the document. The
+  //     first block's start line is replaced by [...newLines, '', that line]
+  //     through commitRangeEdit(), and EVERY block is shifted: commitRangeEdit
+  //     shifts only the blocks after its anchor, and here the anchor itself
+  //     (the first block) moves too.
+  //   * no blocks at all — an empty or whitespace-only file. Its whole line
+  //     range is replaced by [...newLines, ''], so the file ends with exactly
+  //     one newline whatever blank lines it held.
+  // Returns { lines, blocks, op, newStartLine }; op is null only for a
+  // refusal (commitBlockInsertion()'s inverted-anchor case).
+  function commitInsertionAt(state, anchorBlockId, newLines) {
+    if (anchorBlockId !== null && anchorBlockId !== undefined) {
+      return commitBlockInsertion(state, anchorBlockId, newLines);
+    }
+    if (!state.blocks.length) {
+      if (!state.lines.length) {
+        const after = newLines.concat(['']);
+        const op = { startLine: 1, endLine: 0, before: [], after };
+        const r = ops.insertLines(state.lines, 0, after);
+        state.stack.push(op);
+        return { lines: r.lines, blocks: state.blocks, op, newStartLine: 1 };
+      }
+      const z = commitRangeEdit(state, 1, state.lines.length, newLines.concat(['']).join('\n'));
+      return { lines: z.lines, blocks: z.blocks, op: z.op, newStartLine: 1 };
+    }
+    const first = state.blocks[0];
+    const at = first.startLine;
+    const r = commitRangeEdit(state, at, at, newLines.concat(['', state.lines[at - 1]]).join('\n'));
+    if (r.op === null) return { lines: r.lines, blocks: r.blocks, op: null, newStartLine: null };
+    const delta = r.lines.length - state.lines.length;
+    const blocks = state.blocks.map((b) =>
+      Object.assign({}, b, { startLine: b.startLine + delta, endLine: b.endLine + delta }));
+    return { lines: r.lines, blocks, op: r.op, newStartLine: at };
+  }
+
+  // v3.14.0 T2: Enter mid-paragraph (or mid-heading). The block's lines are
+  // replaced by the left half, one blank line and the right half — ONE op
+  // through commitRangeEdit(), so one Ctrl+Z puts the paragraph back.
+  // `rightStartLine` is where the right half starts once this lands.
+  function commitSplit(state, blockId, leftText, rightText) {
+    const block = state.blocks.find((b) => b.id === blockId);
+    const r = commitRangeEdit(state, block.startLine, block.endLine, leftText + '\n\n' + rightText);
+    return { lines: r.lines, blocks: r.blocks, op: r.op,
+      rightStartLine: block.startLine + leftText.split('\n').length + 1 };
+  }
+
   // ── S4 Task 3: relocating ONE block's lines (spec §4.5) ────────────────
   //
   // A move is ONE commitRangeEdit over
@@ -742,7 +793,7 @@
   }
 
   if (typeof module === 'object' && module.exports) {
-    module.exports = { pasteIsAllListLines, LIST_LINE_RE, extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, planBlockMove, commitBlockMove, reorderSpanRange, spanMoveRange, spanIndentsAreAnchored, blockMoveSeamRefusal, rollbackFailedRender, headingDepthOf, withHeadingDepth, resolveDrawioLanding, shiftBlocksAfterBodyEdit, waveDiscardIsSafe, waveOfferHolds, waveRedoHolds };
+    module.exports = { pasteIsAllListLines, LIST_LINE_RE, extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, commitInsertionAt, commitSplit, planBlockMove, commitBlockMove, reorderSpanRange, spanMoveRange, spanIndentsAreAnchored, blockMoveSeamRefusal, rollbackFailedRender, headingDepthOf, withHeadingDepth, resolveDrawioLanding, shiftBlocksAfterBodyEdit, waveDiscardIsSafe, waveOfferHolds, waveRedoHolds };
     return; // node: pure core only
   }
 
@@ -1005,8 +1056,32 @@
   // instead of leaving the skeleton on disk. Editing ANYTHING clears it
   // (see each call site below) — from that point on the block is a normal,
   // permanently-committed one like any other.
+  // Since v3.14.0 (T1) the 段落 kind never reaches this: a new paragraph is a
+  // transient that writes nothing in the first place (see createTransient()),
+  // so four skeletons — heading, list, table, code — use it today.
   let pristineInsert = null; // { blockId } | null
 
+  // v3.14.0 T1: the transient empty paragraph (spec §2) — an id-less
+  // `.ed-block[data-ed-transient]` that writes no byte until it has content.
+  // `transient` is the one that is on screen (at most one, D3), or null:
+  // { el, surface, byEnter, anchorCaret, stayEl }. A render rebuilds `.content` and
+  // drops it (applyFullRender() nulls this). `transientLandedLine` is the
+  // start line its last successful commit landed on (R8) — read by callers
+  // that commit a transient and then act on the block it became.
+  let transient = null;
+  let transientLandedLine = null;
+  // Fix round 1 (I2): the line shifts landed transient commits made, so a
+  // gesture that captured a block's identity before one can still find it
+  // (identityStartLineNow()).
+  const transientCommits = { seq: 0, log: [] };
+  // v3.14.0 T2 (D7): a structural edit whose render failed and that the
+  // screen still shows — see retryPendingStructure(). null, or
+  // { range, before, surfaces, serialize }.
+  let pendingStructure = null;
+  // D13 / R1: the hint on an empty paragraph. "/" does not exist yet, so the
+  // hint does not name it; v3.15.0 changes this one constant.
+  const PLACEHOLDER_TEXT = '輸入文字';
+
   // Task 5 fix (found via a standalone repro harness — see the task-5
   // report): a table mutation that DETACHES the focused cell — whether by
   // reassigning tableEl.innerHTML wholesale or by re-parenting the cell/row
@@ -1128,6 +1203,9 @@
   // open with its edit intact, banner already shown, caller must abandon
   // whatever it was about to do).
   async function resolveOpenSession() {
+    // v3.14.0 T2 (D7): a structure whose render failed goes first — anything
+    // committed before it would render, and a render drops its screen half.
+    if (pendingStructure && !(await retryPendingStructure())) return false;
     if (currentBurst) {
       const ok = await resolveBurst();
       if (!ok) return false;
@@ -1192,7 +1270,11 @@
     // The distance was a second record of "are we standing where we saved";
     // `UndoStack` now answers that question itself, and a boolean has no zero
     // to walk through. See lineops.js's own comment for the full story.
-    return stack.isDirty() || burstHasUncommittedEdit() || waveUnwrittenEdit;
+    // v3.14.0 T6 (R34): a structure whose render failed is on screen and not
+    // in `lines` (pendingStructure) — unsaved work like an open burst's text.
+    // Measured before: a failed split, then the file changed on disk, and
+    // onDiskMtime() reloaded the page silently, the split gone.
+    return stack.isDirty() || burstHasUncommittedEdit() || waveUnwrittenEdit || pendingStructure !== null;
   }
 
   function setDirty() {
@@ -1876,6 +1958,9 @@
     // 要為一次沒上畫面的編輯升起警告」這件事寫在這裡，而不是留給讀者去讀
     // 它們的本體。
     if (!ok) return false;
+    // v3.14.0 T4: a render that leaves no block at all (the last one deleted)
+    // is an empty document again, with a transient to type into.
+    ensureEmptyDocTransient();
     lastRenderLines = lines.slice();
     lastRenderEndedUnclosed = nowUnclosed;
     // 升 banner 排在套用之後：套用是把新的 DOM 放上畫面那一步，警告的是使用
@@ -2528,6 +2613,9 @@
     // insertBlockBelow() rerenderAll() awaits, so it can never clobber a
     // fresh assignment.
     pristineInsert = null;
+    // v3.14.0 T1: the transient lived in the `.content` children the
+    // innerHTML write above just replaced — every render drops it (D3).
+    transient = null;
     // Task 2 (Phase 3): same belt-and-braces reasoning for the always-on
     // WYSIWYG burst — whatever block had one open a moment ago was just
     // detached by the innerHTML replacement above, so its own focusout
@@ -2737,9 +2825,15 @@
   //  * A "positioned" entry is the first one held after a pointer press into
   //    a surface during the flight: it carries a tag (surface, block id,
   //    table cell index) and the full selection (anchor and focus offsets),
-  //    restored before it replays. Offsets are shifted past the held text
-  //    that will be inserted before them in the same surface by the time it
-  //    replays (heldShiftBefore()). The tag is re-pointed when a render
+  //    restored before it replays. Its offsets are the ones the user saw,
+  //    in the surface's text at hold time, and the tag records how many
+  //    replayed edits that surface had logged by then (`logAt`). Just before
+  //    it replays, the offsets are mapped through the edits logged in that
+  //    surface AFTER that point — the ones the user's text did not hold yet
+  //    — as measured (flightEditLog, mapOffsetThroughLog(); v3.14.0 T7, D10,
+  //    fix round 1). When a render replaces the surface, the offsets are
+  //    mapped through the old surface's later edits right there and the tag
+  //    starts over against the new one's log. The tag is re-pointed when a render
   //    replaces its surface: by the committed run's own line map for an item
   //    of a list run the commit rewrote (an item the split pushed down a
   //    line, the provisional item), otherwise by its block's start line,
@@ -2851,6 +2945,7 @@
       cellIndex: isCell && blockEl
         ? Array.prototype.indexOf.call(blockEl.querySelectorAll('.ed-wys-cell'), snap.surface) : null,
       anchor: snap.anchor, focus: snap.focus,
+      logAt: flightLogLength(snap.surface),
     };
   }
 
@@ -2870,24 +2965,44 @@
     return map;
   }
 
-  // How far held text will have pushed `offset` in `surface` by the time an
-  // entry positioned there replays: the text of every run pinned (or, for
-  // the opening run, typed) in the same surface at or before that offset.
-  function heldShiftBefore(surface, offset) {
-    let pin = null;
-    let shift = 0;
-    flightBuffer.forEach((en, i) => {
-      if (en.pos || i === 0) pin = en.pos || en.hint;
-      if (en.kind !== 'text' || !pin || pin.surface !== surface || pin.anchor === null) return;
-      if (Math.min(pin.anchor, pin.focus === null ? pin.anchor : pin.focus) <= offset) shift += en.data.length;
-    });
-    return shift;
+  // v3.14.0 T7 (D10): what each replayed entry did to its surface, measured
+  // rather than predicted: surface -> [{ at, delta }] in replay order, cleared
+  // when the buffer empties. A positioned entry's offsets were taken in the
+  // DOM the user clicked, which none of the held edits had reached yet; each
+  // logged edit moves an offset at or past its `at` by its `delta`, never
+  // back over `at`. Predicting the shift at hold time counted only
+  // held TEXT: measured before, a Backspace,
+  // a paste or a replaced word ahead of a second click in the same paragraph
+  // put that click's keys one character, two, or eight away from it, and two
+  // clicks at one spot replayed their keys in reverse order.
+  const flightEditLog = new Map();
+  function surfaceTextLength(surface) {
+    const r = document.createRange();
+    r.selectNodeContents(surface);
+    return r.toString().length;
+  }
+  function flightLogLength(surface) {
+    const log = surface ? flightEditLog.get(surface) : null;
+    return log ? log.length : 0;
+  }
+  // `tag`'s offset `o` through the edits its surface logged after the tag
+  // was taken (fix round 1, I1: mapping the whole log shifted a tag taken in
+  // a surface that already held an earlier replayed edit a second time).
+  function mapOffsetThroughLog(tag, o) {
+    if (o === null || o === undefined || !tag || !tag.surface) return o;
+    const log = flightEditLog.get(tag.surface) || [];
+    for (let i = tag.logAt || 0; i < log.length; i++) {
+      const m = log[i];
+      o = o < m.at ? o : Math.max(m.at, o + m.delta);
+    }
+    return o;
   }
-  function shiftedTag(tag) {
-    if (!tag || tag.anchor === null) return tag;
-    tag.anchor += heldShiftBefore(tag.surface, tag.anchor);
-    if (tag.focus !== null) tag.focus += heldShiftBefore(tag.surface, tag.focus);
-    return tag;
+  // Ctrl/Cmd+B / I / U (no Alt, no Shift): the native formatting command.
+  function formatCommandForKey(e) {
+    const mod = FLIGHT_IS_MAC ? (e.metaKey && !e.ctrlKey) : (e.ctrlKey && !e.metaKey);
+    if (!mod || e.altKey || e.shiftKey || typeof e.key !== 'string') return null;
+    const k = e.key.toLowerCase();
+    return k === 'b' ? 'bold' : k === 'i' ? 'italic' : k === 'u' ? 'underline' : null;
   }
 
   // Pins the run of continuation entries that opened this flight (if it is
@@ -2905,7 +3020,7 @@
     entry.hint = flightTagOf(selectionSnapshotIn(surface));
     if (flightSelMoved) {
       flightSelMoved = false;
-      entry.pos = shiftedTag(flightTagOf(selectionSnapshotIn(surface)));
+      entry.pos = flightTagOf(selectionSnapshotIn(surface));
     }
     const last = flightBuffer[flightBuffer.length - 1];
     if (entry.kind === 'text' && !entry.pos && last && last.kind === 'text') {
@@ -2919,7 +3034,7 @@
   function reanchorFlightBuffer(before, editRange, lineMap) {
     if (flightSelMoved && lastRenderSel) {
       flightSelMoved = false;
-      flightBuffer.push({ kind: 'focus', pos: shiftedTag(flightTagOf(lastRenderSel)) });
+      flightBuffer.push({ kind: 'focus', pos: flightTagOf(lastRenderSel) });
     }
     flightFallback = lastRenderSel && !lastRenderSel.surface.isConnected
       ? flightTagOf(lastRenderSel) : null;
@@ -2942,7 +3057,23 @@
           if (editRange && line > editRange.endLine) line += editRange.delta;
         }
       }
+      // Fix round 1 (I1): on a commit render, the render replaced the surface
+      // with one built from the source that commit wrote, which holds every
+      // edit the replay made in the old one before the commit. So the offsets
+      // are mapped through the old surface's later edits now, and the tag
+      // starts over against the new surface's log. This holds for a commit
+      // render only (final review M2): a rollback render (the
+      // PENDING_STRUCTURE_LOST branch) or a global undo() render builds the
+      // surface from a source without those edits, and a held click's offset
+      // can then be off by their length. Accepted for v3.14.0: neither is
+      // reached by a known gesture short of four inside one render. Measured before: click B@5, X, click Omega, Y, click
+      // B@10, Z — Z landed one character short, `BravoX parZagraph`.
+      if (pos.surface) {
+        pos.anchor = mapOffsetThroughLog(pos, pos.anchor);
+        pos.focus = mapOffsetThroughLog(pos, pos.focus);
+      }
       pos.surface = null;
+      pos.logAt = 0;
       if (line === null) return;
       const nb = blocks.find((b) => b.startLine === line);
       const nEl = nb ? document.querySelector('.ed-block[data-block-id="' + nb.id + '"]') : null;
@@ -2952,11 +3083,19 @@
         : blockContentEl(nEl);
       if (surf && !surf.matches('.ed-wys-armed, .ed-wys-cell')) surf = null;
       pos.surface = surf;
+      pos.logAt = flightLogLength(surf);
       pos.blockId = String(nb.id);
     };
     flightBuffer.forEach((en) => { remap(en.pos); remap(en.hint); });
     remap(flightFallback);
+    focusinWaitTags.forEach(remap);
   }
+  // v3.14.0 T1 fix round 1 (I1): the surfaces a focusin is waiting to open a
+  // burst on while a resolution renders (see the focusin handler). Each is a
+  // flight tag, re-pointed by every landed render exactly like a held entry's,
+  // because the block's id is not a stable way back once a render changed the
+  // block count above it.
+  const focusinWaitTags = [];
 
   // A deletion chord's input type, and a caret chord's movement, per
   // platform (Ctrl on Linux/Windows, Alt and Cmd on a Mac).
@@ -2987,7 +3126,7 @@
     return null;
   }
   function isHeldTyping(en) {
-    return en.kind === 'text' || en.kind === 'paste' || en.kind === 'delete' ||
+    return en.kind === 'text' || en.kind === 'paste' || en.kind === 'delete' || en.kind === 'format' ||
       (en.kind === 'key' && !caretMoveForKey(en));
   }
   function dropHeldTyping() {
@@ -3047,6 +3186,11 @@
       routePaste(target, item.dt);
     } else if (item.kind === 'delete') {
       nativeFlightDeletion(item.inputType, target);
+    } else if (item.kind === 'format') {
+      // v3.14.0 T7 (D9): the command the live chord runs natively.
+      snapBurstIfActive(target, 'replay-pre');
+      document.execCommand(item.command);
+      snapBurstIfActive(target, 'replay');
     } else if (item.kind === 'key') {
       const ev = new KeyboardEvent('keydown', { key: item.key, shiftKey: item.shiftKey,
         ctrlKey: item.ctrlKey, altKey: item.altKey, metaKey: item.metaKey, bubbles: true, cancelable: true });
@@ -3076,14 +3220,16 @@
           target.focus();
           if (commitFlight || switching) break;
         }
-        restoreSelection(target, item.pos.anchor, item.pos.focus);
+        restoreSelection(target, mapOffsetThroughLog(item.pos, item.pos.anchor),
+          mapOffsetThroughLog(item.pos, item.pos.focus));
       } else {
         target = activeFlightSurface();
         const fb = flightFallback;
         if (!target && fb && fb.surface && fb.surface.isConnected) {
           fb.surface.focus();
           if (commitFlight || switching) break;
-          restoreSelection(fb.surface, fb.anchor, fb.focus);
+          restoreSelection(fb.surface, mapOffsetThroughLog(fb, fb.anchor),
+            mapOffsetThroughLog(fb, fb.focus));
           flightFallback = null;
           target = activeFlightSurface();
         }
@@ -3091,10 +3237,26 @@
       }
       flightBuffer.shift();
       if (item.kind !== 'focus') {
+        const pre = selectionSnapshotIn(target);
+        const len0 = surfaceTextLength(target);
         flightReplaying = true;
         try { replayFlightEntry(item, target); } finally { flightReplaying = false; }
+        // T7: measured only where it can be — the surface still on screen
+        // and still focused (an Enter that moved the caret on, a commit that
+        // replaced the surface, is no edit IN it to map through).
+        if (pre && pre.anchor !== null && target.isConnected && activeFlightSurface() === target) {
+          const post = selectionSnapshotIn(target);
+          if (post && post.focus !== null) {
+            const delta = surfaceTextLength(target) - len0;
+            const s0 = Math.min(pre.anchor, pre.focus === null ? pre.anchor : pre.focus);
+            const at = Math.min(s0, post.focus - Math.max(delta, 0));
+            if (!flightEditLog.has(target)) flightEditLog.set(target, []);
+            flightEditLog.get(target).push({ at, delta });
+          }
+        }
       }
     }
+    if (!flightBuffer.length) flightEditLog.clear();
     if (!flightBuffer.length && !commitFlight) flightFallback = null;
     if (dropped) showNotice(FLIGHT_DROPPED_MESSAGE);
   }
@@ -3366,6 +3528,9 @@
     // v3.2.0 (final review item 1): `let`, not `const` — reanchor() below
     // re-derives all three of `blockId`/`startLine`/`endLine` when this
     // session survives an incremental patch. See its own comment.
+    // R2 (F1): an id-less block (a transient) has no source to edit, and
+    // `Number(null)` would open block 0's.
+    if (blockEl.getAttribute('data-block-id') === null) return;
     let blockId = Number(blockEl.getAttribute('data-block-id'));
     const block = blocks.find((b) => b.id === blockId);
     if (!block) return;
@@ -4572,9 +4737,40 @@
     // `Alpha <em><br></em> bold text here.` — dropping before the insert would
     // have taken that <em> and the caret's new home with it.
     dropEmptied(leftovers);
+    // v3.14.0 T8: a <br> with nothing visible after it in the surface draws
+    // no new line — the caret after it stays on the line above, and the next
+    // character was typed BEFORE the break (measured: Shift+Enter at the end
+    // of `Alpha.`, then `Z`, saved `Alpha.Z<br>`). A second, tail <br>
+    // gives the new line something to stand on; the caret goes between the
+    // two. inline-md.js writes nothing for a tail, so leaving straight away
+    // writes the same `Alpha.<br>` as before.
+    const surface = editSurfaceOf(br);
+    if (surface) {
+      const tail = tailBrAfter(br, surface);
+      if (tail === false) {
+        const t = document.createElement('br');
+        t.setAttribute('data-ed-tail', '1');
+        br.parentNode.insertBefore(t, br.nextSibling);
+      }
+      range.setStartAfter(br);
+      range.setEndAfter(br);
+    }
     sel.removeAllRanges();
     sel.addRange(range);
   }
+  // What follows `br` inside `surface`: a tail <br> that is already there
+  // (returned), something visible — text, an image, another <br> (true) — or
+  // nothing (false).
+  function tailBrAfter(br, surface) {
+    const w = document.createTreeWalker(surface, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT);
+    w.currentNode = br;
+    for (let n = w.nextNode(); n; n = w.nextNode()) {
+      if (n.nodeType === 3) { if (n.data.length) return true; continue; }
+      if (n.nodeName === 'BR') return n.getAttribute('data-ed-tail') === '1' ? n : true;
+      if (n.nodeName === 'IMG') return true;
+    }
+    return false;
+  }
 
   // Heading ± buttons on the bar: a pure source-level transform (just the
   // leading `#` run) via the SAME commitEdit()/replaceLines() pipeline as
@@ -4629,6 +4825,7 @@
 
   async function changeHeadingDepthBody(blockEl, delta, anchor) {
     if (!blockEl) return;
+    if (blockEl.getAttribute('data-block-id') === null) return; // R2: id-less → not block 0
     const blockId = Number(blockEl.getAttribute('data-block-id'));
     // Commits (never discards) whatever burst/editor is open first — same
     // precondition undo()/redo() use below, so this never races a concurrent
@@ -4752,6 +4949,9 @@
         if (blockType === 'heading') stripHeadingAnchor(editEl);
         editEl.setAttribute('contenteditable', 'true');
         editEl.classList.add('ed-wys-armed');
+        // v3.14.0 T4: the hint a focused EMPTY paragraph shows (the CSS rule
+        // reads this attribute; syncEmptyMark() decides when it shows).
+        if (blockType === 'paragraph') editEl.setAttribute('data-placeholder', PLACEHOLDER_TEXT);
       } else if (blockType === 'li') {
         // Task 6 (Phase 4): per-li arming. Each
         // `.ed-block[data-block-type="li"]` is armed independently: only its
@@ -5378,19 +5578,11 @@
   // this uses the bare marker `-` instead — verified to lex as `list` with
   // one empty `<li>`.
   //
-  // The 段落 skeleton similarly can't be a truly empty line: a blank line by
-  // itself is consumed by marked's lexer as a `space` token between
-  // neighboring blocks, never becomes its own `paragraph` token, and would
-  // leave the ＋ menu unable to find (or focus) any block at all — see
-  // commitBlockInsertion()'s newStartLine contract, which callers use to
-  // locate the inserted block in the server's recomputed block list.
-  // U+200B (zero-width space) is real, non-whitespace-per-`\s` text that
-  // marked DOES lex as its own paragraph, and renders as `<p>​</p>` —
-  // visually empty. focusInsertedBlock() below selects that single
-  // character so an immediate keystroke replaces it, matching the "empty
-  // paragraph to type into" intent; if the user commits without typing at
-  // all, the ZWSP is what ends up on disk (a known, documented trade-off —
-  // see the phase report).
+  // There is no 段落 skeleton (v3.14.0 T1, D6): a blank line cannot be a
+  // paragraph in markdown, and the zero-width-space line that stood in for
+  // one up to v3.13 put an invisible character on disk whenever the user
+  // walked away without typing. A new paragraph is now a transient (see
+  // createTransient()), which writes nothing until it has content.
   //
   // 程式碼: a bare two-line fence pair (```/```, nothing between) is what
   // "fence pair with empty body" reads as most literally, and DOES lex as
@@ -5404,7 +5596,6 @@
   // browser probe). A three-line fence with one blank line between them
   // (still `text: ''` per marked — verified) gives that line to land on.
   const BLOCK_SKELETONS = {
-    paragraph: ['​'],
     heading: ['## '],
     list: ['-'],
     table: ['| A | B |', '|---|---|', '|  |  |'],
@@ -5422,8 +5613,8 @@
   // freshly-inserted, placeholder-only block) so the user's very first
   // keystroke replaces the placeholder instead of being inserted next to
   // it. A no-op-equivalent (nothing to select) on the genuinely-empty
-  // heading/list/table skeletons; load-bearing only for the paragraph
-  // skeleton's ZWSP placeholder (see BLOCK_SKELETONS above).
+  // heading/list/table skeletons, which are all that reach it since the
+  // paragraph skeleton went away (v3.14.0 T1).
   function focusAndSelectAll(el) {
     el.focus();
     const range = document.createRange();
@@ -5548,6 +5739,16 @@
   // parameter and not a second insertion path.
   async function insertBlockBelow(blockEl, kind, opts) {
     if (!blockEl) return;
+    // v3.14.0 T1 (D6): a 段落 is no longer a ZWSP skeleton written to the
+    // file — it is a transient that writes nothing until it has content.
+    if (kind === 'paragraph' && !(opts && Array.isArray(opts.lines))) {
+      await insertTransientBelow(blockEl);
+      return;
+    }
+    // R2 (F1): an id-less anchor (a transient, a provisional li) has no line
+    // to insert below, and `Number(null)` would read it as block 0. The
+    // toolbar's and paste's transient routes are their own (Task 4 / Task 5).
+    if (blockEl.getAttribute('data-block-id') === null) return;
     // T7: captured BEFORE switchAwayFrom(), because that is what can renumber
     // the ids — see captureBlockIdentity()'s comment.
     const identity = captureBlockIdentity(blockEl);
@@ -5599,7 +5800,8 @@
     //    建立副本 (「副本插在該 block 整棵子樹之後」), and it is what makes every
     //    non-list kind safe here. Measured on ['# Doc','','- alpha',
     //    '  - child','    - grand','']: anchored on `child`,
-    //    commitBlockInsertion() with the 段落 skeleton yields
+    //    commitBlockInsertion() with the 段落 skeleton of the time (a ZWSP
+    //    line; since v3.14.0 a transient commits through the same anchor) yields
     //    '# Doc\n\n- alpha\n  - child\n\n<ZWSP>\n\n    - grand\n', and
     //    marked lexes '    - grand' after a paragraph as an INDENTED CODE
     //    BLOCK — the grandchild's content is gone. Anchored on the end of the
@@ -5685,7 +5887,7 @@
     // pasted paragraph it would silently delete real content the moment the
     // user clicked elsewhere without typing. focusAndSelectAll() is wrong for
     // the same reason: it selects the block's whole content so the first
-    // keystroke replaces it, which is what a ZWSP placeholder wants and what
+    // keystroke replaces it, which is what a placeholder skeleton wants and what
     // a just-pasted paragraph very much does not.
     //
     // 'line' is excluded for the same reason from the other direction: both
@@ -5739,6 +5941,1396 @@
   }
 
 
+  // ── v3.14.0 T1: the transient empty paragraph ─────────────────────────
+  //
+  // Markup (D1): <div class="ed-block" data-block-type="paragraph"
+  // data-ed-transient="1"><p class="ed-wys-armed" contenteditable="true"
+  // data-placeholder="…"></p></div> — no data-block-id, no gutter chrome. It
+  // is placed by DOM position: its commit lands after the previous real
+  // block (the end of that block's subtree for a li), or at the top of the
+  // document when nothing precedes it (D2, transientAnchorEl()). It writes no
+  // byte until it has content (spec §2); its commit is one op.
+  //
+  // WALKER AUDIT (R2 / F1). Every `.ed-block` walker and every
+  // `data-block-id` read in this file, against an id-less transient. "skip" =
+  // returns null / does nothing for it; "include" = treats it as the
+  // paragraph it is; "n/a" = cannot meet one (no transient survives a render,
+  // and a patch render never runs while one exists: domMatchesLastRender()
+  // is false for an id-less child).
+  //   applyPatch focusedBlockEl / idDelta rewrite / burstSurvived ... n/a (patch)
+  //   flightTagOf / reanchorFlightBuffer remap ............ include: blockId
+  //       null resolves through pendingFlightLineMap.provisional, which
+  //       commitLinesAtTransient() sets to the landing line
+  //   openRawEditor (+ reanchor) ............................ skip (id guard)
+  //   blockOwnsNoLine / blockRangeIsUnlocatable ............. skip (null-safe)
+  //   allBlockEls / liAttrs / subtreeBlocksAfter / runs ..... include as a
+  //       non-li: it ends a list run, as the paragraph it will become does
+  //   closestLiBlock ........................................ n/a (not a li)
+  //   runRangeOfBlocks / bystanderCarryOver / list commits .. skip (null-safe)
+  //   changeHeadingDepthBody ................................ skip (id guard)
+  //   armEditables .......................................... n/a (fresh DOM)
+  //   focusInsertedBlock / blockElAtLine / focusBlockAtLine . n/a (by line)
+  //   insertBlockBelow ...................................... skip (id guard;
+  //       its 段落 kind is routed here first)
+  //   startBurst ............................................ include (own
+  //       branch); any other id-less block: skip (R2)
+  //   setBlockSelection / selection walkers / blockRecOf .... skip (null)
+  //   captureBlockIdentity / reresolveBlockEl ............... skip (null)
+  //   commitListStructure targets ........................... n/a (li only)
+  //   handleBurstKeydown arrow probe / walkToAdjacentBlockByArrow /
+  //       adjacentFocusableBlock ............................ include: the
+  //       arrow walk lands in it like any armed paragraph (T5 owns leaving)
+  //   Tab walk (walkToAdjacentBlockByTab) .................. include
+  //   blockContentEl ........................................ include (the <p>)
+  //   table burst / cell walkers / grips / edge menu ........ n/a (tables)
+  //   ⠿ handle / ＋ / drag / duplicate / copy ................ skip: it grows
+  //       no .ed-handle or .ed-insert, so no gutter gesture can start on it
+  //   gutter hover chrome / delegated block click ........... skip (no chrome;
+  //       a click inside it is a caret placement in an armed surface)
+  //   toolbar tracking (focusin / click) .................... include: the bar
+  //       reports a paragraph (D15 refinements are Task 4)
+  //   paste insertBlockBelow / insertImages anchors ......... skip (id guard
+  //       in insertBlockBelow; Task 4 / Task 5 route them)
+  //   focusin re-resolve by block id ........................ skip (null id)
+  //   raw textarea focusout ................................. n/a (no raw box)
+  //   wave editor open ...................................... n/a (no diagram)
+  function isTransient(node) {
+    const el = node && (node.nodeType === 1 ? node : node.parentElement);
+    return !!(el && el.closest && el.closest('[data-ed-transient]'));
+  }
+
+  function transientSurfaceEmpty(el) {
+    const surface = el ? blockContentEl(el) : null;
+    return !surface || (surface.textContent === '' && !surface.querySelector('img'));
+  }
+
+  // D3: in an empty document the transient is the only block and is never
+  // removed.
+  function transientIsOnlyBlock(el) {
+    return contentEl.querySelectorAll('.ed-block').length === 1 && el.parentNode === contentEl;
+  }
+
+  // The `.ed-block` sibling right before `el`, transient or not, or null.
+  function previousBlockEl(el) {
+    let p = el.previousElementSibling;
+    while (p && !p.classList.contains('ed-block')) p = p.previousElementSibling;
+    return p;
+  }
+
+  // The last block of `blockEl`'s subtree (itself for anything but a li with
+  // deeper items after it). A transient on the way is stepped over, so a
+  // transient sitting inside a subtree does not cut it short.
+  function subtreeEndOf(blockEl) {
+    const a = liAttrs(blockEl);
+    if (!a) return blockEl;
+    let end = blockEl;
+    for (let n = blockEl.nextElementSibling; n; n = n.nextElementSibling) {
+      if (!n.classList.contains('ed-block')) continue;
+      if (n.hasAttribute('data-ed-transient')) continue;
+      const na = liAttrs(n);
+      if (!na || na.indent <= a.indent) break;
+      end = n;
+    }
+    return end;
+  }
+
+  // D2: the real block the transient's lines are committed after — the
+  // previous `.ed-block[data-block-id]` sibling, or the end of its subtree
+  // when it is a li — or null when nothing real precedes it.
+  function transientAnchorEl(el) {
+    let p = el.previousElementSibling;
+    while (p && !(p.classList.contains('ed-block') && p.getAttribute('data-block-id') !== null)) {
+      p = p.previousElementSibling;
+    }
+    return p ? subtreeEndOf(p) : null;
+  }
+
+  function focusTransientStart(el) {
+    const surface = blockContentEl(el);
+    if (!surface) return;
+    surface.focus();
+    const range = document.createRange();
+    range.selectNodeContents(surface);
+    range.collapse(true);
+    const sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+
+  // Builds the transient after `after` (an `.ed-block` child of `.content`),
+  // or as the first child of `.content` when `after` is null. An existing
+  // EMPTY transient is removed first (at most one, D3); when `after` IS that
+  // empty transient, it is returned as it is (R20). `opts.focus` puts the
+  // caret in it at offset 0, and the focusin that raises opens its burst.
+  // Returns the element, or null when `after` is no longer in the document.
+  function createTransient(after, opts) {
+    const o = opts || {};
+    if (after && transient && transient.el === after && after.isConnected && transientSurfaceEmpty(after)) {
+      if (o.focus) focusTransientStart(after);
+      return after;
+    }
+    if (after && !after.isConnected) return null;
+    if (transient && transient.el.isConnected && transientSurfaceEmpty(transient.el)) removeTransient();
+    const el = document.createElement('div');
+    el.className = 'ed-block';
+    el.setAttribute('data-block-type', 'paragraph');
+    el.setAttribute('data-ed-transient', '1');
+    const surface = document.createElement('p');
+    surface.className = 'ed-wys-armed';
+    surface.setAttribute('contenteditable', 'true');
+    surface.setAttribute('data-placeholder', PLACEHOLDER_TEXT);
+    el.appendChild(surface);
+    if (after) after.parentNode.insertBefore(el, after.nextSibling);
+    else contentEl.insertBefore(el, contentEl.firstChild);
+    transient = { el, surface, byEnter: !!o.byEnter, anchorCaret: o.anchorCaret || null,
+      stayEl: o.stayEl || null };
+    syncEmptyMark(surface);
+    if (o.focus) focusTransientStart(el);
+    return el;
+  }
+
+  // v3.14.0 T4: data-ed-empty on a paragraph surface that holds no text and no
+  // image, off otherwise. The CSS hint keys off it. Called on focusin and
+  // input of an armed paragraph surface, by createTransient(), and after the
+  // places that rewrite a surface's innerHTML (burst undo / redo, Escape).
+  function syncEmptyMark(surface) {
+    if (!surface || surface.nodeType !== 1) return;
+    if (surface.textContent === '' && !surface.querySelector('img')) surface.setAttribute('data-ed-empty', '1');
+    else surface.removeAttribute('data-ed-empty');
+  }
+  function wireEmptyMark() {
+    const handler = (e) => {
+      const t = e.target;
+      const surface = t && t.closest
+        ? t.closest('.ed-block[data-block-type="paragraph"] > .ed-wys-armed') : null;
+      if (surface) syncEmptyMark(surface);
+    };
+    document.addEventListener('focusin', handler, true);
+    document.addEventListener('input', handler, true);
+  }
+
+  // A press that blurs an empty transient must not move the page under
+  // itself. Its mousedown is what resolves the transient's burst (focusout),
+  // and removing the element right there pulls every block below it up by
+  // its height before the mouseup — the click then lands on whatever is
+  // under the pointer now, usually the gap or `main.content`, and the block
+  // click delegator reads that as "clicked outside any block" and resolves
+  // the burst the press had just opened on the block it really hit. MEASURED
+  // (ER "empty-Enter on the ONLY item…", both engines in the click check
+  // 'a press on the paragraph below an empty transient…'): the follow-up
+  // typing was never committed. So while a button is down the removal waits
+  // for the press to end (mouseup, then the click it dispatches), and only
+  // removes the transient if nothing has claimed it meanwhile.
+  let pointerPressed = false;
+  const afterPressQueue = [];
+  document.addEventListener('mousedown', () => { pointerPressed = true; }, true);
+  const endPress = () => {
+    pointerPressed = false;
+    if (!afterPressQueue.length) return;
+    const due = afterPressQueue.splice(0);
+    setTimeout(() => due.forEach((fn) => fn()), 0);
+  };
+  document.addEventListener('mouseup', endPress, true);
+  // v3.14.0 T4: a press can end without a mouseup (a native drag takes the
+  // pointer, the window loses it), which used to leave the flag set until the
+  // next click; those endings clear it too.
+  document.addEventListener('pointercancel', endPress, true);
+  document.addEventListener('dragend', endPress, true);
+  window.addEventListener('blur', endPress);
+  function removeTransientAfterPress(el) {
+    const drop = () => {
+      if (!transient || transient.el !== el || !el.isConnected) return;
+      if (el.contains(document.activeElement) || !transientSurfaceEmpty(el)) return;
+      if (transientIsOnlyBlock(el)) return;
+      removeTransient();
+    };
+    if (pointerPressed) afterPressQueue.push(drop);
+    else drop();
+  }
+
+  // DOM only — no op, nothing written. Its burst (if open) ends first, so the
+  // focusout the removal raises finds nothing to resolve.
+  function removeTransient() {
+    const t = transient;
+    transient = null;
+    if (!t) return;
+    if (currentBurst && currentBurst.blockEl === t.el) endBurstWithoutResolve();
+    if (t.el.parentNode) t.el.parentNode.removeChild(t.el);
+  }
+
+  // Commits `newLines` at the transient's position: one op
+  // (commitInsertionAt()), then a render. Keys held during that render that
+  // were typed into the transient follow it to the line it lands on
+  // (`provisional`). On success `transientLandedLine` names that line; on
+  // failure `lines` is rolled back and the transient — with whatever the
+  // user typed — stays on screen for the next attempt.
+  async function commitLinesAtTransient(el, newLines) {
+    const anchorEl = transientAnchorEl(el);
+    if (anchorEl && blockOwnsNoLine(anchorEl)) {
+      refuseStructuralListEdit(noSourceLineInsertMessageFor(anchorEl));
+      return { ok: false, newStartLine: null };
+    }
+    const anchorId = anchorEl ? Number(anchorEl.getAttribute('data-block-id')) : null;
+    const result = commitInsertionAt({ lines, blocks, stack }, anchorId, newLines);
+    if (result.op === null) return { ok: false, newStartLine: null };
+    const prevLines = lines;
+    lines = result.lines;
+    const editRange = { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
+      endLine: Math.max(result.op.startLine - 1, result.op.endLine),
+      delta: result.op.after.length - result.op.before.length };
+    // Fix round 1 (I1): the commit is a pure insertion, so every block that
+    // starts at or after the op's first line moves down by its delta —
+    // including, at the top of the document, the first block whose line the
+    // op re-states. Named here by id, because editRange alone cannot say it
+    // for that first block (its line is INSIDE the edited range).
+    const shifted = {};
+    blocks.forEach((b) => {
+      if (b.startLine >= result.op.startLine) shifted[b.id] = b.startLine + editRange.delta;
+    });
+    pendingFlightLineMap = { ids: shifted, provisional: result.newStartLine };
+    const ok = await safeRerenderAll(editRange);
+    if (!ok) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+      return { ok: false, newStartLine: null };
+    }
+    transientLandedLine = result.newStartLine;
+    transientCommits.seq++;
+    transientCommits.log.push({ seq: transientCommits.seq, at: result.op.startLine, delta: editRange.delta });
+    if (transientCommits.log.length > 8) transientCommits.log.shift();
+    return { ok: true, newStartLine: result.newStartLine };
+  }
+
+  // resolveBurst()'s transient branch. Empty: kept (burst restarted) while
+  // focus is still inside it — Ctrl+S or a toolbar press right after making
+  // it must not eat it — or while it is the document's only block; removed
+  // otherwise (D3). With text: committed, and the caret follows it to the
+  // committed paragraph's end when the resolution began with focus inside.
+  async function resolveTransientBurst(burst) {
+    const el = burst.blockEl;
+    const surface = burst.editEl;
+    const focusInside = el.contains(document.activeElement);
+    burst.history.flushTyping();
+    // An emptied surface a browser left a <br> in serializes as '<br>': it
+    // holds no text and no image, so it is empty (T4: Ctrl+S after typing and
+    // erasing everything wrote that line).
+    const md = transientSurfaceEmpty(el) ? ''
+      : inlineMd.escapeBlockStarts(inlineMd.serializeInline(surface).md).replace(/\s+$/, '');
+    if (md === '') {
+      endBurstWithoutResolve();
+      if (!el.isConnected) {
+        if (transient && transient.el === el) transient = null;
+        return true;
+      }
+      if (focusInside) {
+        // A <br> a browser leaves behind in an emptied surface is not content.
+        if (surface.innerHTML !== '') { surface.innerHTML = ''; syncEmptyMark(surface); focusTransientStart(el); }
+        startBurst(surface);
+        return true;
+      }
+      if (transientIsOnlyBlock(el)) return true;
+      removeTransientAfterPress(el);
+      return true;
+    }
+    const res = await commitLinesAtTransient(el, md.split('\n'));
+    if (!res.ok) return false;
+    if (focusInside) focusBlockAtLine(res.newStartLine, true);
+    return true;
+  }
+
+  // 在下方插入 / ＋ 段落: a transient below `blockEl` (below its whole
+  // subtree for a li). Same preamble as insertBlockBelow(): resolve whatever
+  // is open, then re-resolve the block if that resolution re-rendered it.
+  async function insertTransientBelow(blockEl) {
+    if (!blockEl) return;
+    const live = await liveBlockAfterSwitch(blockEl);
+    if (!live) return;
+    createTransient(subtreeEndOf(live), { focus: true });
+  }
+
+  // 在上方插入: a transient right above `blockEl`, i.e. after the block before
+  // it — after that block's whole subtree when it is a li, which is also
+  // where its commit lands (D2), so the screen never shows it anywhere the
+  // file will not.
+  async function insertTransientAbove(blockEl) {
+    if (!blockEl) return;
+    const live = await liveBlockAfterSwitch(blockEl);
+    if (!live) return;
+    const prev = previousBlockEl(live);
+    createTransient(prev ? (isTransient(prev) ? prev : subtreeEndOf(prev)) : null, { focus: true });
+  }
+
+  // switchAwayFrom(), then the live element for `blockEl` (null = abandon).
+  async function liveBlockAfterSwitch(blockEl) {
+    const identity = captureBlockIdentity(blockEl);
+    const selfSession = ownsOpenSession(blockEl);
+    const ok = await switchAwayFrom();
+    if (!ok) return null;
+    if (document.body.contains(blockEl)) return blockEl;
+    const live = reresolveBlockEl(identity) ||
+      (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
+    if (!live) showError(DROPPED_GESTURE_MESSAGE, null, null);
+    return live;
+  }
+
+  // ── v3.14.0 T4: the toolbar on a transient paragraph ──────────────────
+  //
+  // toolbarOnTransient(action, el) → true when the press was handled here,
+  // false when the caller should run its normal action (R8: this is the one
+  // implementation of 在上方／在下方插入 on a transient; T1's earlier branch is
+  // gone). `action` is a toolbar button id, or 'h1'..'h6' for the headings
+  // menu. The inline mark ids, undo, redo, save, outline and the headings
+  // opener are not block actions and always return false.
+  //   with text  commit it (switchAwayFrom), re-target the bar at the block
+  //              it became, return false so the normal action runs on that
+  //   empty      insert-after / insert-before: the caret goes (back) into it;
+  //              table / code / list / h1-h6 / line: its position takes the
+  //              skeleton (insertAtTransient); image: false (the picker's
+  //              anchor is the transient, insertImages() commits there);
+  //              quote / numbered / check / indent / outdent: disabled by
+  //              the model, a no-op here
+  const TOOLBAR_TRANSIENT_PASS = new Set(['undo', 'redo', 'outline', 'save', 'headings',
+    'bold', 'italic', 'strike', 'inline-code', 'link']);
+  async function toolbarOnTransient(action, el) {
+    if (!el || !isTransient(el) || !el.isConnected) return false;
+    if (TOOLBAR_TRANSIENT_PASS.has(action)) return false;
+    if (!transientSurfaceEmpty(el)) {
+      transientLandedLine = null;
+      const ok = await switchAwayFrom();
+      if (!ok || transientLandedLine === null) return true;
+      const landed = blockElAtLine(transientLandedLine);
+      if (!landed) return true;
+      toolbarBlockEl = landed;
+      return false;
+    }
+    switch (action) {
+      case 'insert-after':
+      case 'insert-before':
+        focusTransientStart(el);
+        return true;
+      case 'table': case 'code': case 'list': case 'line':
+        await insertAtTransient(el, action);
+        return true;
+      case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
+        await insertAtTransient(el, 'heading', Number(action.slice(1)));
+        return true;
+      case 'image':
+        return false;
+      default:
+        return true;
+    }
+  }
+
+  // Commits BLOCK_SKELETONS[kind] (a heading builds its own marker) at the
+  // transient's position through commitLinesAtTransient(), as one op, then
+  // focuses it the way insertBlockBelow() does — pristineInsert for the four
+  // placeholder kinds, none for 'line', which instead gets a fresh transient
+  // right after the rule so the caret has somewhere to go. One exception: a
+  // 清單 right below a list item continues that list (insertBlockBelow's li
+  // branch) instead of writing a blank-separated item that would make the
+  // list loose.
+  async function insertAtTransient(el, kind, depth) {
+    const skeleton = kind === 'heading' ? ['#'.repeat(depth || 1) + ' '] : BLOCK_SKELETONS[kind];
+    if (!skeleton) return;
+    if (kind === 'list') {
+      const anchor = transientAnchorEl(el);
+      if (anchor && anchor.getAttribute('data-block-type') === 'li') {
+        removeTransient();
+        await insertBlockBelow(anchor, 'list');
+        return;
+      }
+    }
+    const res = await commitLinesAtTransient(el, skeleton.slice());
+    if (!res.ok) return;
+    if (kind === 'line') {
+      const hr = blockElAtLine(res.newStartLine);
+      if (hr) createTransient(hr, { focus: true });
+      return;
+    }
+    const target = blocks.find((b) => b.startLine === res.newStartLine);
+    if (target) pristineInsert = { blockId: target.id };
+    await focusInsertedBlock(res.newStartLine, kind);
+  }
+
+  // The transient's text as source markdown ('' when it holds none) — the
+  // same serialization resolveTransientBurst() commits.
+  function transientTextMd(el) {
+    const surface = blockContentEl(el);
+    if (!surface || transientSurfaceEmpty(el)) return '';
+    return inlineMd.escapeBlockStarts(inlineMd.serializeInline(surface).md).replace(/\s+$/, '');
+  }
+
+  // Block markdown (a pasted structure, a dropped or picked image) replaces
+  // the transient: its own text first when it has some, a blank line, then
+  // `pastedLines` — all one commit, one op. The caret ends at the end of the
+  // last inserted block. Returns whether the commit landed.
+  async function commitPastedLinesAtTransient(el, pastedLines) {
+    const surface = blockContentEl(el);
+    try {
+      return await commitPastedLinesAtTransientBody(el, pastedLines, surface);
+    } catch (e) {
+      // Fix round 1 (I1): a throw must not leave the typed text on screen with
+      // no burst to commit it (R32). The burst is restarted and the card shown.
+      if (el.isConnected && surface && !currentBurst) startBurst(surface);
+      showError('這次修改沒有套用：發生未預期的錯誤（' + describeFailure(e) +
+        '）。文件維持修改前的樣子。', null, null);
+      return false;
+    }
+  }
+  async function commitPastedLinesAtTransientBody(el, pastedLines, surface) {
+    const text = transientTextMd(el);
+    const all = (text ? text.split('\n').concat(['']) : []).concat(pastedLines);
+    // The text is committed here, with the paste; the burst that holds it must
+    // not resolve it a second time when the render detaches the surface (the
+    // focusout that raises runs before applyFullRender() clears the burst —
+    // MEASURED in Chromium: the typed text was written twice).
+    if (currentBurst && currentBurst.blockEl === el) endBurstWithoutResolve();
+    const res = await commitLinesAtTransient(el, all);
+    if (!res.ok) {
+      if (el.isConnected && surface && !currentBurst) startBurst(surface);
+      return false;
+    }
+    const lastLine = res.newStartLine + all.length - 1;
+    let last = null;
+    blocks.forEach((b) => { if (b.startLine <= lastLine) last = b; });
+    if (last) focusBlockAtLine(last.startLine, true);
+    return true;
+  }
+
+  // An empty document has no block to type into: one focused transient is
+  // its first paragraph (it is the only block, so D3 never removes it).
+  function ensureEmptyDocTransient() {
+    if (contentEl.querySelector('.ed-block')) return;
+    createTransient(null, { focus: true });
+  }
+
+  // Mousedown on the page below the last block starts a paragraph there.
+  // Mousedown with preventDefault (R19), not pointerdown: the press must not
+  // move focus, or the transient made here would be blurred away at once. It
+  // acts only on the page's own empty surfaces (an allow-list), never on a
+  // point that elementsFromPoint says is a block or any chrome; comparing the
+  // y against the last block's bottom is region classification after that.
+  // It does not read pointerPressed.
+  function wireClickBelow() {
+    document.addEventListener('mousedown', (e) => {
+      clickBelowOnMousedown(e).catch((err) => {
+        // Fix round 1 (I2): a rejection after preventDefault() must show the
+        // card, not vanish as an unhandled rejection.
+        showError('這次修改沒有套用：發生未預期的錯誤（' + describeFailure(err) +
+          '）。文件維持修改前的樣子。', null, null);
+      });
+    });
+  }
+  async function clickBelowOnMousedown(e) {
+    {
+      if (e.button !== 0 || e.defaultPrevented || waveEditorIsModal()) return;
+      const t = e.target;
+      const surfaceTarget = t === document.documentElement || t === document.body ||
+        (t.classList && t.classList.contains('page-layout')) ||
+        (t.matches && t.matches('main.content'));
+      if (!surfaceTarget) return;
+      const hits = document.elementsFromPoint(e.clientX, e.clientY);
+      if (hits.some((h) => h.closest &&
+          h.closest('.ed-block, .reader-sidebar, .ed-toolbar, .ed-conflict, .md2doc-theme-toggle'))) return;
+      const all = contentEl.querySelectorAll('.ed-block');
+      if (!all.length) return;
+      if (e.clientY <= all[all.length - 1].getBoundingClientRect().bottom) return;
+      e.preventDefault();
+      const focusLastOrCreate = () => {
+        const now = contentEl.querySelectorAll('.ed-block');
+        const last = now[now.length - 1];
+        if (!last) return;
+        if (!isTransient(last)) { createTransient(last, { focus: true }); return; }
+        // Final review M6: one that holds typed text takes the caret at the
+        // end of it, where a click below the last line lands.
+        const surface = blockContentEl(last);
+        if (surface && !transientSurfaceEmpty(last)) caretToSurface(surface, true);
+        else focusTransientStart(last);
+      };
+      if (isTransient(all[all.length - 1])) { focusLastOrCreate(); return; }
+      if (!(await switchAwayFrom())) return;
+      focusLastOrCreate();
+    }
+  }
+
+  // ── v3.14.0 T2: Enter in a paragraph or a heading ─────────────────────
+  //
+  // Plain Enter splits the block at the caret: the left half keeps the block,
+  // the right half becomes a paragraph below it, and the caret goes to the
+  // right half's start (spec §3.1). At an edge nothing is split: at the end a
+  // transient paragraph opens below with the caret in it, at the start one
+  // opens above and the caret stays. One Enter is one undo step; typing it
+  // commits first is its own earlier step (D4). Whitespace at the split point
+  // is dropped from both halves, and so is a trailing <br> on the left (D5).
+  //
+  // The split goes through the v3.13.1 flight guard: the DOM is split and the
+  // right half armed and focused synchronously, before the commit's render is
+  // awaited, so keys typed meanwhile are held and replayed into the new
+  // paragraph. The two edge cases await the commit of pending typing BEFORE
+  // the transient is created (R7): that commit's render would drop a
+  // transient made first.
+
+  // Where a collapsed caret sits in `surface`: 'start' (nothing before it),
+  // 'end' (nothing after it, a trailing <br> that is the surface's last child
+  // aside), 'empty' (both), 'middle', or null when the selection is not a
+  // collapsed caret inside `surface`. "Nothing" is no <br>, no <img> and no
+  // text but whitespace — whitespace at the split point is dropped anyway, so
+  // a caret after a trailing space is at the end. `strict` (Backspace /
+  // Delete) counts whitespace as text: there the key would delete it.
+  function caretPlace(surface, strict) {
+    const sel = window.getSelection();
+    if (!surface || !sel.rangeCount || !sel.isCollapsed) return null;
+    const r = sel.getRangeAt(0);
+    if (!surface.contains(r.startContainer)) return null;
+    const before = document.createRange();
+    before.selectNodeContents(surface);
+    before.setEnd(r.startContainer, r.startOffset);
+    const after = document.createRange();
+    after.selectNodeContents(surface);
+    after.setStart(r.startContainer, r.startOffset);
+    const last = surface.lastChild;
+    if (last && last.nodeName === 'BR' && after.isPointInRange(last, 0)) after.setEndBefore(last);
+    const holds = (range) => {
+      const frag = range.cloneContents();
+      const text = strict ? frag.textContent : frag.textContent.replace(/\s+/g, '');
+      return text !== '' || !!frag.querySelector('br, img');
+    };
+    const b = holds(before);
+    const a = holds(after);
+    if (!b && !a) return 'empty';
+    if (!b) return 'start';
+    if (!a) return 'end';
+    return 'middle';
+  }
+
+  // R4: the text a paragraph / heading surface commits as — the heading's
+  // own `#` run in front, a paragraph's line-start markers escaped (F-1).
+  // resolveBurst() uses the same rule; split and merge serialize through it.
+  function commitTextOf(md, blockType, depth) {
+    if (blockType === 'heading') return md === '' ? '#'.repeat(depth) : '#'.repeat(depth) + ' ' + md;
+    return blockType === 'paragraph' ? inlineMd.escapeBlockStarts(md) : md;
+  }
+  function surfaceCommitText(surface, blockType, depth) {
+    return commitTextOf(inlineMd.serializeInline(surface).md, blockType, depth);
+  }
+  function burstCommitText(burst, surface) {
+    return surfaceCommitText(surface || burst.editEl, burst.blockType, burst.depth);
+  }
+
+  // Inline elements holding nothing a serializer emits (no text, no <br>, no
+  // <img>) are removed, deepest first — the empty `<a>` or `<strong>` a split
+  // right at a mark's edge leaves on one side would otherwise come back as
+  // `[](url)` or `****`.
+  function dropEmptyInlines(root) {
+    Array.prototype.slice.call(root.querySelectorAll('*')).reverse().forEach((el) => {
+      if (el.nodeName === 'BR' || el.nodeName === 'IMG') return;
+      if (el.textContent === '' && !el.querySelector('br, img')) el.parentNode.removeChild(el);
+    });
+  }
+  // The first (`atEnd` false) or last leaf node under `root`, or null.
+  function edgeLeaf(root, atEnd) {
+    let n = atEnd ? root.lastChild : root.firstChild;
+    while (n && n.nodeType === 1 && (atEnd ? n.lastChild : n.firstChild)) n = atEnd ? n.lastChild : n.firstChild;
+    return n;
+  }
+  // D5 on one half: its whitespace at the split point (the end of the left
+  // half, the start of the right one) — a soft-wrap newline included — plus
+  // one hard break (<br>) on that edge. Fix round 1 (C2): the newline was
+  // kept, so a split at a soft wrap wrote an extra blank line, the right half
+  // landed one line below where the caret was sent, and the next key was
+  // lost (measured: `Alpha one\n\n\nbravo two.`, caret null).
+  function trimSplitEdge(root, atEnd) {
+    root.normalize();
+    dropEmptyInlines(root);
+    const br = edgeLeaf(root, atEnd);
+    if (br && br.nodeName === 'BR') { br.parentNode.removeChild(br); dropEmptyInlines(root); }
+    for (;;) {
+      const leaf = edgeLeaf(root, atEnd);
+      if (!leaf || leaf.nodeType !== 3) return;
+      const t = atEnd ? leaf.data.replace(/[ \t\r\n ]+$/, '') : leaf.data.replace(/^[ \t\r\n ]+/, '');
+      if (t === leaf.data) return;
+      if (t !== '') { leaf.data = t; return; }
+      leaf.parentNode.removeChild(leaf);
+      dropEmptyInlines(root);
+    }
+  }
+
+  // Moves [caret, end of `surface`] into a new provisional paragraph — an
+  // id-less `.ed-block[data-block-type="paragraph"]` right after the source
+  // block — and returns its <p>, or null when the caret is not in `surface`.
+  // Range surgery like splitListItemAtCaret(), so a caret inside a mark or a
+  // link gives each half its own copy of it. The new block owns no line until
+  // the commit's render replaces it (startBurst() opens no burst on it, R2).
+  function splitSurfaceAtCaret(surface) {
+    const sel = window.getSelection();
+    if (!sel.rangeCount) return null;
+    const range = sel.getRangeAt(0).cloneRange();
+    if (!surface.contains(range.startContainer)) return null;
+    const blockEl = surface.closest('.ed-block');
+    if (!blockEl || !blockEl.parentNode) return null;
+    const leftovers = collectLeftovers(range, surface);
+    if (!range.collapsed) range.deleteContents();
+    const tail = document.createRange();
+    tail.setStart(range.startContainer, range.startOffset);
+    tail.setEnd(surface, surface.childNodes.length);
+    collectLeftovers(tail, surface, leftovers);
+    const frag = tail.extractContents();
+    const newBlock = document.createElement('div');
+    newBlock.className = 'ed-block';
+    newBlock.setAttribute('data-block-type', 'paragraph');
+    const right = document.createElement('p');
+    right.appendChild(frag);
+    newBlock.appendChild(right);
+    blockEl.parentNode.insertBefore(newBlock, blockEl.nextSibling);
+    dropEmptied(leftovers);
+    trimSplitEdge(surface, true);
+    trimSplitEdge(right, false);
+    return right;
+  }
+
+  // The two halves of `surface` at the caret as detached copies, D5 applied
+  // — for a transient, whose split is committed before anything is drawn.
+  function halvesAtCaret(surface) {
+    const at = window.getSelection().getRangeAt(0);
+    const half = (left) => {
+      const range = document.createRange();
+      range.selectNodeContents(surface);
+      if (left) range.setEnd(at.startContainer, at.startOffset);
+      else range.setStart(at.startContainer, at.startOffset);
+      const el = document.createElement('p');
+      el.appendChild(range.cloneContents());
+      trimSplitEdge(el, left);
+      return el;
+    };
+    return { left: half(true), right: half(false) };
+  }
+
+  // A structural key moves focus off (or detaches) the focused surface while
+  // its burst is still current; the focusout that raises must not resolve the
+  // burst — the key commits it itself. Same flag and same reason as
+  // mutateListRun(), without the list-run bookkeeping.
+  function withFocusoutSuppressed(fn) {
+    suppressLiFocusout = true;
+    try {
+      return fn();
+    } finally {
+      suppressLiFocusout = false;
+    }
+  }
+
+  // Plain Enter in a paragraph, heading or transient surface (Shift+Enter is
+  // a <br>; a chord still commits by blurring).
+  async function paragraphEnter(e, editEl) {
+    // R / Review Focus 4: an IME's own confirming Enter is the IME's.
+    if (e.isComposing || e.keyCode === 229) return;
+    e.preventDefault();
+    const burst = currentBurst;
+    if (!burst || burst.editEl !== editEl) return;
+    // Content the inline serializer cannot write: the old commit-and-leave,
+    // whose resolution falls back to the source editor.
+    if (inlineMd.serializeInline(editEl).unsupported.length) { editEl.blur(); return; }
+    // A selection standing in the surface is deleted first, one burst step.
+    const sel = window.getSelection();
+    if (sel.rangeCount && !sel.isCollapsed) {
+      const r = sel.getRangeAt(0);
+      if (!editEl.contains(r.startContainer) || !editEl.contains(r.endContainer)) return;
+      snapBurstIfActive(editEl, 'enter-pre');
+      const leftovers = collectLeftovers(r, editEl);
+      r.deleteContents();
+      dropEmptied(leftovers);
+      sel.removeAllRanges();
+      sel.addRange(r);
+      snapBurstIfActive(editEl, 'enter');
+    }
+    const place = caretPlace(editEl);
+    if (!place) return;
+    const blockEl = editEl.closest('.ed-block');
+    // Fix round 1 (C1): an emptied real block is one removal op and a
+    // focused transient where it was. Committing it as text wrote a blank (or
+    // a `<br>` html block), took the block away, and the lookup by start line
+    // then found nothing — no transient, no caret, the next keys lost.
+    if (place === 'empty' && !burst.transient) { await replaceEmptiedBlockWithTransient(burst, editEl); return; }
+    if (burst.transient) {
+      if (place === 'empty') return;
+      if (place === 'middle') { await splitTransientAtCaret(blockEl, editEl); return; }
+    }
+    if (place === 'middle') { await splitBlockAtCaret(burst, editEl, blockEl); return; }
+    const live = await settleEnterSource(burst, blockEl);
+    if (!live) return;
+    const surface = blockContentEl(live);
+    if (place === 'start') {
+      createTransient(previousBlockEl(live), { focus: false, byEnter: true, stayEl: live });
+      if (!surface || !surface.classList.contains('ed-wys-armed')) return;
+      if (document.activeElement !== surface) surface.focus();
+      const r = document.createRange();
+      r.selectNodeContents(surface);
+      r.collapse(true);
+      sel.removeAllRanges();
+      sel.addRange(r);
+      // R3: a surface that kept focus through the commit gets no focusin, and
+      // its burst ended with that commit.
+      if (!currentBurst) startBurst(surface);
+      return;
+    }
+    createTransient(subtreeEndOf(live), { focus: true, byEnter: true,
+      anchorCaret: surface ? { surface, offset: surface.textContent.length } : null });
+  }
+
+  // The edge cases' first step: commit what is pending in the block Enter was
+  // pressed in (R7) and hand back the live element it is now — re-resolved by
+  // its start line when the commit re-rendered it, or the paragraph a
+  // transient with text became. null = the commit failed, do nothing more.
+  async function settleEnterSource(burst, blockEl) {
+    if (burst.transient) {
+      transientLandedLine = null;
+      if (!(await switchAwayFrom())) return null;
+      return transientLandedLine === null ? null : blockElAtLine(transientLandedLine);
+    }
+    const rec = blocks.find((b) => b.id === burst.blockId);
+    if (!rec) return null;
+    const startLine = rec.startLine;
+    if (!(await switchAwayFrom())) return null;
+    return blockEl.isConnected ? blockEl : blockElAtLine(startLine);
+  }
+
+  // The split of a real paragraph / heading. Up to two ops in one render: the
+  // pending typing over the unsplit block (D4), then commitSplit(). A failed
+  // render rolls both back and leaves the screen split; pendingStructure
+  // re-commits it from the live DOM on the next resolution (D7).
+  async function splitBlockAtCaret(burst, editEl, blockEl) {
+    const blockId = burst.blockId;
+    const rec = blocks.find((b) => b.id === blockId);
+    if (!rec) return;
+    const typed = typedInBurst(burst);
+    let right = null;
+    // R5: the right half is armed and focused first, while the burst is still
+    // current (so the focusin that raises opens nothing), then the burst ends.
+    withFocusoutSuppressed(() => {
+      right = splitSurfaceAtCaret(editEl);
+      if (right) armProvisionalSurface(right);
+    });
+    if (!right) return;
+    endBurstWithoutResolve();
+    const leftText = surfaceCommitText(editEl, burst.blockType, burst.depth);
+    const rightText = inlineMd.escapeBlockStarts(inlineMd.serializeInline(right).md);
+    // commitSplit() starts the right half here whatever the typing op did:
+    // that op rewrites only this block, so its start line does not move.
+    const rightStartLine = rec.startLine + leftText.split('\n').length + 1;
+    const ok = await commitTypingThenStructure({ typed,
+      commit: (state) => commitSplit(state, blockId, leftText, rightText),
+      oldRange: [rec.startLine, rec.endLine],
+      lineMap: { ids: { [blockId]: rec.startLine }, provisional: rightStartLine },
+      pending: { surfaces: [editEl, right], serialize: () => {
+        const left = surfaceCommitText(editEl, burst.blockType, burst.depth);
+        const text = left + '\n\n' + inlineMd.escapeBlockStarts(inlineMd.serializeInline(right).md);
+        return { text, lineMap: { ids: { [blockId]: rec.startLine },
+          provisional: rec.startLine + left.split('\n').length + 1 } };
+      } } });
+    if (ok) focusBlockAtLine(rightStartLine, false);
+  }
+
+  // Enter in the middle of a transient with text: its two halves are its
+  // commit — one op (commitLinesAtTransient()), caret to the right one's
+  // start. Nothing is drawn first; a failed commit leaves the transient as it
+  // was, its text and caret included, and keys held meanwhile replay there.
+  async function splitTransientAtCaret(blockEl, editEl) {
+    const h = halvesAtCaret(editEl);
+    const left = inlineMd.escapeBlockStarts(inlineMd.serializeInline(h.left).md).split('\n');
+    const right = inlineMd.escapeBlockStarts(inlineMd.serializeInline(h.right).md).split('\n');
+    // The burst ends first, as commitListStructure()'s does: the render
+    // detaches the focused transient, and Chromium's synchronous focusout
+    // would otherwise resolve this burst a second time — measured: the
+    // transient's whole text committed again above the two halves.
+    endBurstWithoutResolve();
+    const res = await commitLinesAtTransient(blockEl, left.concat([''], right));
+    if (res.ok) {
+      focusBlockAtLine(res.newStartLine + left.length + 1, false);
+      return;
+    }
+    // Failed: the transient keeps its text, so it gets its burst back (its
+    // baseline is empty, so the next resolution commits that text).
+    if (editEl.isConnected && !currentBurst) startBurst(editEl);
+  }
+
+  // ── D7: a structure whose render failed ──────────────────────────────────
+  // The screen keeps what the user made; `lines` was rolled back. The next
+  // resolution (resolveOpenSession(), first), a focus into any surface, or a
+  // structural key (R6) re-commits it from the live DOM before anything else
+  // can commit over it: a commit elsewhere would render, and a render drops
+  // the screen's half of it. Task 2 introduces the slot for the paragraph
+  // split; later tasks reuse it.
+  //   { range: {startLine, endLine}, before, surfaces, serialize }
+  // `serialize()` → { text, lineMap }: what to write over `range`, and the
+  // pendingFlightLineMap that re-points held keys at the result.
+  const PENDING_STRUCTURE_LOST_MESSAGE =
+    '先前沒有寫進檔案的分段／合併已無法補寫：文件在那之後被改過。畫面已換回檔案的內容。';
+  // `covers(surface)` (optional): true when the retry's serialize() reads that
+  // surface — a list run's retry reads every item of the run, not only the
+  // ones the gesture touched. Without it, `surfaces` is the answer.
+  // `typedIds` (fix round 1, I2): ids of covered blocks whose burst a retry
+  // ended with typed text in it. Their text is then only in the DOM, so a
+  // later serialize() must read them from there, not replay their source.
+  function setPendingStructure(startLine, endLine, surfaces, serialize, covers) {
+    pendingStructure = { range: { startLine, endLine },
+      before: lines.slice(startLine - 1, endLine).join('\n'), surfaces, serialize, covers: covers || null,
+      typedIds: new Set() };
+    setDirty(); // R34: it is unsaved work (documentIsDirty())
+  }
+
+  // Re-commits pendingStructure. true = nothing pending (any more); false =
+  // its render failed again (banner shown, the slot stays). A surface the
+  // retry serialized loses its burst without resolving: its text is in the
+  // retry. A slot whose surfaces a render already replaced, or whose range
+  // `lines` no longer holds, is dropped — there is nothing left to write it
+  // from, or nowhere safe to write it.
+  //
+  // v3.14.0 T6: a caret that was in a surface the retry serialized is put
+  // back on the same line and offset once it lands (a Ctrl+S right after a
+  // failed list Enter used to leave focus on the body). And (R28) an open
+  // burst with typed text on a surface the retry does NOT serialize — typing
+  // done after a retry failed too, in another block — is resolved INSIDE the
+  // retry: the structure op first (it happened first), then that burst's own
+  // commit, which renders both. Before, the retry rendered first and dropped
+  // that burst's surface, and its text was lost.
+  async function retryPendingStructure() {
+    const ps = pendingStructure;
+    if (!ps) return true;
+    if (!ps.surfaces.every((s) => s.isConnected) ||
+        lines.slice(ps.range.startLine - 1, ps.range.endLine).join('\n') !== ps.before) {
+      // R32: never silently. Something wrote `lines` or rendered over the
+      // structure first (the R32 audit found no gesture that can); what the
+      // screen showed of it cannot be written any more, so say so and show
+      // the file as it is.
+      pendingStructure = null;
+      setDirty();
+      showError(PENDING_STRUCTURE_LOST_MESSAGE, null, null);
+      if (ps.surfaces.every((s) => s.isConnected)) await safeRerenderAll();
+      return true;
+    }
+    const covers = (el) => !!el && (ps.covers ? ps.covers(el) : ps.surfaces.indexOf(el) !== -1);
+    const caret = selectionSnapshotIn(activeFlightSurface());
+    const caretTag = caret && caret.anchor !== null && covers(caret.surface) ? flightTagOf(caret) : null;
+    // serialize() before the burst ends: a list run's bystander replay reads
+    // the open burst to leave a typed-into item to the DOM.
+    const s = ps.serialize(ps);
+    if (currentBurst && covers(currentBurst.editEl)) {
+      // I2: if this retry's render fails, that typing lives only in the DOM.
+      if (burstHasUncommittedEdit() && currentBurst.blockId !== null) ps.typedIds.add(String(currentBurst.blockId));
+      endBurstWithoutResolve();
+    }
+    const other = burstHasUncommittedEdit() ? currentBurst : null;
+    // `text: null` is a removal (an emptied block whose removal did not land).
+    const result = s.text === null
+      ? commitRangeRemoval({ lines, blocks, stack }, ps.range.startLine, ps.range.endLine)
+      : commitRangeEdit({ lines, blocks, stack }, ps.range.startLine, ps.range.endLine, s.text);
+    const prevLines = lines;
+    const prevBlocks = blocks;
+    if (result.op !== null) lines = result.lines;
+    const editRange = { startLine: ps.range.startLine, endLine: ps.range.endLine,
+      delta: result.op ? result.op.after.length - result.op.before.length : 0 };
+    const undoStructure = () => {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+      blocks = prevBlocks;
+    };
+    let ok;
+    if (other) {
+      // R28. `blocks` shifted with the structure op, so the burst's commit
+      // finds its block where the structure moved it. A render rebinds
+      // `blocks`, which is how this tells whether one landed: a refusal can
+      // render and still answer false, and a no-op answers true unrendered.
+      const shifted = result.op !== null ? result.blocks : blocks;
+      blocks = shifted;
+      pendingFlightLineMap = s.lineMap;
+      const resolved = await resolveBurst();
+      if (blocks !== shifted) {
+        if (pendingStructure === ps) { pendingStructure = null; setDirty(); }
+        return resolved;
+      }
+      if (!resolved) { undoStructure(); return false; }
+      pendingFlightLineMap = s.lineMap;
+      ok = await safeRerenderAll(editRange);
+    } else {
+      pendingFlightLineMap = s.lineMap;
+      ok = await safeRerenderAll(editRange);
+    }
+    if (!ok) { undoStructure(); return false; }
+    if (pendingStructure === ps) { pendingStructure = null; setDirty(); }
+    if (caretTag && !activeFlightSurface() && s.lineMap) {
+      const line = caretTag.blockId === null ? s.lineMap.provisional : s.lineMap.ids[caretTag.blockId];
+      const el = line === null || line === undefined ? null : blockElAtLine(line);
+      const surface = el ? blockContentEl(el) : null;
+      if (surface && surface.classList.contains('ed-wys-armed')) {
+        surface.focus();
+        restoreSelection(surface, caretTag.anchor, caretTag.focus);
+      }
+    }
+    return true;
+  }
+
+  // R6: a structural key pressed while a structure is pending. The retry goes
+  // first and the key is held behind it (the retry's render is a flight), so
+  // it — and anything typed after it — replays once the retry has landed, in
+  // order. If the retry fails the key is dropped: the error card says why.
+  function retryStructureThenReplay(e, surface) {
+    e.preventDefault();
+    const entry = { kind: 'key', key: e.key, shiftKey: e.shiftKey, ctrlKey: e.ctrlKey,
+      altKey: e.altKey, metaKey: e.metaKey };
+    const retry = retryPendingStructure();
+    holdFlightEntry(surface, entry);
+    const drop = () => {
+      const i = flightBuffer.indexOf(entry);
+      if (i !== -1) flightBuffer.splice(i, 1);
+    };
+    retry.then((ok) => {
+      if (!ok) drop();
+      scheduleFlightFlush();
+    }, (err) => { drop(); structuralKeyFailed(err); });
+  }
+
+  // R32 (fix round 1): a structural key's async work is fire-and-forget from
+  // its keydown. A throw there must not vanish (an unhandled rejection) nor
+  // leave held keys waiting for a flush nobody schedules — flightActive()
+  // would then hold every later key. The flight count itself cannot stick:
+  // safeRerenderAll() ends its flight in `finally`.
+  function structuralKeyFailed(err) {
+    if (typeof console !== 'undefined' && console.error) console.error('md2doc: a structural key failed', err);
+    showError('這次修改沒有套用：發生未預期的錯誤（' + describeFailure(err) + '）。文件維持修改前的樣子。', null, null);
+    scheduleFlightFlush();
+  }
+  function isStructuralKeyForRetry(e, surface) {
+    if (e.isComposing || e.keyCode === 229 || e.ctrlKey || e.metaKey || e.altKey) return false;
+    if ((e.key === 'Enter' && !e.shiftKey) || e.key === 'Tab') return true;
+    // v3.14.0 T3: Backspace at a start / Delete at an end joins blocks.
+    if (e.shiftKey || (e.key !== 'Backspace' && e.key !== 'Delete')) return false;
+    const place = caretPlace(surface, true);
+    return place === 'empty' || place === (e.key === 'Backspace' ? 'start' : 'end');
+  }
+
+  // ── v3.14.0 T3: Backspace at a block start, Delete at a block end ──────
+  //
+  // Spec §3.2. Backspace with the caret at the start of a paragraph joins it
+  // to the block above (a paragraph, a heading, or a list item's text); at
+  // the start of a heading it makes the heading a paragraph. Delete at the
+  // end of a paragraph or heading pulls the next one up. A neighbour that has
+  // no text to join (a table, a code block, a list item for Delete) is
+  // selected instead, and an EMPTY block below such a neighbour goes away
+  // with the caret landing at the neighbour's end (R12). Every case is one
+  // undo step; typing the key commits first is its own earlier step (D4).
+  // The join is done on screen synchronously, the caret placed at the seam,
+  // then committed through the flight guard (R5: the new caret first, then
+  // the burst ends), and a failed render keeps the screen as joined
+  // (pendingStructure, D7).
+
+  // Inline marks that merge across a seam when they meet: same tag, no
+  // attributes. Two links merge only when their href is the same.
+  const SEAM_MERGE_TAGS = ['STRONG', 'B', 'EM', 'I', 'DEL', 'S', 'U', 'CODE'];
+  function sameSeamMark(a, b) {
+    if (!a || !b || a.nodeType !== 1 || b.nodeType !== 1 || a.nodeName !== b.nodeName) return false;
+    if (a.nodeName === 'A') return a.getAttribute('href') === b.getAttribute('href');
+    return SEAM_MERGE_TAGS.indexOf(a.nodeName) !== -1 && !a.attributes.length && !b.attributes.length;
+  }
+
+  // Appends `rightNodes` to `leftSurface` and returns the seam: the left
+  // text length before the join. A trailing <br> on the left goes first (at
+  // the end of a line it showed nothing; before joined text it would be a
+  // hard break), and a right side that holds nothing is not appended at all
+  // (an emptied surface keeps a placeholder <br>). At the seam, marks of the
+  // same kind merge, repeated inward, so `**bo**` + `**ld**` is `**bold**`
+  // and not `**bo****ld**`.
+  //
+  // `flatten` (R30, fix round 1 C3): the target is a heading, which is one
+  // line — every hard break (<br>) and soft-wrap newline in the joined text
+  // becomes one space. Measured before: `first\` + `second` merged into
+  // `# D` wrote `# Dfirst\` and a stray `second` paragraph.
+  function joinSeam(leftSurface, rightNodes, flatten) {
+    // T8: a Shift+Enter tail <br> holds no line of its own (insertBrAtCaret()).
+    while (leftSurface.lastChild && leftSurface.lastChild.nodeName === 'BR' &&
+        leftSurface.lastChild.getAttribute('data-ed-tail') === '1') leftSurface.removeChild(leftSurface.lastChild);
+    const tail = leftSurface.lastChild;
+    if (tail && tail.nodeName === 'BR') leftSurface.removeChild(tail);
+    leftSurface.normalize();
+    const seam = leftSurface.textContent.length;
+    const holder = document.createElement('p');
+    rightNodes.forEach((n) => holder.appendChild(n));
+    // Asked BEFORE the flatten below, which turns an emptied surface's
+    // placeholder <br> into a space. Fix round 2: asked after it, that space
+    // was appended to the heading — Backspace removing an emptied paragraph
+    // under `# D` saved `# D `.
+    if (holder.textContent === '' && !holder.querySelector('img')) return seam;
+    if (flatten) {
+      // A break at either edge of the joined text separates nothing, so the
+      // space it would become goes too (fix round 2: a text ending in a
+      // <br> joined a heading as `# Dfirst `).
+      const breakAt = (atEnd) => {
+        const leaf = edgeLeaf(holder, atEnd);
+        if (!leaf) return false;
+        if (leaf.nodeName === 'BR') return true;
+        return leaf.nodeType === 3 && (atEnd ? /\n[ \t]*$/ : /^[ \t]*\n/).test(leaf.data);
+      };
+      // normalize() first: an editing surface often carries an EMPTY text
+      // node after its last <br> (invisible in innerHTML), and edgeLeaf()
+      // would answer that instead of the break.
+      holder.normalize();
+      const leadingBreak = breakAt(false);
+      const trailingBreak = breakAt(true);
+      Array.prototype.slice.call(holder.querySelectorAll('br')).forEach((br) => {
+        br.parentNode.replaceChild(document.createTextNode('\n'), br);
+      });
+      holder.normalize();
+      const walker = document.createTreeWalker(holder, NodeFilter.SHOW_TEXT);
+      for (let t = walker.nextNode(); t; t = walker.nextNode()) {
+        t.data = t.data.replace(/[ \t]*\n[ \t\n]*/g, ' ');
+      }
+      const first = edgeLeaf(holder, false);
+      if (leadingBreak && first && first.nodeType === 3) first.data = first.data.replace(/^ /, '');
+      const last = edgeLeaf(holder, true);
+      if (trailingBreak && last && last.nodeType === 3) last.data = last.data.replace(/ $/, '');
+      if (holder.textContent === '' && !holder.querySelector('img')) return seam;
+    }
+    let a = leftSurface.lastChild;
+    while (holder.firstChild) leftSurface.appendChild(holder.firstChild);
+    while (a && sameSeamMark(a, a.nextSibling)) {
+      const b = a.nextSibling;
+      const inner = a.lastChild;
+      while (b.firstChild) a.appendChild(b.firstChild);
+      b.parentNode.removeChild(b);
+      a = inner;
+    }
+    leftSurface.normalize();
+    return seam;
+  }
+
+  // focusBlockAtLine() with the caret at a character offset.
+  function focusBlockAtLineOffset(startLine, offset) {
+    const el = blockElAtLine(startLine);
+    const surface = el ? blockContentEl(el) : null;
+    if (!surface || !surface.classList.contains('ed-wys-armed')) return;
+    surface.focus();
+    restoreSelection(surface, offset, offset);
+  }
+
+  // The armed text surface a join can go into: a paragraph, a heading or a
+  // list item, or null.
+  function mergeSurfaceOf(blockEl) {
+    if (!blockEl) return null;
+    const t = blockEl.getAttribute('data-block-type');
+    if (t !== 'paragraph' && t !== 'heading' && t !== 'li') return null;
+    const s = blockContentEl(blockEl);
+    return s && s.classList.contains('ed-wys-armed') ? s : null;
+  }
+  function nextBlockEl(el) {
+    let n = el.nextElementSibling;
+    while (n && !n.classList.contains('ed-block')) n = n.nextElementSibling;
+    return n;
+  }
+  function selectBlock(blockEl) {
+    const rec = blockRecOf(blockEl);
+    if (!rec || rec.endLine < rec.startLine) return;
+    setBlockSelection({ anchorLine: rec.startLine, focusLine: rec.startLine });
+  }
+  function caretToSurface(surface, atEnd) {
+    surface.focus();
+    const r = document.createRange();
+    r.selectNodeContents(surface);
+    r.collapse(!atEnd);
+    const sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(r);
+  }
+
+  // Plain Backspace (dir -1) at the start, or plain Delete (dir 1) at the end,
+  // of a paragraph, heading or transient surface. true = handled (and
+  // preventDefault() done); false = the browser's own key.
+  function blockEdgeDelete(e, editEl, dir) {
+    if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.isComposing || e.keyCode === 229) return false;
+    const burst = currentBurst;
+    if (!burst || burst.editEl !== editEl) return false;
+    if (burst.blockType !== 'paragraph' && burst.blockType !== 'heading') return false;
+    const place = caretPlace(editEl, true);
+    if (dir < 0 ? (place !== 'start' && place !== 'empty') : (place !== 'end' && place !== 'empty')) return false;
+    if (inlineMd.serializeInline(editEl).unsupported.length) return false;
+    e.preventDefault();
+    const blockEl = editEl.closest('.ed-block');
+    (dir < 0 ? backspaceAtStart(burst, editEl, blockEl, place === 'empty')
+      : deleteAtEnd(burst, editEl, blockEl, place === 'empty')).catch(structuralKeyFailed);
+    return true;
+  }
+
+  // The commit every structural key here ends with (the Enter split, every
+  // Backspace / Delete join, the heading -> paragraph conversion, the
+  // removal of an emptied block): the pending typing of the block the key
+  // was pressed in (D4), then the structure — `o.commit(state)`, or `o.text`
+  // over the range `o.range(blocks)` computes in the state after the typing
+  // op (a removal when `text` is null) — in ONE render. `oldRange` is the
+  // range in today's lines. A failed render rolls both ops back, newest
+  // first, and records `o.pending` (D7). Fix round 1 (I2): the split used to
+  // carry its own copy of all of this.
+  async function commitTypingThenStructure(o) {
+    const prevLines = lines;
+    const first = o.typed ? commitEdit({ lines, blocks, stack }, o.typed.blockId, o.typed.text) : null;
+    const typedOp = first && first.op ? first : null;
+    const state = typedOp ? { lines: typedOp.lines, blocks: typedOp.blocks, stack } : { lines, blocks, stack };
+    let second;
+    if (o.commit) second = o.commit(state);
+    else {
+      const range = o.range(state.blocks);
+      second = o.text === null
+        ? commitRangeRemoval(state, range[0], range[1])
+        : commitRangeEdit(state, range[0], range[1], o.text);
+    }
+    lines = second.lines;
+    const delta = (typedOp ? typedOp.op.after.length - typedOp.op.before.length : 0) +
+      (second.op ? second.op.after.length - second.op.before.length : 0);
+    pendingFlightLineMap = o.lineMap;
+    const ok = await safeRerenderAll({ startLine: o.oldRange[0], endLine: o.oldRange[1], delta });
+    if (ok) return true;
+    lines = rollbackFailedRender({ lines, stack }, second, typedOp ? typedOp.lines : prevLines);
+    if (typedOp) lines = rollbackFailedRender({ lines, stack }, typedOp, prevLines);
+    if (o.pending) setPendingStructure(o.oldRange[0], o.oldRange[1], o.pending.surfaces, o.pending.serialize);
+    return false;
+  }
+
+  function typedInBurst(burst) {
+    if (burst.transient || burstBaselineHtml(burst.editEl) === burst.original) return null;
+    burst.history.flushTyping();
+    return { blockId: burst.blockId, text: burstCommitText(burst) };
+  }
+
+  async function backspaceAtStart(burst, editEl, blockEl, empty) {
+    if (burst.blockType === 'heading') { await headingToParagraph(burst, editEl, blockEl, empty); return; }
+    const prev = previousBlockEl(blockEl);
+    if (!prev) return;
+    // An empty transient above (Enter at this block's start made it): the
+    // Backspace takes it away. One with text: this block joins it (R31).
+    if (isTransient(prev)) {
+      if (transientSurfaceEmpty(prev)) removeTransient();
+      else if (!burst.transient) await joinTransientIntoBlock(burst, editEl, prev, false);
+      return;
+    }
+    const curIsTransient = !!burst.transient;
+    const prevSurface = mergeSurfaceOf(prev);
+    if (!prevSurface) {
+      if (!empty) { selectBlock(prev); return; }
+      // R12 (spec §3.2): an empty block below a table / code block goes, and
+      // the caret lands at that block's end.
+      if (curIsTransient) {
+        removeTransient();
+        arrowLandOn(prev, -1, null);
+        return;
+      }
+      const rec = blocks.find((b) => b.id === burst.blockId);
+      const prevRec = blockRecOf(prev);
+      if (!rec || !prevRec) return;
+      endBurstWithoutResolve();
+      const ok = await commitTypingThenStructure({ typed: null, text: null,
+        range: (bs) => { const r = bs.find((b) => b.id === rec.id); return [r.startLine, r.endLine]; },
+        oldRange: [rec.startLine, rec.endLine], lineMap: { ids: {}, provisional: null },
+        pending: { surfaces: [editEl], serialize: () => ({ text: null, lineMap: { ids: {}, provisional: null } }) } });
+      if (ok) {
+        const landed = blockElAtLine(prevRec.startLine);
+        if (landed) arrowLandOn(landed, -1, null);
+      }
+      return;
+    }
+    if (curIsTransient && empty) {
+      removeTransient();
+      caretToSurface(prevSurface, true);
+      return;
+    }
+    await joinIntoPrevious(burst, editEl, blockEl, prev, prevSurface, empty);
+  }
+
+  // Backspace at the start of `blockEl` (a paragraph or a transient with
+  // text) into the block above: a paragraph, a heading or a list item.
+  // `empty`: the surface was emptied, so its typing is not committed as an op
+  // of its own (final review I2) — it would write the placeholder <br> left
+  // behind as a raw-html block, and one Ctrl+Z would land there. The join
+  // alone is the step, as for every other emptied-block removal (C1, R12).
+  async function joinIntoPrevious(burst, editEl, blockEl, prev, prevSurface, empty) {
+    const curIsTransient = !!burst.transient;
+    const prevRec = blockRecOf(prev);
+    const curRec = curIsTransient ? null : blocks.find((b) => b.id === burst.blockId);
+    if (!prevRec || (!curIsTransient && !curRec)) return;
+    const prevType = prev.getAttribute('data-block-type');
+    const prevDepth = blockDepthOf(prevType, prevSurface);
+    let run = null;
+    let runRange = null;
+    if (prevType === 'li') {
+      run = listRunOf(prev);
+      runRange = run.length ? runRangeOfBlocks({ lines, blocks, stack }, run) : null;
+      if (!runRange) return;
+      if (!listRunSupportsStructuralEdit(run, prev)) { refuseStructuralListEdit(); return; }
+    }
+    const typed = empty ? null : typedInBurst(burst);
+    let seam = 0;
+    withFocusoutSuppressed(() => {
+      seam = joinSeam(prevSurface, Array.prototype.slice.call(editEl.childNodes), prevType === 'heading');
+      prevSurface.focus();
+      restoreSelection(prevSurface, seam, seam);
+      if (curIsTransient) removeTransient();
+      else blockEl.parentNode.removeChild(blockEl);
+    });
+    endBurstWithoutResolve();
+    const startLine = run ? runRange.startLine : prevRec.startLine;
+    const curId = curRec ? curRec.id : null;
+    const endIn = (bs, fallback) => {
+      if (curId === null) return fallback;
+      const r = bs.find((b) => b.id === curId);
+      return r ? r.endLine : fallback;
+    };
+    const serialize = () => {
+      if (run) {
+        const out = serializeListEls(run, { carryOver: bystanderCarryOver(run, prev) });
+        const map = flightLineMapOf(out.lineMeta, runRange.startLine);
+        return { text: out.md, lineMap: { ids: map.ids, provisional: null } };
+      }
+      return { text: surfaceCommitText(prevSurface, prevType, prevDepth),
+        lineMap: { ids: { [prevRec.id]: prevRec.startLine }, provisional: null } };
+    };
+    const s = serialize();
+    const oldEnd = curRec ? curRec.endLine : (run ? runRange.endLine : prevRec.endLine);
+    const ok = await commitTypingThenStructure({ typed, text: s.text,
+      range: (bs) => [startLine, endIn(bs, run ? runRange.endLine : prevRec.endLine)],
+      oldRange: [startLine, oldEnd], lineMap: s.lineMap,
+      pending: { surfaces: [prevSurface], serialize } });
+    if (ok) focusBlockAtLineOffset(prevRec.startLine, seam);
+  }
+
+  // Backspace at the start of a heading: it becomes a paragraph (its text
+  // escaped where it would read as a block marker). An empty heading is
+  // removed and an empty transient paragraph takes its place.
+  async function headingToParagraph(burst, editEl, blockEl, empty) {
+    if (empty) { await replaceEmptiedBlockWithTransient(burst, editEl); return; }
+    const rec = blocks.find((b) => b.id === burst.blockId);
+    if (!rec) return;
+    const typed = typedInBurst(burst);
+    endBurstWithoutResolve();
+    const text = () => inlineMd.escapeBlockStarts(inlineMd.serializeInline(editEl).md);
+    const lineMap = { ids: { [rec.id]: rec.startLine }, provisional: null };
+    const ok = await commitTypingThenStructure({ typed, text: text(),
+      range: (bs) => { const r = bs.find((b) => b.id === rec.id); return [r.startLine, r.endLine]; },
+      oldRange: [rec.startLine, rec.endLine], lineMap,
+      pending: { surfaces: [editEl], serialize: () => ({ text: text(), lineMap }) } });
+    if (ok) focusBlockAtLineOffset(rec.startLine, 0);
+  }
+
+  // An emptied real block (paragraph or heading) under Enter, or an empty
+  // heading under Backspace: ONE removal op (an empty block cannot be
+  // written), then a focused transient where it was — after the block before
+  // it (the end of that block's subtree for a li), or at the top. Keys typed
+  // during the render are held and replay into that transient. As with the
+  // empty-li Enter (T1), Ctrl+Z in that still-empty transient first takes the
+  // transient away, then the next one reverts the removal.
+  async function replaceEmptiedBlockWithTransient(burst, editEl) {
+    const rec = blocks.find((b) => b.id === burst.blockId);
+    if (!rec) return;
+    const preceding = blocks.filter((b) => b.id !== rec.id && b.endLine < rec.startLine).pop() || null;
+    endBurstWithoutResolve();
+    const lineMap = { ids: {}, provisional: null };
+    const ok = await commitTypingThenStructure({ typed: null, text: null,
+      range: (bs) => { const r = bs.find((b) => b.id === rec.id); return [r.startLine, r.endLine]; },
+      oldRange: [rec.startLine, rec.endLine], lineMap,
+      pending: { surfaces: [editEl], serialize: () => ({ text: null, lineMap }) } });
+    if (!ok) return;
+    const anchor = preceding ? blockElAtLine(preceding.startLine) : null;
+    if (preceding && !anchor) return;
+    createTransient(anchor ? subtreeEndOf(anchor) : null, { focus: true });
+  }
+
+
+  // R31 (fix round 1): a transient WITH text next to the real block the key
+  // was pressed in. Its text was never committed, so the join is ONE op on
+  // the real block's range (after the block's own pending typing, D4): Delete
+  // at the block's end pulls the transient's text up into the block;
+  // Backspace at the block's start joins the block onto the end of the
+  // transient's text, and the joined paragraph takes the block's lines.
+  async function joinTransientIntoBlock(burst, editEl, transientEl, pullUp) {
+    const rec = blocks.find((b) => b.id === burst.blockId);
+    const tSurface = blockContentEl(transientEl);
+    if (!rec || !tSurface) return;
+    const typed = typedInBurst(burst);
+    const into = pullUp ? editEl : tSurface;
+    const from = pullUp ? tSurface : editEl;
+    const flatten = pullUp && burst.blockType === 'heading';
+    let seam = 0;
+    withFocusoutSuppressed(() => {
+      seam = joinSeam(into, Array.prototype.slice.call(from.childNodes), flatten);
+      into.focus();
+      restoreSelection(into, seam, seam);
+      if (pullUp) {
+        removeTransient();
+      } else {
+        // The transient now holds the joined text and stands in for the block
+        // on screen until the render; the `transient` slot lets go of it so
+        // nothing resolves it as a transient of its own.
+        editEl.closest('.ed-block').parentNode.removeChild(editEl.closest('.ed-block'));
+        if (transient && transient.el === transientEl) transient = null;
+      }
+    });
+    endBurstWithoutResolve();
+    const text = () => (pullUp
+      ? surfaceCommitText(editEl, burst.blockType, burst.depth)
+      : inlineMd.escapeBlockStarts(inlineMd.serializeInline(tSurface).md));
+    const lineMap = { ids: { [rec.id]: rec.startLine }, provisional: null };
+    const ok = await commitTypingThenStructure({ typed, text: text(),
+      range: (bs) => { const r = bs.find((b) => b.id === rec.id); return [r.startLine, r.endLine]; },
+      oldRange: [rec.startLine, rec.endLine], lineMap,
+      pending: { surfaces: [into], serialize: () => ({ text: text(), lineMap }) } });
+    if (ok) focusBlockAtLineOffset(rec.startLine, seam);
+  }
+
+  async function deleteAtEnd(burst, editEl, blockEl, empty) {
+    const next = nextBlockEl(blockEl);
+    // Nothing below: nothing happens (an empty transient there is the last
+    // block and stays, R12).
+    if (!next) return;
+    if (isTransient(next)) {
+      if (transientSurfaceEmpty(next)) removeTransient();
+      else if (!burst.transient) await joinTransientIntoBlock(burst, editEl, next, true);
+      return;
+    }
+    const curIsTransient = !!burst.transient;
+    const nextSurface = mergeSurfaceOf(next);
+    const nextType = next.getAttribute('data-block-type');
+    if (curIsTransient && empty) {
+      removeTransient();
+      if (nextSurface) caretToSurface(nextSurface, false);
+      else selectBlock(next);
+      return;
+    }
+    // D14: a list item is never pulled up into a paragraph; it is selected.
+    if (!nextSurface || nextType === 'li') { selectBlock(next); return; }
+    const nextRec = blockRecOf(next);
+    const curRec = curIsTransient ? null : blocks.find((b) => b.id === burst.blockId);
+    if (!nextRec || (!curIsTransient && !curRec)) return;
+    // Final review I2, as in joinIntoPrevious(): an emptied block's typing is
+    // not an op of its own.
+    const typed = empty ? null : typedInBurst(burst);
+    let seam = 0;
+    withFocusoutSuppressed(() => {
+      seam = joinSeam(editEl, Array.prototype.slice.call(nextSurface.childNodes), burst.blockType === 'heading');
+      restoreSelection(editEl, seam, seam);
+      next.parentNode.removeChild(next);
+    });
+    endBurstWithoutResolve();
+    const headId = curRec ? curRec.id : nextRec.id;
+    const headLine = curRec ? curRec.startLine : nextRec.startLine;
+    const serialize = () => ({
+      text: curIsTransient
+        ? inlineMd.escapeBlockStarts(inlineMd.serializeInline(editEl).md)
+        : surfaceCommitText(editEl, burst.blockType, burst.depth),
+      lineMap: { ids: { [headId]: headLine }, provisional: null } });
+    const s = serialize();
+    const ok = await commitTypingThenStructure({ typed, text: s.text,
+      range: (bs) => {
+        const n = bs.find((b) => b.id === nextRec.id);
+        const c = curRec ? bs.find((b) => b.id === curRec.id) : null;
+        return [c ? c.startLine : n.startLine, n.endLine];
+      },
+      oldRange: [headLine, nextRec.endLine], lineMap: s.lineMap,
+      pending: { surfaces: [editEl], serialize } });
+    if (ok) focusBlockAtLineOffset(headLine, seam);
+  }
+
   // S2 Task 7 — the li half of ＋. The new item is spliced into the run's own
   // span and the WHOLE span is re-serialized over the run's line range: one
   // commitRangeEdit, therefore one undo op, no leading blank line (so the run
@@ -6129,12 +7721,12 @@
   // never reported, never tested for duplicate/delete) — widening past
   // convertBlockViaMenu() to the other three callers remains a separate
   // decision this task did not make and should not make silently.
-  function restoreAfterStructuralOp(focusLine, anchorLine, allowRawEditRescue) {
+  function restoreAfterStructuralOp(focusLine, anchorLine, allowRawEditRescue, caretToEnd) {
     // 有 blockSelection 站著時什麼都不做 —— 見 convertBlockViaMenu() 底下那段
     // 註解：強行還原 caret 會做出「底色仍說已選取、Delete 卻是死鍵」的混種狀態。
     if (blockSelection) return;
     if (focusLine != null) {
-      focusBlockAtLine(focusLine, true);   // caretToEnd
+      focusBlockAtLine(focusLine, caretToEnd !== false);   // caretToEnd unless asked otherwise
       // 降級目標（quote / code）沒有可聚焦編輯面，focusBlockAtLine 會安靜
       // no-op；把 toolbarBlockEl 指回那個 block，工具列才不會塌成 4 顆。
       reaimToolbarBlockAtLine(focusLine);
@@ -6254,7 +7846,10 @@
   // The body returns the operated block's post-commit start line, or undefined
   // when it refused or wrote nothing — `anchor.line` is what covers the
   // second case (see restoreAfterStructuralOp()).
-  async function convertBlockViaMenu(blockEl, target) {
+  // `opts.caretToEnd === false` puts the caret at the start of the converted
+  // block instead of its end (Backspace at a list item's start, final review
+  // I1); the ⠿ menu passes nothing.
+  async function convertBlockViaMenu(blockEl, target, opts) {
     let focusLine = null;
     const anchor = {};
     try {
@@ -6270,7 +7865,7 @@
       // Task 9 review I4: `true` — this is the ONE call site backlog #6's
       // raw-editor rescue is scoped to. See restoreAfterStructuralOp()'s
       // own `allowRawEditRescue` comment.
-      restoreAfterStructuralOp(focusLine, anchor.line, true);
+      restoreAfterStructuralOp(focusLine, anchor.line, true, !(opts && opts.caretToEnd === false));
     }
   }
 
@@ -6413,7 +8008,8 @@
   // block the user never pointed at.
   function reresolveBlockElAfterSelfCommit(identity) {
     if (!identity) return null;
-    const at = blocks.find((b) => b.startLine === identity.startLine);
+    const startLine = identityStartLineNow(identity);
+    const at = blocks.find((b) => b.startLine === startLine);
     if (!at || at.type !== identity.type) return null;
     return document.querySelector('.ed-block[data-block-id="' + at.id + '"]');
   }
@@ -7774,8 +9370,16 @@
   function burstBaselineHtml(editEl) {
     const html = editEl.innerHTML;
     if (html.indexOf('ed-te-hl') === -1 && html.indexOf('ed-te-row-dragging') === -1 &&
-        html.indexOf('ed-cell-range') === -1) return html;
+        html.indexOf('ed-cell-range') === -1 && html.indexOf('search-hit') === -1) return html;
     const clone = editEl.cloneNode(true);
+    // v3.14.0 T9: the reader's search marks are transient chrome; unwrap them
+    // and rejoin the text they cut.
+    Array.prototype.slice.call(clone.querySelectorAll('mark.search-hit')).forEach((mk) => {
+      const par = mk.parentNode;
+      while (mk.firstChild) par.insertBefore(mk.firstChild, mk);
+      par.removeChild(mk);
+      par.normalize();
+    });
     const marked = clone.querySelectorAll('.ed-te-hl, .ed-te-row-dragging, .ed-cell-range');
     Array.prototype.forEach.call(marked, (el) => {
       el.classList.remove('ed-te-hl');
@@ -7795,6 +9399,32 @@
     dropDiscardedRawEdit();
     const blockEl = editEl.closest('.ed-block');
     if (!blockEl) return;
+    // v3.14.0 T1: a transient paragraph has no block record and no line. Its
+    // burst carries `transient: true` and an empty baseline; resolveBurst()
+    // commits it through commitLinesAtTransient() instead of commitEdit().
+    if (blockEl.hasAttribute('data-ed-transient')) {
+      const tHistory = historyLib.createBurstHistory(() => burstBaselineHtml(editEl), { debounceMs: 400 });
+      tHistory.start();
+      currentBurst = {
+        blockEl, editEl, blockId: null, blockType: 'paragraph', transient: true,
+        depth: null, original: '', history: tHistory,
+      };
+      watchBurstForDirtyDot(editEl);
+      selToolbarEditEl = editEl;
+      if (!selToolbarListener) {
+        selToolbarListener = onSelectionChangeForToolbar;
+        document.addEventListener('selectionchange', onSelectionChangeForToolbar);
+      }
+      return;
+    }
+    // R2 (F1): any OTHER id-less block (the provisional li an Enter builds
+    // before its render lands) opens no burst. `Number(null)` is 0, so without
+    // this the burst bound itself to block 0 and its commit could overwrite
+    // the document's first line.
+    // T6: also after that item's render FAILED. It is then part of a pending
+    // run (setPendingListRun()), and the retry re-commits the whole live run,
+    // this item's text included; a burst of its own would commit it alone.
+    if (blockEl.getAttribute('data-block-id') === null) return;
     const blockId = Number(blockEl.getAttribute('data-block-id'));
     const block = blocks.find((b) => b.id === blockId);
     if (!block) return;
@@ -7854,6 +9484,9 @@
     // ordinal into.
     cancelBlockDrag();
     if (!burst) return true;
+    // v3.14.0 T1: a transient's burst never reaches the commitEdit() path
+    // below — it has no block to commit over. See resolveTransientBurst().
+    if (burst.transient) return await resolveTransientBurst(burst);
     // §10-gap fix (review): this burst's block's "pristine" window (see
     // `pristineInsert`'s own comment) closes right here, the moment its
     // OWN first burst resolves — one way (a real edit, below) or the
@@ -8100,9 +9733,9 @@
     // the paragraph into that block. A heading's text sits after its own
     // `# ` and needs none; a table's rows START with `|`, so its markdown
     // must never reach the escape — hence the blockType test, not just depth.
-    const newText = burst.depth === null
-      ? (burst.blockType === 'paragraph' ? inlineMd.escapeBlockStarts(result.md) : result.md) :
-      (result.md === '' ? '#'.repeat(burst.depth) : '#'.repeat(burst.depth) + ' ' + result.md);
+    // v3.14.0 T2 (R4): the rule itself lives in commitTextOf(), which the
+    // split and the merge serialize through too.
+    const newText = commitTextOf(result.md, burst.blockType, burst.depth);
     // S1 removed the pre-per-li "a whole-list burst that serialized to ''"
     // branch that lived here alongside the dead 'list' serializer arm above.
     // The per-li equivalent — a run whose every item was removed — is handled
@@ -8657,11 +10290,30 @@
     if (raw === null) return null;
     const b = blocks.find((x) => x.id === Number(raw));
     if (!b) return null;
-    return { startLine: b.startLine, type: b.type, source: blockSourceOf(b) };
+    return { startLine: b.startLine, type: b.type, source: blockSourceOf(b),
+      transientSeq: transientCommits.seq };
+  }
+  // v3.14.0 T1 fix round 1 (I2): where `identity`'s block starts NOW. A
+  // transient's commit is a pure insertion — no existing line is rewritten —
+  // so a block it moved is exactly `delta` lines further down, and the
+  // fingerprint below still holds. Every other commit keeps the old rule
+  // (its start line must not have moved, or the gesture is dropped). Measured
+  // before: type into a transient, then ＋ / ⠿ on any block below it — the
+  // gesture's own switchAwayFrom() committed the transient, the target's
+  // start line moved by ≥ 2, and the gesture was dropped with
+  // DROPPED_GESTURE_MESSAGE.
+  function identityStartLineNow(identity) {
+    let line = identity.startLine;
+    const since = identity.transientSeq === undefined ? transientCommits.seq : identity.transientSeq;
+    transientCommits.log.forEach((c) => {
+      if (c.seq > since && c.at <= line) line += c.delta;
+    });
+    return line;
   }
   function reresolveBlockEl(identity) {
     if (!identity) return null;
-    const at = blocks.find((b) => b.startLine === identity.startLine);
+    const startLine = identityStartLineNow(identity);
+    const at = blocks.find((b) => b.startLine === startLine);
     if (!at || at.type !== identity.type || blockSourceOf(at) !== identity.source) return null;
     return document.querySelector('.ed-block[data-block-id="' + at.id + '"]');
   }
@@ -8863,12 +10515,59 @@
       // successful render (any later commit, undo, or redo) re-derives the DOM
       // from `lines`. Same convention as insertBlockBelow() /
       // deleteBlockViaGutter() / resolveBurst()'s own failure paths.
+      // v3.14.0 T6 (D7, R14 widened): "until the next successful render"
+      // used to mean the next render threw the screen's run away — measured:
+      // Enter after `bravo`, the render fails, type `new`, leave: the file
+      // had no `- new`. The run is now pending (retryPendingStructure()):
+      // the next resolution, focus into any surface, or a structural key
+      // re-commits the whole LIVE run over the same range first, provisional
+      // item and anything typed into it included, as one op.
+      setPendingListRun(span, range, opts && opts.carryOver);
       return false;
     }
     if (focusStartLine != null) focusBlockAtLine(focusStartLine, caretToEnd);
     return true;
   }
 
+  // T6: the pendingStructure slot for a list run whose commit did not land.
+  // `span` is the post-mutation run the commit serialized; its provisional
+  // item (no id) is the member the live run is re-derived from, else any
+  // member still on screen. The bystander replay is the commit's own set —
+  // `carry0` names exactly the items the gesture did not touch — re-read
+  // from `lines` and minus an item typed into since (bystanderCarryOver()'s
+  // dirty-burst rule), so a later edit in the run is not replayed away.
+  function setPendingListRun(span, range, carry0) {
+    const members = (span || []).slice();
+    const liveMember = () => members.find((el) => el.isConnected && el.getAttribute('data-block-id') === null) ||
+      members.find((el) => el.isConnected) || null;
+    const liveRun = () => { const m = liveMember(); return m ? listRunOf(m) : []; };
+    const surfaces = members.map(liTextEl).filter(Boolean);
+    setPendingStructure(range.startLine, range.endLine, surfaces, (ps) => {
+      const run = liveRun();
+      if (!run.length) return { text: null, lineMap: null };
+      let carry = null;
+      if (carry0) {
+        const fresh = bystanderCarryOver(run, null) || {};
+        Object.keys(fresh).forEach((k) => {
+          // Fix round 1 (I2): an item typed into after the failure, whose
+          // burst an earlier (failed) retry ended, is read from the DOM.
+          // Measured before: failed Enter, type in `charlie`, a second retry
+          // fails, and the next commit wrote `- charlie` with no message.
+          if (!(k in carry0) || (ps && ps.typedIds && ps.typedIds.has(k))) return;
+          carry = carry || {};
+          carry[k] = fresh[k];
+        });
+      }
+      const res = serializeListEls(run, { carryOver: carry });
+      return res.md === ''
+        ? { text: null, lineMap: null }
+        : { text: res.md, lineMap: flightLineMapOf(res.lineMeta, range.startLine) };
+    }, (el) => {
+      const b = el && el.closest ? el.closest('.ed-block') : null;
+      return !!b && liveRun().indexOf(b) !== -1;
+    });
+  }
+
   // The line `targetBlock`'s own marker will occupy once the run span it belongs
   // to is committed by commitListStructure() above.
   //
@@ -9052,6 +10751,34 @@
     // this unconditionally qualifies as "abandoned" (no separate
     // unchanged-check needed here, unlike resolveBurst()'s branch, where a
     // real commit is also possible).
+    // v3.14.0 T1: Escape in a transient abandons it — it wrote nothing, so
+    // there is nothing to stash for Ctrl+Z. The only block of an empty
+    // document stays (D3), emptied.
+    if (burst.transient) {
+      burst.history.dispose();
+      currentBurst = null;
+      resetSelToolbarState();
+      editEl.innerHTML = '';
+      syncEmptyMark(editEl);
+      if (transientIsOnlyBlock(burst.blockEl)) return; // still focused, still empty
+      // T8 (D8): the caret does not fall to the body — it goes back where
+      // the gesture that made the transient was pressed, else to the end of
+      // the block above, so the next key is typed somewhere.
+      const t = transient;
+      const prev = previousBlockEl(burst.blockEl);
+      removeTransient();
+      if (t && t.anchorCaret && t.anchorCaret.surface && t.anchorCaret.surface.isConnected) {
+        t.anchorCaret.surface.focus();
+        restoreSelection(t.anchorCaret.surface, t.anchorCaret.offset, t.anchorCaret.offset);
+        return;
+      }
+      const surface = prev ? blockContentEl(prev) : null;
+      if (surface && surface.classList.contains('ed-wys-armed')) {
+        surface.focus();
+        placeCaretAtEnd(surface);
+      }
+      return;
+    }
     const wasPristineForThisBlock = !!(pristineInsert && pristineInsert.blockId === burst.blockId);
     if (wasPristineForThisBlock) pristineInsert = null;
     // T21 item 1: a pristine insert keeps the old, unrecoverable shape, and
@@ -9092,7 +10819,13 @@
     };
     currentBurst = null;
     resetSelToolbarState();
-    editEl.blur();
+    // v3.14.0 T8 (D8): the caret stays in the reverted surface, at its end,
+    // instead of blur(): the key typed right after Escape went nowhere before
+    // (measured: X, Escape, Y saved nothing of Y). The surface has no burst
+    // now; the next input into it starts one (ensureBurst()). Ctrl+Z still
+    // finds the stash above first (restoreDiscardedBurst()).
+    syncEmptyMark(editEl);
+    placeCaretAtEnd(editEl);
   }
 
   // The table twin of the stash above — a table burst's editEl is the whole
@@ -9147,6 +10880,11 @@
       : d.editEl;
     if (!entry) { d.history.dispose(); return false; }
     entry.focus();
+    // T8: since Escape keeps the caret in the surface, focus() is usually a
+    // no-op here and raises no focusin — open the burst directly.
+    if (!currentBurst && document.activeElement === entry) {
+      if (isTable) startTableBurst(entry); else startBurst(entry);
+    }
     if (!currentBurst || currentBurst.editEl !== d.editEl) { d.history.dispose(); return false; }
     currentBurst.history.dispose();
     currentBurst.history = d.history;
@@ -9244,9 +10982,47 @@
     const state = burst.history.undo();
     if (state !== null) {
       editEl.innerHTML = state;
+      syncEmptyMark(editEl);
       placeCaretAtEnd(editEl); // best-effort — see the file-level caret-quirk note
       return;
     }
+    // v3.14.0 T1: an empty transient with nothing left to step back through
+    // locally. It wrote nothing, so the undo the user asked for is taking it
+    // away again — not the document op before it. The caret goes back where
+    // the gesture that made it was pressed (anchorCaret), else to the end of
+    // the block above. In an empty document it is the only block and stays.
+    if (burst.transient && transientSurfaceEmpty(burst.blockEl) && !transientIsOnlyBlock(burst.blockEl)) {
+      const t = transient;
+      const prev = previousBlockEl(burst.blockEl);
+      removeTransient();
+      if (t && t.anchorCaret && t.anchorCaret.surface && t.anchorCaret.surface.isConnected) {
+        t.anchorCaret.surface.focus();
+        restoreSelection(t.anchorCaret.surface, t.anchorCaret.offset, t.anchorCaret.offset);
+        return;
+      }
+      const surface = prev ? blockContentEl(prev) : null;
+      if (surface && surface.classList.contains('ed-wys-armed')) {
+        surface.focus();
+        placeCaretAtEnd(surface);
+      }
+      return;
+    }
+    // v3.14.0 T2: Enter at a block's start left an empty transient ABOVE the
+    // caret and the burst stayed where it was. With nothing left to step back
+    // through here, taking that transient away is the Enter's undo step; the
+    // caret stays put. Only in the block the Enter was pressed in (`stayEl`):
+    // a transient the user has already left behind is on its way out (its
+    // removal waits for the press that left it), and a Ctrl+Z in another
+    // block means that block's undo. MEASURED without the `stayEl` test (ER
+    // 'burst undo: … cascades to the previous commit'): Enter at the end,
+    // a click straight into the paragraph above, typing, Ctrl+Z twice — the
+    // second one took the still-present transient instead of the commit.
+    if (!burst.transient && transient && transient.byEnter && transient.stayEl === burst.blockEl &&
+        transient.el.isConnected && transientSurfaceEmpty(transient.el) &&
+        !transientIsOnlyBlock(transient.el)) {
+      removeTransient();
+      return;
+    }
     // §10-gap fix (review): if this burst is an untouched pristine insert,
     // switchAwayFrom() below will itself auto-remove the block (resolveBurst()'s
     // pristineInsert branch) — that auto-remove IS the undo the user just
@@ -9268,6 +11044,7 @@
     const state = burst.history.redo();
     if (state !== null) {
       editEl.innerHTML = state;
+      syncEmptyMark(editEl);
       placeCaretAtEnd(editEl);
       return;
     }
@@ -9317,6 +11094,19 @@
   //
   // `reason` is metadata only — createBurstHistory().snap() does not read it
   // (see lib/editor/history.js).
+  // v3.14.0 T8 (D8): a focused armed surface can be without a burst — after
+  // Escape (the caret stays), after Ctrl+S on an untouched surface — and
+  // input there was never committed (typing) or did nothing (Enter,
+  // Backspace, Delete). The next input starts the burst first. Never during
+  // a flight or a resolution (those own the surface), never in a table cell
+  // (its own burst opens on focus).
+  function ensureBurst(surface) {
+    if (currentBurst || switching || flightActive()) return;
+    if (!surface || !surface.isConnected || !surface.classList.contains('ed-wys-armed')) return;
+    if (surface.closest('.ed-wys-cell')) return;
+    startBurst(surface);
+  }
+
   function snapBurstIfActive(root, reason) {
     if (currentBurst && (currentBurst.editEl === root || currentBurst.editEl.contains(root))) {
       currentBurst.history.snap(reason);
@@ -9329,6 +11119,13 @@
   // wireBurstListeners() below), Shift+Enter inserts a <br> and snapshots
   // it, Escape reverts, Ctrl+Z/Y drive the burst-local history.
   function handleBurstKeydown(e, editEl) {
+    // v3.14.0 T2 (R6): a structural key while a failed structure is still
+    // pending re-commits that first — burst or no burst (the provisional half
+    // of a failed split has none).
+    if (pendingStructure && isStructuralKeyForRetry(e, editEl)) {
+      retryStructureThenReplay(e, editEl);
+      return;
+    }
     if (!currentBurst || currentBurst.editEl !== editEl) {
       // v2.11.1 acceptance, escape class B. This bail is reachable with the
       // surface STILL FOCUSED and still `.ed-wys-armed`: resolveBurst() nulls
@@ -9381,6 +11178,11 @@
     if (currentBurst.blockType === 'li') {
       if (handleLiKeydown(e, editEl)) return;
     }
+    // v3.14.0 T3: Backspace at a paragraph / heading / transient start, Delete
+    // at its end — join, convert or select (blockEdgeDelete()); anywhere else
+    // the browser's own deletion.
+    if ((e.key === 'Backspace' || e.key === 'Delete') &&
+        blockEdgeDelete(e, editEl, e.key === 'Backspace' ? -1 : 1)) return;
     // Task 6 — spec §3.5's other two rows. Tab is CONSUMED here: the
     // alternative is not "nothing happens", it is the browser's own focus
     // traversal walking the caret out of the document body, which is both a
@@ -9422,13 +11224,19 @@
       return;
     }
     if (e.key === 'Enter') {
-      e.preventDefault();
       if (e.shiftKey) {
+        e.preventDefault();
         snapBurstIfActive(editEl, 'br-pre');
         insertBrAtCaret();
         snapBurstIfActive(editEl, 'br');
-      } else {
+      } else if (e.ctrlKey || e.metaKey || e.altKey) {
+        // A chord is not a paragraph break: it still commits by leaving.
+        e.preventDefault();
         editEl.blur();
+      } else {
+        // v3.14.0 T2: split, or open a transient at an edge. It calls
+        // preventDefault() itself — never for an IME's confirming Enter.
+        paragraphEnter(e, editEl).catch(structuralKeyFailed);
       }
       return;
     }
@@ -9609,12 +11417,18 @@
   // here, so that handler's `if (currentBurst) return;` returns.
   function armProvisionalLi(newLi) {
     const textEl = liTextEl(newLi);
-    if (!textEl) return;
-    textEl.setAttribute('contenteditable', 'true');
-    textEl.classList.add('ed-wys-armed');
-    textEl.focus();
+    if (textEl) armProvisionalSurface(textEl);
+  }
+  // v3.14.0 T2: the same two writes for any provisional surface — the li's
+  // `.ed-li-text`, or the <p> a paragraph split builds — then focus and the
+  // caret at its start, where the commit's own focusBlockAtLine() puts it
+  // again once the render lands.
+  function armProvisionalSurface(el) {
+    el.setAttribute('contenteditable', 'true');
+    el.classList.add('ed-wys-armed');
+    el.focus();
     const range = document.createRange();
-    range.selectNodeContents(textEl);
+    range.selectNodeContents(el);
     range.collapse(true);
     const sel = window.getSelection();
     sel.removeAllRanges();
@@ -10255,18 +12069,15 @@
 
   // Row 3, top-level press: spec §4 — "at top level the next press converts
   // the block to a paragraph". Markdown cannot persist an EMPTY paragraph, so
-  // this reuses the repo's existing §10 pristine-insert machinery instead of
-  // inventing a second empty-block representation: remove the li (commit #1,
-  // the run re-serialize), then insertBlockBelow() the paragraph skeleton
-  // anchored to whatever block now PRECEDES the removal point (commit #2). The
-  // user lands in a focused provisional paragraph that becomes real the moment
-  // anything is typed into it, and self-removes at zero net undo cost if
-  // abandoned (discardPristineInsert()).
-  //
-  // RULING F-J: this is therefore the ONE structural key press that is not a
-  // single undo op. Observed granularity (asserted in
-  // test/editor-client-runtime.test.js): Ctrl+Z #1 removes the provisional
-  // paragraph without popping the stack, Ctrl+Z #2 reverts the li removal.
+  // the li is removed (ONE op, the run re-serialize) and a transient paragraph
+  // takes its place, after whatever block now PRECEDES the removal point (the
+  // end of its subtree when that is a li), or at the top of the document. The
+  // transient writes nothing until something is typed into it.
+  //
+  // v3.14.0 T1 supersedes RULING F-J's two-step granularity (the ZWSP
+  // paragraph was a second op): the key press is one undo op, and Ctrl+Z in
+  // the still-empty transient takes the transient away without touching the
+  // stack (burstUndo()).
   async function convertEmptyTopLevelLiToParagraph(runEls, li) {
     // Both captured BEFORE the mutation. The range, because removing the run's
     // last item leaves commitListStructure() nothing to derive it from. The
@@ -10309,20 +12120,136 @@
     const ok = await commitListStructure(survivors, null, false,
       { presetRange: range, carryOver: bystanderCarryOver(survivors) });
     if (!ok) return;
-    // Nothing precedes the removal point (the list opened the document):
-    // commitBlockInsertion() can only insert BELOW an existing block, so the
-    // paragraph step is skipped. The li removal still stands — no content is
-    // lost, the user just has to type where they want the paragraph.
-    if (!precedingBlock) return;
+    // Nothing precedes the removal point (the list opened the document): the
+    // transient opens the document, and its commit lands at the top
+    // (commitInsertionAt() with no anchor).
+    if (!precedingBlock) { createTransient(null, { focus: true }); return; }
     const anchorEl = blockElAtLine(precedingBlock.startLine);
     if (!anchorEl) return;
-    await insertBlockBelow(anchorEl, 'paragraph');
+    createTransient(subtreeEndOf(anchorEl), { focus: true });
+  }
+
+  function liBackspaceAtStart(e, editEl) {
+    if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.isComposing || e.keyCode === 229) return false;
+    const place = caretPlace(editEl, true);
+    if (place !== 'start' && place !== 'empty') return false;
+    const li = closestLiBlock(editEl);
+    if (!li) return false;
+    if (!listRunOf(li).length) return false;
+    e.preventDefault();
+    liBackspaceStructure(li).catch(structuralKeyFailed);
+    return true;
+  }
+  // R29 (fix round 1, I1): typing still in the item is committed as its own
+  // op first (D4 wins over D14's single step), then the structure op runs on
+  // the item as it now stands. Measured before: type X, Home, Backspace on a
+  // nested item — one Ctrl+Z took back the X and the outdent together. Keys
+  // typed while the typing op renders are held by the guard and replay after
+  // the structure op (R7's shape).
+  async function liBackspaceStructure(li) {
+    const burst = currentBurst;
+    if (burst && burst.blockType === 'li' && burst.blockEl === li &&
+        burstBaselineHtml(burst.editEl) !== burst.original) {
+      const rec = blockRecOf(li);
+      if (!rec) return;
+      if (!(await switchAwayFrom())) return;
+      li = li.isConnected ? li : blockElAtLine(rec.startLine);
+      if (!li) return;
+    }
+    const run = listRunOf(li);
+    if (!run.length) return;
+    if ((Number(li.getAttribute('data-indent')) || 0) > 0) {
+      // Final review I1: the caret stays at the start of the item's text, as
+      // in Notion, so a second Backspace converts it instead of deleting its
+      // last character. Tab and Shift+Tab keep the caret at the end.
+      liIndentStructure(li, run, true, false);
+      return;
+    }
+    if (liOwnTextIsBlank(li)) {
+      if (!listRunSupportsStructuralEdit(run, li)) { refuseStructuralListEdit(); return; }
+      // RULING F-Q, as for Enter: an empty item that owns a sublist is not
+      // removed from over its children.
+      if (liBlockHasChildren(li)) return;
+      await convertEmptyTopLevelLiToParagraph(run, li);
+      return;
+    }
+    await convertBlockViaMenu(li, 'text', { caretToEnd: false });
+  }
+
+  // Tab / Shift+Tab on a list item (and, v3.14.0 T3, Backspace at the start
+  // of a nested one, which is Shift+Tab). Extracted unchanged from
+  // handleLiKeydown(); `outdent` stands for the Shift key. `caretToEnd`
+  // (default true, Tab's) is where the caret lands in the item afterwards;
+  // Backspace passes false, the start of its text.
+  function liIndentStructure(li, run, outdent, caretToEnd) {
+    // `columnOnly`: an indent change rewrites nothing but leading columns, so
+    // a hard-wrapped item is allowed to be the target here — see
+    // listRunSupportsStructuralEdit()'s deviation note for the measurement.
+    if (!listRunSupportsStructuralEdit(run, li, { columnOnly: true })) {
+      refuseStructuralListEdit(); return true;
+    }
+    // Tab (spec §3.5): indentListItem() moves ONLY the caret item — its
+    // children keep their indent and become its siblings. Shift+Tab:
+    // outdentListItem() raises it one level, takes its own subtree with it,
+    // and adopts its former following same-level siblings. Both return false
+    // at their respective boundary (no previous sibling / already top level),
+    // which is a complete no-op — nothing mutated, nothing committed, file
+    // byte-identical.
+    const oldIndent = Number(li.getAttribute('data-indent')) || 0;
+    // INERT here: indentListItem()/outdentListItem() are attribute-only in
+    // this flat model (setBlockIndent() on `li` and its subtree — see the
+    // note on outdentListItem() further down this function) and never
+    // detach the focused node, so the synchronous blur/focusout this span
+    // exists to catch never fires, whether or not the flag is set.
+    // Measured: primed a burst on `li`, ran this mutation, and no
+    // focusout fired — `document.activeElement` stayed put and the node
+    // never left the document. Kept for uniformity with the load-bearing
+    // span in convertEmptyTopLevelLiToParagraph() above, not because this
+    // one guards anything measured.
+    const changed = mutateListRun(() => {
+      if (!(outdent ? outdentListItem(li) : indentListItem(li))) return false;
+      // v3.0.1: `run` above is a PRE-mutation snapshot, captured while `li`
+      // still had its OLD indent. That is fine for outdentListItem() — the
+      // clamp's model rereads every element's CURRENT data-indent off the
+      // DOM, so it self-corrects regardless of which elements the snapshot
+      // names — but indentListItem() can now move a rule-(d) list-start
+      // item (a bullet directly below an ordered item, say) whose own
+      // pre-mutation run is `[li]` alone: nothing shallower ever preceded
+      // it, because runBlocksOf() stops at a list-start by design. With no
+      // anchor IN the span, applyIndentClamp()'s rule 1 has nothing to
+      // bound the indent this call just wrote against, and clamps it
+      // straight back to 0 — silently undoing the write. A FRESH
+      // listRunOf(li) call here — taken after the write above — walks back
+      // from li's NEW indent and finds the real parent, exactly like the
+      // post-mutation `run = listRunOf(li)` a few lines below (the COMMIT
+      // span) already does; using the same fresh call for the clamp keeps
+      // the two consistent. Provably identical to the old stale `run` for
+      // every case where li was never a list-start (listRunOf() slices by
+      // INDEX RANGE, and neither the range's start/end index nor the
+      // elements between them shift when only li's own indent changes).
+      applyIndentClamp(listRunOf(li), li, oldIndent);
+      return true;
+    });
+    if (!changed) return true;
+    run = listRunOf(li);
+    // Column-only: nothing's CONTENT moved, so every block in the span —
+    // the target included — is a bystander whose source bytes must come
+    // back untouched. Built once and shared with runLineOfBlock() below,
+    // which indexes into the lines this very map decides.
+    const carry = bystanderCarryOver(run, null);
+    commitListStructure(run, runLineOfBlock(run, li, carry), caretToEnd !== false, { carryOver: carry });
+    return true;
   }
 
   // Returns true when the key was CONSUMED (Enter/Tab, incl. their no-op
   // outcomes); false lets handleBurstKeydown()'s shared Escape / Ctrl+Z /
   // Ctrl+Y branches run unchanged.
   function handleLiKeydown(e, editEl) {
+    // v3.14.0 T3 (D14): Backspace at an item's start. Nested: Shift+Tab's
+    // outdent. Top level with text: ⠿ 轉換成 文字. Top level and empty: the
+    // item goes and a transient paragraph takes its place (Enter's row-3
+    // path). Anywhere else the browser's own deletion.
+    if (e.key === 'Backspace') return liBackspaceAtStart(e, editEl);
     if (e.key !== 'Enter' && e.key !== 'Tab') return false;
     e.preventDefault();
     // T21 item 2, the li half — see handleBurstKeydown()'s Tab branch. Ahead
@@ -10351,65 +12278,7 @@
     let run = listRunOf(li);
     if (!run.length) return true;
 
-    if (e.key === 'Tab') {
-      // `columnOnly`: an indent change rewrites nothing but leading columns, so
-      // a hard-wrapped item is allowed to be the target here — see
-      // listRunSupportsStructuralEdit()'s deviation note for the measurement.
-      if (!listRunSupportsStructuralEdit(run, li, { columnOnly: true })) {
-        refuseStructuralListEdit(); return true;
-      }
-      // Tab (spec §3.5): indentListItem() moves ONLY the caret item — its
-      // children keep their indent and become its siblings. Shift+Tab:
-      // outdentListItem() raises it one level, takes its own subtree with it,
-      // and adopts its former following same-level siblings. Both return false
-      // at their respective boundary (no previous sibling / already top level),
-      // which is a complete no-op — nothing mutated, nothing committed, file
-      // byte-identical.
-      const oldIndent = Number(li.getAttribute('data-indent')) || 0;
-      // INERT here: indentListItem()/outdentListItem() are attribute-only in
-      // this flat model (setBlockIndent() on `li` and its subtree — see the
-      // note on outdentListItem() further down this function) and never
-      // detach the focused node, so the synchronous blur/focusout this span
-      // exists to catch never fires, whether or not the flag is set.
-      // Measured: primed a burst on `li`, ran this mutation, and no
-      // focusout fired — `document.activeElement` stayed put and the node
-      // never left the document. Kept for uniformity with the load-bearing
-      // span in convertEmptyTopLevelLiToParagraph() above, not because this
-      // one guards anything measured.
-      const changed = mutateListRun(() => {
-        if (!(e.shiftKey ? outdentListItem(li) : indentListItem(li))) return false;
-        // v3.0.1: `run` above is a PRE-mutation snapshot, captured while `li`
-        // still had its OLD indent. That is fine for outdentListItem() — the
-        // clamp's model rereads every element's CURRENT data-indent off the
-        // DOM, so it self-corrects regardless of which elements the snapshot
-        // names — but indentListItem() can now move a rule-(d) list-start
-        // item (a bullet directly below an ordered item, say) whose own
-        // pre-mutation run is `[li]` alone: nothing shallower ever preceded
-        // it, because runBlocksOf() stops at a list-start by design. With no
-        // anchor IN the span, applyIndentClamp()'s rule 1 has nothing to
-        // bound the indent this call just wrote against, and clamps it
-        // straight back to 0 — silently undoing the write. A FRESH
-        // listRunOf(li) call here — taken after the write above — walks back
-        // from li's NEW indent and finds the real parent, exactly like the
-        // post-mutation `run = listRunOf(li)` a few lines below (the COMMIT
-        // span) already does; using the same fresh call for the clamp keeps
-        // the two consistent. Provably identical to the old stale `run` for
-        // every case where li was never a list-start (listRunOf() slices by
-        // INDEX RANGE, and neither the range's start/end index nor the
-        // elements between them shift when only li's own indent changes).
-        applyIndentClamp(listRunOf(li), li, oldIndent);
-        return true;
-      });
-      if (!changed) return true;
-      run = listRunOf(li);
-      // Column-only: nothing's CONTENT moved, so every block in the span —
-      // the target included — is a bystander whose source bytes must come
-      // back untouched. Built once and shared with runLineOfBlock() below,
-      // which indexes into the lines this very map decides.
-      const carry = bystanderCarryOver(run, null);
-      commitListStructure(run, runLineOfBlock(run, li, carry), true, { carryOver: carry });
-      return true;
-    }
+    if (e.key === 'Tab') return liIndentStructure(li, run, e.shiftKey);
 
     // Enter.
     if (selectionSpansMultipleListItems()) {
@@ -11442,8 +13311,27 @@
       while (n && !n.classList.contains('ed-block')) n = step(n);
       return n;
     };
+    // v3.14.0 T5: leaving a transient. Empty: it wrote nothing, so it is
+    // removed and the walk lands on the real neighbour — no render. With
+    // text: it is committed first (commitLinesAtTransient() records
+    // transientLandedLine) and the walk goes on from the paragraph it became.
+    if (isTransient(fromBlockEl)) {
+      if (transientSurfaceEmpty(fromBlockEl)) {
+        const target = nextBlock(fromBlockEl);
+        if (!target) return;
+        if (!transientIsOnlyBlock(fromBlockEl)) removeTransient();
+        if (x !== null) arrowGoalX = x;
+        arrowLandOn(target, delta, x !== null ? x : arrowGoalX);
+        return;
+      }
+      transientLandedLine = null;
+      if (!(await switchAwayFrom()) || transientLandedLine === null) return;
+      fromBlockEl = blockElAtLine(transientLandedLine);
+      if (!fromBlockEl) return;
+    }
     let dest = nextBlock(fromBlockEl);
     if (!dest) return;
+    const destWasTransient = isTransient(dest);
     const srcStartLine = (blockRecOf(fromBlockEl) || {}).startLine;
     const destIdentity = captureBlockIdentity(dest);
     const ok = await switchAwayFrom();
@@ -11453,7 +13341,9 @@
       const liveSrc = srcRec
         ? document.querySelector('.ed-block[data-block-id="' + srcRec.id + '"]') : null;
       dest = (liveSrc && nextBlock(liveSrc)) || reresolveBlockEl(destIdentity);
-      if (!dest) { showError(DROPPED_GESTURE_MESSAGE); return; }
+      // A transient destination is gone with the render that committed the
+      // source; there is nothing to re-resolve and nothing was dropped.
+      if (!dest) { if (!destWasTransient) showError(DROPPED_GESTURE_MESSAGE); return; }
     }
     if (x !== null) arrowGoalX = x;
     arrowLandOn(dest, delta, x !== null ? x : arrowGoalX);
@@ -16564,6 +18454,9 @@
       // expression setDirty() paints the title dot from — not a second copy
       // of it.
       dirty: documentIsDirty(),
+      // v3.14.0 T4 (D15): 'empty' | 'text' on a transient paragraph, else null.
+      transient: blockEl && isTransient(blockEl)
+        ? (transientSurfaceEmpty(blockEl) ? 'empty' : 'text') : null,
     };
   }
 
@@ -16944,6 +18837,12 @@
   }
 
   async function runToolbarAction(id, btnEl, viaKeyboard) {
+    // R32 audit: a toolbar action can write `lines` without a resolution
+    // first (indentCaretLi() commits a list structure directly), so a pending
+    // structure is re-committed before any of them runs; if that fails the
+    // press is dropped (the error card stays).
+    if (pendingStructure && !(await retryPendingStructure())) return;
+    if (await toolbarOnTransient(id, liveToolbarBlock())) return;
     const blockEl = liveToolbarBlock();
     switch (id) {
       // v3.4.0 §3: saveViaToolbar() — not save() directly. See its own
@@ -16980,8 +18879,8 @@
       case 'indent': return indentCaretLi(1);
       case 'table': return blockEl ? insertBlockBelow(blockEl, 'table') : undefined;
       case 'line': return blockEl ? insertBlockBelow(blockEl, 'line') : undefined;
-      case 'insert-after': return blockEl ? insertBlockBelow(blockEl, 'paragraph') : undefined;
-      case 'insert-before': return blockEl ? insertBlockAbove(blockEl) : undefined;
+      case 'insert-after': return blockEl ? insertTransientBelow(blockEl) : undefined;
+      case 'insert-before': return blockEl ? insertTransientAbove(blockEl) : undefined;
       // backlog #6: imageViaToolbar() — not pickAndInsertImage() directly.
       // See its own comment (shared with undoViaToolbar()/redoViaToolbar())
       // for the caret rescue.
@@ -17095,6 +18994,7 @@
   // gate (convert-md.js's 'h1'..'h6' targets already carry the level), and a
   // heading gets a delta computed against its own current depth.
   async function applyHeadingLevel(n) {
+    if (await toolbarOnTransient('h' + n, liveToolbarBlock())) return;
     const blockEl = liveToolbarBlock();
     if (!blockEl) return;
     if (blockEl.getAttribute('data-block-type') !== 'heading') {
@@ -17109,79 +19009,12 @@
   }
 
   // ── insert above ───────────────────────────────────────────────────────
-  // commitBlockInsertion() only ever inserts AFTER a block's range, so
-  // "insert above" is expressed the way this file already expresses it (see
-  // convertEmptyTopLevelLiToParagraph()'s own preceding-block lookup):
-  // anchor on the block before this one. That keeps one insertion path and
-  // one set of gates rather than teaching the pure core a direction.
-  async function insertBlockAbove(blockEl) {
-    const rec = blockRecOf(blockEl);
-    if (!rec) return;
-    const preceding = blocks
-      .filter((b) => b.id !== rec.id && b.endLine < rec.startLine && b.endLine >= b.startLine)
-      .pop();
-    if (preceding) {
-      const anchorEl = blockElAtLine(preceding.startLine);
-      if (anchorEl) { await insertBlockBelow(anchorEl, 'paragraph'); return; }
-    }
-    // Nothing above to anchor on — see insertParagraphAtTop(). Refusing here
-    // instead would leave the document's FIRST block permanently impossible
-    // to precede: the ⠿ and ＋ menus both insert below, so this button is the
-    // only affordance that reaches that position at all.
-    await insertParagraphAtTop(blockEl);
-  }
-
-  // The document's first block has no predecessor to insert BELOW, and
-  // commitBlockInsertion() only ever inserts after a block's range. Rather
-  // than teach the pure core a direction (a change under byte-stability and
-  // roundtrip fixtures), the insert is expressed as a REPLACE of that
-  // block's own first source line by [skeleton, '', that same line] — the
-  // same commitRangeEdit()/replaceLines() pipeline as every other edit,
-  // therefore one undo op, and no new primitive.
-  //
-  // The switchAwayFrom() + re-resolve preamble is insertBlockBelow()'s,
-  // for its reasons: the resolution can commit a dirty burst, whose
-  // rerenderAll() detaches the very node this was called with.
-  async function insertParagraphAtTop(blockEl) {
-    const identity = captureBlockIdentity(blockEl);
-    const selfSession = ownsOpenSession(blockEl);
-    const ok = await switchAwayFrom();
-    if (!ok) return;
-    let liveBlockEl = blockEl;
-    if (!document.body.contains(blockEl)) {
-      liveBlockEl = reresolveBlockEl(identity) ||
-        (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
-      if (!liveBlockEl) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
-    }
-    const rec = blockRecOf(liveBlockEl);
-    // A block that owns no source line has an inverted range, and there is
-    // no line to splice in front of.
-    if (!rec || rec.endLine < rec.startLine) {
-      refuseStructuralListEdit(noSourceLineInsertMessageFor(liveBlockEl));
-      return;
-    }
-    const at = rec.startLine;
-    const newText = BLOCK_SKELETONS.paragraph.concat(['', lines[at - 1]]).join('\n');
-    const result = commitRangeEdit({ lines, blocks, stack }, at, at, newText);
-    if (result.op === null) return;
-    const prevLines = lines;
-    lines = result.lines;
-    const editRange = result.op
-      ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
-          endLine: Math.max(result.op.startLine - 1, result.op.endLine),
-          delta: result.op.after.length - result.op.before.length }
-      : undefined;
-    const okRender = await safeRerenderAll(editRange);
-    if (!okRender) {
-      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
-      return;
-    }
-    // The new paragraph starts exactly where the old first line did — same
-    // pristine + focus contract insertBlockBelow() gives a skeleton insert.
-    const target = blocks.find((b) => b.startLine === at);
-    if (target) pristineInsert = { blockId: target.id };
-    await focusInsertedBlock(at, 'paragraph');
-  }
+  // v3.14.0 T1: 在上方插入 opens a transient above the block — see
+  // insertTransientAbove(). It used to write a ZWSP paragraph, through
+  // insertBlockBelow() on the preceding block or, for the document's first
+  // block, a splice over that block's own first line; a transient needs
+  // neither, because it writes nothing until it is committed, and its commit
+  // (commitInsertionAt()) already covers the top of the document.
 
   // ── 大綱 ───────────────────────────────────────────────────────────────
   // TWO attributes, chosen by viewport, and that is not an accident.
@@ -17390,6 +19223,12 @@
       if (i > 0) newLines.push('');
       newLines.push('![](' + markdownImageDest(p) + ')');
     });
+    // v3.14.0 T4: a transient has no source line to insert below; the images
+    // replace it (after its own text, if it has any), as one op.
+    if (isTransient(target)) {
+      await commitPastedLinesAtTransient(target, newLines);
+      return;
+    }
     await insertBlockBelow(target, 'paragraph', { lines: newLines });
   }
 
@@ -17623,7 +19462,14 @@
       // serializeBlocks()'s existing gates, instead of arriving as a pile of
       // foreign nodes the serializer would have to make sense of afterwards.
       const pastedLines = md.split('\n');
-      insertBlockBelow(editEl.closest('.ed-block'), 'paragraph',
+      // v3.14.0 T5: in a transient the pasted blocks replace it (after its
+      // own text, if any) as one op.
+      const hostBlock = editEl.closest('.ed-block');
+      if (hostBlock && isTransient(hostBlock)) {
+        commitPastedLinesAtTransient(hostBlock, pastedLines);
+        return;
+      }
+      insertBlockBelow(hostBlock, 'paragraph',
         { lines: pastedLines, tight: pasteIsAllListLines(pastedLines) });
       return;
     }
@@ -18071,6 +19917,14 @@
         dropHeldTyping();
         return;
       }
+      // v3.14.0 T7 (D9): Ctrl/Cmd+B/I/U is held too and replays as the same
+      // native command — let through, it formatted DOM the render replaced.
+      const formatCommand = flightSurface ? formatCommandForKey(e) : null;
+      if (formatCommand) {
+        e.preventDefault();
+        holdFlightEntry(flightSurface, { kind: 'format', command: formatCommand });
+        return;
+      }
       if (flightSurface && flightHoldsKey(e)) {
         e.preventDefault();
         holdFlightEntry(flightSurface, { kind: 'key', key: e.key, shiftKey: e.shiftKey,
@@ -18119,6 +19973,8 @@
     // it either.
     const wysArmedEl = e.target && e.target.closest && e.target.closest('.ed-wys-armed');
     if (wysArmedEl && burstOwnsKey) {
+      // T8: Enter / Backspace / Delete need the burst their handlers act in.
+      if (!currentBurst && (e.key === 'Enter' || e.key === 'Backspace' || e.key === 'Delete')) ensureBurst(wysArmedEl);
       handleBurstKeydown(e, wysArmedEl);
       return;
     }
@@ -18318,6 +20174,15 @@
   // input/paste handling (class 'ed-wys-cell') is a separate branch at the
   // top of each listener below — see handleTableCellFocusIn() above.
   document.addEventListener('focusin', async (e) => {
+    // v3.14.0 T2 (D7): focus going into any surface while a failed structure
+    // is pending re-commits it first. Opening a burst over its range would
+    // commit the left half over the whole block, and a commit anywhere else
+    // renders and drops the screen half. The wait below then re-resolves this
+    // surface across that render like any other resolution's.
+    if (pendingStructure && !switching &&
+        e.target && e.target.closest && e.target.closest('.ed-wys-armed, .ed-wys-cell')) {
+      switchAwayFrom();
+    }
     const cellEl = e.target && e.target.closest && e.target.closest('.ed-wys-cell');
     if (cellEl) { await handleTableCellFocusIn(cellEl); scheduleFlightFlush(); return; }
     const editEl = e.target && e.target.closest && e.target.closest('.ed-wys-armed');
@@ -18329,7 +20194,22 @@
     // be resolving from the focusout that just preceded this focusin — see
     // switchAwayFrom()'s single-flight `switching`. Await it before
     // starting a new burst so the two never race a concurrent commit.
-    if (switching) await switching;
+    // v3.14.0 T1 fix round 1 (I1): the wait is tracked as a flight tag, so a
+    // render that lands meanwhile re-points it at the block that now holds
+    // the same source. Measured before: a press below a transient whose
+    // commit inserted lines re-resolved by the OLD id and put the caret, and
+    // the keys typed after the press, into the transient's new paragraph.
+    // v3.14.0 T2: the provisional half of a pending split is tagged too — it
+    // has no id, and its tag re-points through the retry's `provisional` line.
+    const pendingHalf = !!(pendingStructure && pendingStructure.surfaces.indexOf(editEl) !== -1);
+    const waitTag = switching && (blockId !== null || pendingHalf)
+      ? { surface: editEl, blockId, cellIndex: null, anchor: null, focus: null } : null;
+    if (waitTag) focusinWaitTags.push(waitTag);
+    try {
+      if (switching) await switching;
+    } finally {
+      if (waitTag) focusinWaitTags.splice(focusinWaitTags.indexOf(waitTag), 1);
+    }
     // v3.13.1 T1 fix round 2: focus may have moved on while this waited — an
     // arrow walk lands on the NEXT block from inside that same resolution, and
     // its own focusin is queued behind this one. Starting a burst here would
@@ -18348,7 +20228,12 @@
       // target. Re-resolve the equivalent LIVE node by block id and move
       // focus there for real — that re-enters this same handler
       // synchronously (switching is null by now), which starts the burst.
-      const liveBlockEl = blockId != null ? document.querySelector('.ed-block[data-block-id="' + blockId + '"]') : null;
+      // A tag no landed render re-pointed (a render outside safeRerenderAll())
+      // still names the detached surface: the id lookup is all there is then.
+      const remapped = waitTag && waitTag.surface !== editEl;
+      const liveBlockEl = remapped
+        ? (waitTag.surface && waitTag.surface.isConnected ? waitTag.surface.closest('.ed-block') : null)
+        : (blockId != null ? document.querySelector('.ed-block[data-block-id="' + blockId + '"]') : null);
       liveEditEl = liveBlockEl ? blockContentEl(liveBlockEl) : null;
       if (!liveEditEl || !liveEditEl.classList.contains('ed-wys-armed')) return;
       liveEditEl.focus();
@@ -18578,6 +20463,37 @@
     setTimeout(() => { composedHeld = null; }, 0);
   }, true);
 
+  // v3.14.0 T8: input into a focused armed surface that has no burst starts
+  // one first, before the DOM changes, so the burst's baseline is the
+  // surface as it was (ensureBurst()). Final review I3: a native format
+  // chord (Ctrl+B / I / U, NATIVE_FORMAT_INPUT_TYPES) and a drop are input
+  // too — measured before: Escape, select, Ctrl+B showed the bold and the
+  // file kept the plain word. This listener is registered ahead of the
+  // `native-format-pre` one below (both capture phase on document, so they
+  // run in that order), so the burst exists when that one snaps it.
+  document.addEventListener('beforeinput', (e) => {
+    if (e.defaultPrevented) return;
+    const t = e.inputType;
+    if (t !== 'insertText' && t !== 'insertReplacementText' && t !== 'insertFromPaste' &&
+        t !== 'insertLineBreak' && t !== 'insertParagraph' && !/^delete/.test(t) &&
+        !NATIVE_FORMAT_INPUT_TYPES.has(t) && t !== 'insertFromDrop') return;
+    const surface = e.target && e.target.closest ? e.target.closest('.ed-wys-armed') : null;
+    if (surface) ensureBurst(surface);
+  }, true);
+  // Fix round 1 (I3, R35): an IME composition is input too. Its text arrives
+  // as insertCompositionText, which the list above leaves out, so composed
+  // text after Escape or after Ctrl+S on an untouched surface was never
+  // committed (measured, Chromium via CDP: X, Escape, IME 你 → file
+  // `Alpha.`). The burst opens at compositionstart, before the composition
+  // touches the DOM, so its baseline is the surface as it was; it only opens
+  // a burst, and commits nothing mid-composition. ensureBurst() never opens a
+  // second one, and holds off during a flight (the flight guard owns the
+  // composition then).
+  document.addEventListener('compositionstart', (e) => {
+    const surface = e.target && e.target.closest ? e.target.closest('.ed-wys-armed') : null;
+    if (surface) ensureBurst(surface);
+  }, true);
+
   // Capture phase, matching the phase the ordering above was measured in.
   document.addEventListener('beforeinput', (e) => {
     if (!NATIVE_FORMAT_INPUT_TYPES.has(e.inputType)) return;
@@ -20432,4 +22348,9 @@
   // selToolbar, …) is initialised and the bar's first deriveState() sees the
   // armed document rather than an empty one.
   mountToolbar();
+  // v3.14.0 T4: after the bar exists, so its focusin tracking sees the
+  // empty document's transient and reports a paragraph.
+  wireEmptyMark();
+  wireClickBelow();
+  ensureEmptyDocTransient();
 })();