@helping-ai-workflow/md2doc 3.13.0 → 3.13.1

package/lib/editor/client.js

@@ -1110,7 +1110,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;
   }
 
@@ -1685,6 +1687,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);
   }
 
@@ -2664,14 +2671,457 @@
   // 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. Offsets are shifted past the held text
+  //    that will be inserted before them in the same surface by the time it
+  //    replays (heldShiftBefore()). The tag is re-pointed when a render
+  //    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,
+    };
+  }
+
+  // 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;
+  }
+
+  // How far held text will have pushed `offset` in `surface` by the time an
+  // entry positioned there replays: the text of every run pinned (or, for
+  // the opening run, typed) in the same surface at or before that offset.
+  function heldShiftBefore(surface, offset) {
+    let pin = null;
+    let shift = 0;
+    flightBuffer.forEach((en, i) => {
+      if (en.pos || i === 0) pin = en.pos || en.hint;
+      if (en.kind !== 'text' || !pin || pin.surface !== surface || pin.anchor === null) return;
+      if (Math.min(pin.anchor, pin.focus === null ? pin.anchor : pin.focus) <= offset) shift += en.data.length;
+    });
+    return shift;
+  }
+  function shiftedTag(tag) {
+    if (!tag || tag.anchor === null) return tag;
+    tag.anchor += heldShiftBefore(tag.surface, tag.anchor);
+    if (tag.focus !== null) tag.focus += heldShiftBefore(tag.surface, tag.focus);
+    return tag;
+  }
+
+  // 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 = shiftedTag(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: shiftedTag(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;
+        }
+      }
+      pos.surface = null;
+      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.blockId = String(nb.id);
+    };
+    flightBuffer.forEach((en) => { remap(en.pos); remap(en.hint); });
+    remap(flightFallback);
+  }
+
+  // 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 === '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 === '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, item.pos.anchor, item.pos.focus);
+      } else {
+        target = activeFlightSurface();
+        const fb = flightFallback;
+        if (!target && fb && fb.surface && fb.surface.isConnected) {
+          fb.surface.focus();
+          if (commitFlight || switching) break;
+          restoreSelection(fb.surface, fb.anchor, fb.focus);
+          flightFallback = null;
+          target = activeFlightSurface();
+        }
+        if (!target) { flightBuffer.shift(); dropped = true; continue; }
+      }
+      flightBuffer.shift();
+      if (item.kind !== 'focus') {
+        flightReplaying = true;
+        try { replayFlightEntry(item, target); } finally { flightReplaying = false; }
+      }
     }
+    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) {
@@ -7579,11 +8029,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,7 +8095,13 @@
     // 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 :
+    // 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.
+    const newText = burst.depth === null
+      ? (burst.blockType === 'paragraph' ? inlineMd.escapeBlockStarts(result.md) : result.md) :
       (result.md === '' ? '#'.repeat(burst.depth) : '#'.repeat(burst.depth) + ' ' + result.md);
     // S1 removed the pre-per-li "a whole-list burst that serialized to ''"
     // branch that lived here alongside the dead 'list' serializer arm above.
@@ -8354,7 +8818,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 +8847,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);
@@ -9131,6 +9599,28 @@
   //
   // 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) return;
+    textEl.setAttribute('contenteditable', 'true');
+    textEl.classList.add('ed-wys-armed');
+    textEl.focus();
+    const range = document.createRange();
+    range.selectNodeContents(textEl);
+    range.collapse(true);
+    const sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+
   function splitListItemAtCaret(blockEl) {
     const sel = window.getSelection();
     if (!sel.rangeCount) return null;
@@ -10018,7 +10508,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
@@ -17550,6 +18047,38 @@
       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;
+      }
+      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
@@ -17790,7 +18319,7 @@
   // top of each listener below — see handleTableCellFocusIn() above.
   document.addEventListener('focusin', async (e) => {
     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
@@ -17801,7 +18330,17 @@
     // 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.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
@@ -17813,9 +18352,19 @@
       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 +18505,79 @@
     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);
+
   // 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 +18644,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 +18680,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 +18689,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