@helping-ai-workflow/md2doc 3.13.0 → 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
@@ -1110,7 +1185,9 @@
   let switching = null;
   function switchAwayFrom() {
     if (switching) return switching;
-    switching = resolveOpenSession().finally(() => { switching = null; });
+    // v3.13.1 T1: a held-key replay that waited on this resolution resumes
+    // once it is over (scheduleFlightFlush() is a no-op with nothing held).
+    switching = resolveOpenSession().finally(() => { switching = null; scheduleFlightFlush(); });
     return switching;
   }
 
@@ -1126,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;
@@ -1190,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() {
@@ -1685,6 +1769,11 @@
     // through explicitly. Passed positionally here and through
     // applyRenderResult() rather than folded into `j` (which is the
     // server's response payload, not render-context the CALLER derived).
+    // v3.13.1 R11: the selection right before the DOM is replaced — a click,
+    // drag or double-click into another block during this request has
+    // already put it there. The focusin re-resolve and the flight replay
+    // restore it, anchor and focus both.
+    lastRenderSel = selectionSnapshotIn(activeFlightSurface());
     return applyRenderResult(j, editRange, scrollY, declaredRange);
   }
 
@@ -1869,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 放上畫面那一步，警告的是使用
@@ -2521,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
@@ -2664,14 +2759,531 @@
   // refusal, and commitListStructure()'s no-range exit) pass nothing, which
   // falls back to a full re-render by contract — patch can only compare
   // renderer output, never DOM the user has already touched.
+  //
+  // v3.13.1 T1: every render is also a "commit in flight" for the input guard
+  // below — see `commitFlight`. A render that lands re-points every held
+  // entry's tag at the surface that now holds the same source.
   async function safeRerenderAll(editRange) {
+    const blocksBefore = blocks;
+    const lineMap = pendingFlightLineMap;
+    pendingFlightLineMap = null;
+    beginCommitFlight();
+    let ok = false;
     try {
-      return await rerenderAll(editRange);
+      ok = await rerenderAll(editRange);
+      return ok;
     } catch (e) {
       showError('這次修改沒有套用：發生未預期的錯誤（' + describeFailure(e) +
         '）。文件維持修改前的樣子。', null, null);
       return false;
+    } finally {
+      if (ok) reanchorFlightBuffer(blocksBefore, editRange, lineMap);
+      // A failed render: nothing places focus afterwards (commitListStructure()
+      // skips its focusBlockAtLine(), and a failed blur-commit refocuses the
+      // block it could not commit), so the opening run replays where it was
+      // typed. Measured before round 3: edit A, click B@5, `ZZ`, render 500 —
+      // `ZZ` went to the start of A.
+      else pinFirstFlightRun(null);
+      endCommitFlight();
+    }
+  }
+
+  // ── v3.13.1 T1: the commit-in-flight input guard ──────────────────────
+  // A commit awaits /api/render and then rebuilds the surfaces it covers from
+  // `lines`. Anything typed into a surface while that request is out lands in
+  // DOM the render is about to throw away. Measured before this (audit
+  // 2026-10-10): Enter then an immediate `type('new')` in a tight list lost
+  // every character in Chromium and wrote an extra empty `-` item; with the
+  // render held 800 ms, 100% loss in both engines.
+  //
+  // While a flight is active (flightActive(): a commit in flight, or held
+  // entries still waiting to replay), what is typed into an armed surface is held in
+  // `flightBuffer` instead of reaching the DOM — text, paste, and the keys
+  // that edit or move: Enter, Tab, Backspace/Delete (and their word/line
+  // chords), arrows, Home/End. Escape drops everything held (R12: Escape
+  // means "throw away what I have not committed", in flight or not). Once
+  // the render has landed and its caller has placed focus, the entries are
+  // replayed in order, each through the path the live input would have taken
+  // (ruling R13): text through the browser's own insertText (which replaces a
+  // selection and rebalances whitespace; insertTextAtCaret() is the fallback),
+  // paste through routePaste(), keys as a keydown through the
+  // document handler — so ↑/↓ can still cross blocks and a table cell still
+  // owns its keys — and, when no handler claims the key, its native default
+  // (execCommand deletion, Selection.modify movement).
+  //
+  // WHERE an entry replays (fix rounds 1-3):
+  //  * A "continuation" entry (pos === null) replays at the selection the
+  //    replay has reached — wherever focus is once the caller placed it, or
+  //    wherever an earlier replayed key moved it (a held ArrowDown that walks
+  //    to the next block takes the keys typed after it there). A held key
+  //    never moves the DOM selection; a pointer press does, so the press
+  //    first PINS the run of continuation entries that opened the flight to
+  //    the selection it is about to move away from (pinFirstFlightRun(); a
+  //    failed render pins it too, since then no caller places focus). Every
+  //    other run already starts at a positioned entry. Measured before round
+  //    3: click B@5, `xy`, click Omega, `Z` replayed `xy` at B's start.
+  //  * 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. 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,
+  //    shifted by the commit's line delta when it lay below the edited range.
+  //    Measured before round 2: Enter, `ab`, click `charlie`, `Z` saved
+  //    `- abZ` with charlie untouched.
+  //  * A pointer press during the flight with nothing typed after it becomes
+  //    a { kind: 'focus' } entry, so the click is not lost to the commit's
+  //    own focusBlockAtLine().
+  //
+  // A failed render keeps the buffer too: rerenderAll() leaves `.content`
+  // untouched on failure, every surface is still connected, and the replay
+  // lands where it was typed.
+  let commitFlight = 0;
+  const flightBuffer = [];
+  // A pointer press into a surface during a flight: the next held entry is
+  // positioned (see above).
+  let flightSelMoved = false;
+  // Set while an entry replays: the replay's own keydown / insertText must
+  // not be held again.
+  let flightReplaying = false;
+  function flightActive() {
+    return !flightReplaying && (commitFlight > 0 || flightBuffer.length > 0);
+  }
+  // The selection right before the latest render replaced the DOM (R11).
+  let lastRenderSel = null;
+  // Where continuation entries go when the render took focus away and no
+  // caller put it anywhere (e.g. a Ctrl+S commit of the focused block).
+  let flightFallback = null;
+  // commitListStructure() -> safeRerenderAll(): the run's line map.
+  let pendingFlightLineMap = null;
+  const FLIGHT_DROPPED_MESSAGE = '重新整理期間打的字沒有地方放，已略過';
+
+  function beginCommitFlight() {
+    commitFlight++;
+  }
+
+  // Not a synchronous decrement. The caller's continuation after
+  // `await safeRerenderAll(...)` — focusBlockAtLine(), an arrow walk's
+  // landing — is a microtask, so it runs before this timer and focus is
+  // placed before the replay. Keys that arrive between the render landing
+  // and the timer are still held, behind the earlier ones.
+  function endCommitFlight() {
+    setTimeout(() => {
+      commitFlight--;
+      if (!commitFlight) flushFlightBuffer();
+    }, 0);
+  }
+
+  // A replay that had to wait for a focus change resumes from here (the
+  // focusin handlers call it once their burst is open).
+  function scheduleFlightFlush() {
+    if (flightBuffer.length && !commitFlight) setTimeout(flushFlightBuffer, 0);
+  }
+
+  function flightSurfaceOf(node) {
+    const el = node && (node.nodeType === 1 ? node : node.parentElement);
+    return el && el.closest ? el.closest('.ed-wys-armed, .ed-wys-cell') : null;
+  }
+  function activeFlightSurface() {
+    return flightSurfaceOf(document.activeElement);
+  }
+
+  // Selection points as character offsets inside a surface, counted over
+  // text nodes only — the same count pointInSurface() walks back.
+  function offsetInSurface(surface, node, offset) {
+    const r = document.createRange();
+    r.selectNodeContents(surface);
+    r.setEnd(node, offset);
+    return r.toString().length;
+  }
+  function pointInSurface(surface, offset) {
+    let left = offset;
+    let lastText = null;
+    const walker = document.createTreeWalker(surface, NodeFilter.SHOW_TEXT);
+    for (let t = walker.nextNode(); t; t = walker.nextNode()) {
+      if (left <= t.data.length) return [t, left];
+      left -= t.data.length;
+      lastText = t;
+    }
+    return lastText ? [lastText, lastText.data.length] : [surface, 0];
+  }
+  // { surface, anchor, focus } for the selection in `surface`; offsets are
+  // null when the selection is not inside it.
+  function selectionSnapshotIn(surface) {
+    if (!surface) return null;
+    const sel = window.getSelection();
+    if (!sel.rangeCount || !surface.contains(sel.anchorNode) || !surface.contains(sel.focusNode)) {
+      return { surface, anchor: null, focus: null };
+    }
+    return { surface,
+      anchor: offsetInSurface(surface, sel.anchorNode, sel.anchorOffset),
+      focus: offsetInSurface(surface, sel.focusNode, sel.focusOffset) };
+  }
+  function restoreSelection(surface, anchor, focus) {
+    if (anchor === null || anchor === undefined) return;
+    const a = pointInSurface(surface, anchor);
+    const f = pointInSurface(surface, focus === null || focus === undefined ? anchor : focus);
+    window.getSelection().setBaseAndExtent(a[0], a[1], f[0], f[1]);
+  }
+
+  function flightTagOf(snap) {
+    if (!snap || !snap.surface) return null;
+    const blockEl = snap.surface.closest('.ed-block');
+    const isCell = snap.surface.classList.contains('ed-wys-cell');
+    return {
+      surface: snap.surface,
+      blockId: blockEl ? blockEl.getAttribute('data-block-id') : null,
+      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),
+    };
+  }
+
+  // The committed run's lines after the commit: the serializer's own
+  // line -> block map (`lineMeta`, one entry per emitted line), keyed by the
+  // block ids the run had before it. The provisional item has no id.
+  function flightLineMapOf(lineMeta, startLine) {
+    const map = { ids: {}, provisional: null };
+    (lineMeta || []).forEach((m, k) => {
+      if (m.blank) return;
+      if (m.blockId === null || m.blockId === undefined) {
+        if (map.provisional === null) map.provisional = startLine + k;
+      } else if (!(m.blockId in map.ids)) {
+        map.ids[m.blockId] = startLine + k;
+      }
+    });
+    return map;
+  }
+
+  // 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;
+  }
+  // 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
+  // still unpinned) to `snap`, or to its own first entry's hint — where it
+  // was typed — when there is no usable selection.
+  function pinFirstFlightRun(snap) {
+    const first = flightBuffer[0];
+    if (!first || first.pos) return;
+    const tag = snap && snap.anchor !== null ? flightTagOf(snap) : null;
+    first.pos = tag || (first.hint ? Object.assign({}, first.hint) : null);
+  }
+
+  function holdFlightEntry(surface, entry) {
+    entry.pos = null;
+    entry.hint = flightTagOf(selectionSnapshotIn(surface));
+    if (flightSelMoved) {
+      flightSelMoved = false;
+      entry.pos = flightTagOf(selectionSnapshotIn(surface));
+    }
+    const last = flightBuffer[flightBuffer.length - 1];
+    if (entry.kind === 'text' && !entry.pos && last && last.kind === 'text') {
+      last.data += entry.data;
+      return;
+    }
+    flightBuffer.push(entry);
+  }
+
+  // After a render lands: re-point every tag whose surface it replaced.
+  function reanchorFlightBuffer(before, editRange, lineMap) {
+    if (flightSelMoved && lastRenderSel) {
+      flightSelMoved = false;
+      flightBuffer.push({ kind: 'focus', pos: flightTagOf(lastRenderSel) });
+    }
+    flightFallback = lastRenderSel && !lastRenderSel.surface.isConnected
+      ? flightTagOf(lastRenderSel) : null;
+    const remap = (pos) => {
+      if (!pos) return;
+      if (pos.surface && pos.surface.isConnected) {
+        const own = pos.surface.closest('.ed-block');
+        pos.blockId = own ? own.getAttribute('data-block-id') : pos.blockId;
+        return;
+      }
+      let line = null;
+      if (lineMap) {
+        if (pos.blockId === null) line = lineMap.provisional;
+        else if (pos.blockId in lineMap.ids) line = lineMap.ids[pos.blockId];
+      }
+      if (line === null && pos.blockId !== null) {
+        const rec = (before || []).find((b) => b.id === Number(pos.blockId));
+        if (rec) {
+          line = rec.startLine;
+          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;
+      if (!nEl) return;
+      let surf = pos.cellIndex !== null && pos.cellIndex !== undefined
+        ? nEl.querySelectorAll('.ed-wys-cell')[pos.cellIndex] || null
+        : 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).
+  const FLIGHT_IS_MAC = /Mac|iPhone|iPad/.test(navigator.platform);
+  function deletionForKey(e) {
+    const word = FLIGHT_IS_MAC ? (e.altKey && !e.metaKey && !e.ctrlKey) : (e.ctrlKey && !e.metaKey && !e.altKey);
+    const line = FLIGHT_IS_MAC && e.metaKey && !e.altKey && !e.ctrlKey;
+    const plain = !e.ctrlKey && !e.metaKey && !e.altKey;
+    if (e.key === 'Backspace') {
+      return plain ? 'deleteContentBackward' : word ? 'deleteWordBackward' : line ? 'deleteSoftLineBackward' : null;
+    }
+    if (e.key === 'Delete') {
+      return plain ? 'deleteContentForward' : word ? 'deleteWordForward' : line ? 'deleteSoftLineForward' : null;
     }
+    return null;
+  }
+  function caretMoveForKey(e) {
+    const word = FLIGHT_IS_MAC ? (e.altKey && !e.metaKey && !e.ctrlKey) : (e.ctrlKey && !e.metaKey && !e.altKey);
+    const plain = !e.ctrlKey && !e.metaKey && !e.altKey;
+    const extend = !!e.shiftKey;
+    if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') {
+      if (!plain && !word) return null;
+      return { dir: e.key === 'ArrowLeft' ? 'backward' : 'forward', unit: word ? 'word' : 'character', extend };
+    }
+    if (!plain) return null;
+    if (e.key === 'Home' || e.key === 'End') return { dir: e.key === 'Home' ? 'backward' : 'forward', unit: 'lineboundary', extend };
+    if (e.key === 'ArrowUp' || e.key === 'ArrowDown') return { dir: e.key === 'ArrowUp' ? 'backward' : 'forward', unit: 'line', extend };
+    return null;
+  }
+  function isHeldTyping(en) {
+    return en.kind === 'text' || en.kind === 'paste' || en.kind === 'delete' || en.kind === 'format' ||
+      (en.kind === 'key' && !caretMoveForKey(en));
+  }
+  function dropHeldTyping() {
+    const kept = [];
+    let carry = null;
+    flightBuffer.forEach((en) => {
+      if (isHeldTyping(en)) {
+        if (en.pos) carry = en.pos;
+        return;
+      }
+      if (en.pos) carry = null;
+      else if (carry) { en.pos = carry; carry = null; }
+      kept.push(en);
+    });
+    flightBuffer.length = 0;
+    kept.forEach((en) => flightBuffer.push(en));
+  }
+  function flightHoldsKey(e) {
+    if ((e.key === 'Enter' || e.key === 'Tab') && !e.ctrlKey && !e.metaKey && !e.altKey) return true;
+    return !!(deletionForKey(e) || caretMoveForKey(e));
+  }
+
+  // The native default of a deletion, against the restored selection: a
+  // selection is deleted whole; a collapsed caret deletes one character, or
+  // is first extended by a word / to the line boundary.
+  function nativeFlightDeletion(t, target) {
+    const sel = window.getSelection();
+    if (!sel.rangeCount) return;
+    const back = /Backward$/.test(t);
+    const unit = /Word/.test(t) ? 'word' : (/Line/.test(t) ? 'lineboundary' : null);
+    if (sel.isCollapsed && unit) {
+      if (!sel.modify) return;
+      sel.modify('extend', back ? 'backward' : 'forward', unit);
+      // Nothing to delete in that direction: a collapsed 'delete' would take
+      // a character instead.
+      if (sel.isCollapsed) return;
+    }
+    snapBurstIfActive(target, 'replay-pre');
+    document.execCommand(sel.isCollapsed && !back ? 'forwardDelete' : 'delete');
+    snapBurstIfActive(target, 'replay');
+  }
+
+  function replayFlightEntry(item, target) {
+    if (item.kind === 'text') {
+      // The browser's own insertText, not insertTextAtCaret(): it replaces a
+      // selection the same way, and it also rebalances the whitespace around
+      // the caret the way live typing does (measured: a held Ctrl+Backspace
+      // leaves `ab` + NBSP, and only the native insertion of the next `e`
+      // turns that back into `ab e`).
+      snapBurstIfActive(target, 'replay-pre');
+      if (/[\r\n]/.test(item.data) || !document.execCommand('insertText', false, item.data)) {
+        insertTextAtCaret(item.data);
+      }
+      snapBurstIfActive(target, 'replay');
+    } else if (item.kind === 'paste') {
+      plainPasteArmed = item.plainOnly;
+      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 });
+      target.dispatchEvent(ev);
+      if (ev.defaultPrevented) return;
+      const del = deletionForKey(item);
+      if (del) { nativeFlightDeletion(del, target); return; }
+      const move = caretMoveForKey(item);
+      const sel = window.getSelection();
+      if (move && sel.modify) sel.modify(move.extend ? 'extend' : 'move', move.dir, move.unit);
+    }
+  }
+
+  function flushFlightBuffer() {
+    if (commitFlight || switching) return;
+    let dropped = false;
+    // Replay in order. A replayed key, or the focus change to a positioned
+    // entry's surface, can start a new commit (or wait on one); the rest
+    // waits and resumes from its endCommitFlight() or the focusin handlers.
+    while (flightBuffer.length && !commitFlight && !switching) {
+      const item = flightBuffer[0];
+      let target = null;
+      if (item.pos) {
+        target = item.pos.surface && item.pos.surface.isConnected ? item.pos.surface : null;
+        if (!target) { flightBuffer.shift(); dropped = true; continue; }
+        if (activeFlightSurface() !== target) {
+          target.focus();
+          if (commitFlight || switching) break;
+        }
+        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, mapOffsetThroughLog(fb, fb.anchor),
+            mapOffsetThroughLog(fb, fb.focus));
+          flightFallback = null;
+          target = activeFlightSurface();
+        }
+        if (!target) { flightBuffer.shift(); dropped = true; continue; }
+      }
+      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);
+  }
+
+  // An IME composition cannot be cancelled (its beforeinput is not
+  // cancelable), so the committed text is already in the DOM when
+  // compositionend reports it. It is taken back out when it sits right
+  // before the caret, which leaves the buffer its only owner — a render that
+  // keeps this surface (a failed one, or a patch that does not cover it)
+  // would otherwise show it twice once the replay lands. Returns false when
+  // it cannot be found there; the caller holds it anyway, and the render
+  // that replaces the surface is what removes the DOM copy.
+  function takeBackComposedText(data) {
+    const sel = window.getSelection();
+    if (!data || !sel.rangeCount) return false;
+    const r = sel.getRangeAt(0);
+    if (!r.collapsed || r.startContainer.nodeType !== 3) return false;
+    const node = r.startContainer;
+    const start = r.startOffset - data.length;
+    if (start < 0 || node.data.slice(start, r.startOffset) !== data) return false;
+    node.deleteData(start, data.length);
+    const c = document.createRange();
+    c.setStart(node, start);
+    c.collapse(true);
+    sel.removeAllRanges();
+    sel.addRange(c);
+    return true;
   }
 
   function autoSize(ta) {
@@ -2916,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;
@@ -4122,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
@@ -4179,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
@@ -4302,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
@@ -4928,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
@@ -4954,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 |', '|---|---|', '|  |  |'],
@@ -4972,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();
@@ -5098,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);
@@ -5149,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
@@ -5235,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
@@ -5289,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
@@ -5679,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);
@@ -5804,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 {
@@ -5820,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));
     }
   }
 
@@ -5963,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 + '"]');
   }
@@ -7324,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');
@@ -7345,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;
@@ -7404,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
@@ -7579,11 +9662,19 @@
         commitMd = runMd;
         commitStart = range.startLine;
         commitEnd = range.endLine;
+        // v3.13.1 T1 fix round 3: the whole run is rewritten — including any
+        // provisional item still in it, which then gets a line of its own and
+        // pushes the items after it down one. Keys held for those items find
+        // them by this map (see flightLineMapOf()). Measured without it: a
+        // failed Enter render, then `ab` replayed into the new item, then the
+        // blur commit of this run — `Z` held for charlie landed in `ab`.
+        pendingFlightLineMap = flightLineMapOf(lineMeta, range.startLine);
       }
       const liCommitResult = (commitMd === '')
         ? commitRangeRemoval({ lines, blocks, stack }, commitStart, commitEnd)
         : commitRangeEdit({ lines, blocks, stack }, commitStart, commitEnd, commitMd);
       if (liCommitResult.op === null) {
+        pendingFlightLineMap = null;
         endBurstWithoutResolve();
         return true;
       }
@@ -7637,8 +9728,14 @@
     // commit '#'.repeat(depth) + ' ' with nothing after the space. Every
     // non-heading burst's `depth` is null (blockDepthOf() only computes it for
     // 'heading'), so it takes the plain result.md branch.
-    const newText = burst.depth === null ? result.md :
-      (result.md === '' ? '#'.repeat(burst.depth) : '#'.repeat(burst.depth) + ' ' + result.md);
+    // v3.13.1 T2 (F-1): a paragraph's text is escaped where it would read as
+    // a block marker (`## `, `- `, `> `, `1. ` …), or the next render turns
+    // 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.
+    // 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
@@ -8193,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 + '"]');
   }
@@ -8354,7 +10470,7 @@
   async function commitListStructure(runEls, focusStartLine, caretToEnd, opts) {
     const span = runEls || [];
     const presetRange = opts && opts.presetRange;
-    const { md } = serializeListEls(span, { carryOver: (opts && opts.carryOver) || null });
+    const { md, lineMeta } = serializeListEls(span, { carryOver: (opts && opts.carryOver) || null });
     // The run's line range is read back off its own li blocks' ids — which
     // requires at least one li to still BE there. A caller whose mutation
     // removed the run's last item therefore captures the range BEFORE mutating
@@ -8383,6 +10499,10 @@
           endLine: Math.max(result.op.startLine - 1, result.op.endLine),
           delta: result.op.after.length - result.op.before.length }
       : undefined;
+    // v3.13.1 T1 fix round 2: where each item of the run will start once this
+    // commit lands, so a key held for an item of this very run — one the
+    // split pushed down a line, or the provisional item itself — finds it.
+    if (result.op !== null) pendingFlightLineMap = flightLineMapOf(lineMeta, range.startLine);
     const ok = await safeRerenderAll(editRange);
     if (!ok) {
       lines = rollbackFailedRender({ lines, stack }, result, prevLines);
@@ -8395,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.
   //
@@ -8584,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
@@ -8624,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
@@ -8679,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;
@@ -8776,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
@@ -8800,6 +11044,7 @@
     const state = burst.history.redo();
     if (state !== null) {
       editEl.innerHTML = state;
+      syncEmptyMark(editEl);
       placeCaretAtEnd(editEl);
       return;
     }
@@ -8849,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);
@@ -8861,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
@@ -8913,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
@@ -8954,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;
     }
@@ -9131,6 +11407,34 @@
   //
   // Returns the new block element, or null when the caret is not inside
   // `blockEl`'s own surface (nothing mutated).
+  // v3.13.1 T1: the item splitListItemAtCaret() just built is a plain div
+  // until the commit's render replaces it — not editable, so the caret stayed
+  // in the OLD item and anything typed before the render landed went there.
+  // Arm it the way armEditables() arms an li (the same two writes), focus it
+  // and put the caret at its start, where the render's own
+  // focusBlockAtLine() will put it again.
+  // The focusin this raises starts no burst: Enter's burst is still current
+  // here, so that handler's `if (currentBurst) return;` returns.
+  function armProvisionalLi(newLi) {
+    const textEl = liTextEl(newLi);
+    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(el);
+    range.collapse(true);
+    const sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+
   function splitListItemAtCaret(blockEl) {
     const sel = window.getSelection();
     if (!sel.rangeCount) return null;
@@ -9765,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
@@ -9819,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
@@ -9861,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()) {
@@ -10018,7 +12377,14 @@
     // splitListItemAtCaret() keeps `li` itself in place (only `newLi` is a
     // freshly-inserted sibling) and never touches the focused node's
     // attachment.
-    const newLi = mutateListRun(() => splitListItemAtCaret(li));
+    // v3.13.1 T1: the new item is armed and focused inside the same span, so
+    // the old item's focusout stays suppressed and the next keystroke is
+    // already aimed at the new item while the commit below is in flight.
+    const newLi = mutateListRun(() => {
+      const n = splitListItemAtCaret(li);
+      if (n) armProvisionalLi(n);
+      return n;
+    });
     if (!newLi) return true;
     run = listRunOf(newLi);
     // `li` had its text CUT IN TWO in the DOM; replaying its source would put
@@ -10945,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();
@@ -10956,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);
@@ -16067,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,
     };
   }
 
@@ -16447,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
@@ -16483,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.
@@ -16598,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') {
@@ -16612,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.
@@ -16893,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 });
   }
 
@@ -17126,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;
     }
@@ -17550,6 +19893,46 @@
       e.target.classList.contains('ed-raw');
     if (inTextarea) return; // Ctrl+Enter/Esc handled by openRawEditor()'s own per-instance listener
 
+    // v3.13.1 T1: a key that edits or moves, pressed while a commit is in
+    // flight, would act on DOM the render is about to replace. Held, in order
+    // with the text around it, and replayed by flushFlightBuffer() through
+    // this same handler (see `commitFlight`). An IME's own keys (isComposing)
+    // are left alone. Escape drops everything held (R12) and then carries on
+    // to its usual meaning. A standing table cell range keeps its own keys —
+    // its Delete clears the range, which a held character delete would not.
+    if (flightActive() && !e.isComposing && !cellRangeBurst()) {
+      const flightSurface = flightSurfaceOf(e.target);
+      if (flightSurface && e.key === 'Escape') { flightBuffer.length = 0; flightSelMoved = false; }
+      // Ctrl/Cmd+Z with keys held: the most recent thing to undo is that
+      // typing, which never reached the document — dropping it IS the undo,
+      // and the commit in flight stays (the next Ctrl+Z, with nothing held,
+      // undoes it as usual). Measured before: the undo reverted the Enter
+      // underneath the held keys, and they replayed into the next item
+      // (`abccharlie`). Held navigation (and a click's focus entry) is not
+      // typing and stays; a dropped entry's position passes to the next kept
+      // entry of its run.
+      if (flightSurface && flightBuffer.some(isHeldTyping) && (e.ctrlKey || e.metaKey) && !e.shiftKey &&
+          !e.altKey && (e.key === 'z' || e.key === 'Z')) {
+        e.preventDefault();
+        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,
+          ctrlKey: e.ctrlKey, altKey: e.altKey, metaKey: e.metaKey });
+        return;
+      }
+    }
+
     // Task 5: a table cell (class 'ed-wys-cell') owns its own Enter/Tab/
     // Escape/Ctrl+Z/Ctrl+Y contract, materially different from paragraph/
     // heading/list (Enter is an UNCONDITIONAL <br>, Tab moves the active
@@ -17590,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;
     }
@@ -17789,8 +20174,17 @@
   // 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); return; }
+    if (cellEl) { await handleTableCellFocusIn(cellEl); scheduleFlightFlush(); return; }
     const editEl = e.target && e.target.closest && e.target.closest('.ed-wys-armed');
     if (!editEl) return;
     if (currentBurst && currentBurst.editEl === editEl) return; // already tracking
@@ -17800,8 +20194,33 @@
     // 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;
-    if (currentBurst) return; // a concurrent focusin already won the race
+    // 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
+    // open it on a surface that no longer has focus and leave the one that
+    // does without one: measured on base and head, Enter, `ab`, ArrowDown, `Z`
+    // put `Z` in charlie's DOM, and the blur that followed committed nothing.
+    if (document.body.contains(editEl) && !editEl.contains(document.activeElement)) {
+      scheduleFlightFlush();
+      return;
+    }
+    if (currentBurst) { scheduleFlightFlush(); return; } // a concurrent focusin already won the race
     let liveEditEl = editEl;
     if (!document.body.contains(editEl)) {
       // The awaited resolution above committed successfully and swapped the
@@ -17809,13 +20228,28 @@
       // 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();
+      // v3.13.1 R11: focus() alone puts the caret at the surface's start, not
+      // where the click that brought focus here put it. Measured on base and
+      // head, both engines: edit A, click mid-B, type — the characters landed
+      // at B's start; a drag or double-click selection collapsed. The
+      // selection was read just before the render replaced B (lastRenderSel).
+      if (lastRenderSel && lastRenderSel.surface === editEl) {
+        restoreSelection(liveEditEl, lastRenderSel.anchor, lastRenderSel.focus);
+      }
+      scheduleFlightFlush();
       return;
     }
     startBurst(liveEditEl);
+    scheduleFlightFlush();
   });
 
   document.addEventListener('focusout', (e) => {
@@ -17956,6 +20390,110 @@
     return currentBurst.history;
   }
 
+  // v3.13.1 T1: a pointer press into a surface during a flight moves the
+  // selection the user means the next held key for (see `flightSelMoved`).
+  // A press anywhere else — the toolbar, the margin — is not one.
+  // Capture phase: this runs before the press moves the selection, which is
+  // what pins the opening run to where it was typed (see pinFirstFlightRun()).
+  document.addEventListener('pointerdown', (e) => {
+    if (!flightActive()) return;
+    pinFirstFlightRun(selectionSnapshotIn(activeFlightSurface()));
+    if (flightSurfaceOf(e.target)) flightSelMoved = true;
+  }, true);
+
+  // v3.13.1 T1: the input half of the commit-in-flight guard (see
+  // `commitFlight`). Registered ahead of the native-format listener below,
+  // both in the capture phase, so a held keystroke never reaches it.
+  //
+  // `isComposing` insertText is skipped: an engine that reports a
+  // composition's commit that way also reports it to compositionend below,
+  // and the text must be held once.
+  function flightSurfaceOfEvent(e) {
+    return flightActive() ? flightSurfaceOf(e.target) : null;
+  }
+  // The text compositionend just held. An engine that inserts a
+  // composition's commit AFTER compositionend (WebKit's
+  // insertFromComposition) would put it in the DOM a second time; that
+  // insertion is cancelled, or taken back out on its input event when it
+  // cannot be cancelled. Cleared on the next task: the follow-up arrives in
+  // the same one or not at all.
+  let composedHeld = null;
+  let composedTakeBack = null;
+  document.addEventListener('beforeinput', (e) => {
+    if (composedHeld !== null && e.data === composedHeld &&
+        (e.inputType === 'insertFromComposition' || e.inputType === 'insertText')) {
+      composedHeld = null;
+      if (e.cancelable) e.preventDefault(); else composedTakeBack = e.data;
+      return;
+    }
+    const surface = flightSurfaceOfEvent(e);
+    if (!surface) return;
+    const t = e.inputType;
+    if ((t === 'insertText' || t === 'insertReplacementText') && !e.isComposing) {
+      // insertReplacementText (autocorrect, spellcheck) carries its text in
+      // dataTransfer in some engines and in `data` in others.
+      const data = e.data != null ? e.data
+        : (e.dataTransfer && e.dataTransfer.getData('text/plain')) || '';
+      e.preventDefault();
+      if (data) holdFlightEntry(surface, { kind: 'text', data });
+      return;
+    }
+    // A deletion that did not come from a held key (the keyboard ones are
+    // held at keydown — WebKit fires no beforeinput at all for Backspace on
+    // an empty surface, measured): a context-menu delete, say.
+    if (/^delete/.test(t) && t !== 'deleteByCut' && t !== 'deleteByDrag' && t !== 'deleteCompositionText') {
+      e.preventDefault();
+      holdFlightEntry(surface, { kind: 'delete', inputType: t });
+    }
+  }, true);
+  document.addEventListener('input', (e) => {
+    if (composedTakeBack !== null && e.data === composedTakeBack) takeBackComposedText(e.data);
+    composedTakeBack = null;
+  }, true);
+  // Known limit: a composition still open when the flight ends is left to
+  // the browser — its compositionend arrives with no flight to hold it, and
+  // if the render replaced the surface mid-composition, what the engine does
+  // with the rest of it is its own.
+  document.addEventListener('compositionend', (e) => {
+    const surface = flightSurfaceOfEvent(e);
+    if (!surface || !e.data) return;
+    takeBackComposedText(e.data);
+    holdFlightEntry(surface, { kind: 'text', data: e.data });
+    composedHeld = e.data;
+    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;
@@ -18022,10 +20560,35 @@
     // wave field is not — this is here so the boundary is one predicate rather
     // than a property of which targets those two selectors happen to match.
     if (waveEditorIsModal()) return;
-    const cellEl = e.target && e.target.closest && e.target.closest('.ed-wys-cell');
-    if (cellEl) {
+    // v3.13.1 T1 fix round 1: a paste while a commit is in flight is held like
+    // typing (measured before: lost outright) and replayed through
+    // routePaste(), the path a live paste takes. The clipboard is readable
+    // only during the event, so its flavours are copied out here.
+    const flightSurface = flightSurfaceOfEvent(e);
+    if (flightSurface) {
       e.preventDefault();
-      const dt = e.clipboardData || window.clipboardData;
+      holdFlightEntry(flightSurface, { kind: 'paste',
+        dt: snapshotClipboard(e.clipboardData || window.clipboardData), plainOnly: plainPasteArmed });
+      plainPasteArmed = false;
+      return;
+    }
+    const target = e.target && e.target.closest &&
+      (e.target.closest('.ed-wys-cell') || e.target.closest('.ed-wys-armed'));
+    if (!target) return;
+    e.preventDefault();
+    routePaste(target, e.clipboardData || window.clipboardData);
+  });
+  function snapshotClipboard(dt) {
+    const data = {};
+    ['text/plain', 'text/html'].forEach((k) => {
+      try { data[k] = dt ? dt.getData(k) || '' : ''; } catch (err) { data[k] = ''; }
+    });
+    const files = dt && dt.files ? Array.prototype.slice.call(dt.files) : [];
+    return { files, types: Object.keys(data).filter((k) => data[k]), getData: (k) => data[k] || '' };
+  }
+  function routePaste(target, dt) {
+    const cellEl = target.closest('.ed-wys-cell');
+    if (cellEl) {
       const grid = dt ? clipboardGrid(dt) : null;
       if (grid && pasteGridIntoTable(cellEl, grid)) return;
       snapBurstIfActive(cellEl.closest('table'), 'paste-pre');
@@ -18033,10 +20596,8 @@
       snapBurstIfActive(cellEl.closest('table'), 'paste');
       return;
     }
-    const editEl = e.target && e.target.closest && e.target.closest('.ed-wys-armed');
+    const editEl = target.closest('.ed-wys-armed');
     if (!editEl) return;
-    e.preventDefault();
-    const dt = e.clipboardData || window.clipboardData;
     // v3.1.0 追加 2: paste-md.js decides what the clipboard actually holds
     // (text/html -> markdown, an image, or plain text) and this routes the
     // answer. The TABLE-CELL branch above deliberately keeps its plain-text
@@ -18044,7 +20605,7 @@
     // pasted into one cell would be a nested structure the serializer has no
     // way to represent.
     handleArmedPaste(dt, editEl);
-  });
+  }
 
   // Task 5: hover-edge insert bubbles — one delegated, rAF-throttled
   // mousemove listener (never a per-block/per-boundary listener) drives
@@ -19787,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();
 })();