@helping-ai-workflow/md2doc 2.10.1 → 2.11.0

package/lib/editor/client.js

@@ -10,6 +10,46 @@
     return lines.slice(block.startLine - 1, block.endLine).join('\n');
   }
 
+  // ── T8 item 1: the range helpers refuse an INVERTED range THEMSELVES ────
+  // A block that owns no source line has endLine === startLine - 1 (see
+  // blockOwnsNoLine() further down) and blocks do not tile the document, so an
+  // inverted range is a shape callers can genuinely arrive at. Both helpers
+  // below were written assuming endLine >= startLine, and handed an inverted
+  // range neither fails — each does something plausible and wrong:
+  //   commitRangeEdit()    `lines.slice(startLine-1, endLine)` is [], so the
+  //                        unchanged-text test compares against '', and
+  //                        ops.replaceLines() splices without removing — an
+  //                        INSERT where a replace was asked for. Measured:
+  //                        '# Doc\n\n- a\n\n- - b\n' + 'ZZZ' ->
+  //                        '# Doc\n\n- a\n\nZZZ\n- - b\n'.
+  //   commitRangeRemoval() the blank-line absorption samples `lines[el]` (the
+  //                        range's own first line) and `lines[sl-2]` (a line
+  //                        owned by whatever precedes), finds one blank and
+  //                        deletes it. Measured: '# Doc\n\n- a\n\n- - b\n'
+  //                        -> '# Doc\n\n- a\n- - b\n', silently.
+  // That single root cause was fixed FIVE separate times at five call sites
+  // (T3 arming, T3 same-line child commit, T4 gutter delete, T4 raw edit,
+  // T7 insertBlockBelow). Those guards stay — they can show the user a banner,
+  // which this cannot — but the rule now also lives in the one place every
+  // path must pass through.
+  //
+  // The refusal REUSES the existing "nothing changed" return shape (`op: null`,
+  // the caller's own arrays handed straight back) plus a `refused` tag, rather
+  // than throwing: every call site already has a correct abort path for
+  // op === null, and none of the five is inside a try/catch, so a throw would
+  // convert a silent wrong edit into an unhandled rejection mid-gesture — a
+  // different failure, not a safer one. The tag is what makes the refusal
+  // observable; `console.error` is what makes it findable in a real session.
+  function refuseInvertedRange(state, who, startLine, endLine) {
+    if (endLine >= startLine) return null;
+    if (typeof console !== 'undefined' && console && typeof console.error === 'function') {
+      console.error('[md2doc] ' + who + ' refused an inverted line range: startLine=' +
+        startLine + ' endLine=' + endLine + ' (a block that owns no source line, or a ' +
+        'caller that computed a range backwards) — nothing was committed');
+    }
+    return { lines: state.lines, blocks: state.blocks, op: null, refused: 'inverted-range' };
+  }
+
   // Pure: apply a raw-edit commit to an EXPLICIT line range (startLine..endLine,
   // 1-indexed inclusive); push onto stack.
   // Returns {lines, blocks, op}; op === null when text is unchanged.
@@ -17,6 +57,8 @@
   // so that only blocks after the committed range are shifted — not blocks
   // inside it. Guards the no-anchor case (range before every block).
   function commitRangeEdit(state, startLine, endLine, newText) {
+    const refusal = refuseInvertedRange(state, 'commitRangeEdit', startLine, endLine);
+    if (refusal) return refusal;
     const before = state.lines.slice(startLine - 1, endLine);
     const after = newText.split('\n');
     if (before.join('\n') === after.join('\n')) {
@@ -48,6 +90,8 @@
   // widening endLine to cover an adjacent blank never reaches across into the
   // next real block and mis-shifts it.
   function commitRangeRemoval(state, startLine, endLine) {
+    const refusal = refuseInvertedRange(state, 'commitRangeRemoval', startLine, endLine);
+    if (refusal) return refusal;
     const anchor = state.blocks.filter((b) => b.endLine <= endLine).pop();
     let sl = startLine, el = endLine;
     // state.lines[el] (0-indexed) is the line immediately AFTER the range.
@@ -103,6 +147,14 @@
   // pure insertion/pure removal without a third op shape.
   function commitBlockInsertion(state, blockId, newBlockLines) {
     const block = state.blocks.find((b) => b.id === blockId);
+    // T8 item 1, third helper in the same family: the anchor's range is read as
+    // an interval here too (`endLine + 1` is the insertion point, `lines[endLine]`
+    // the trailing-blank probe), so an inverted one puts the new block ABOVE the
+    // block it was anchored to, inside the previous one's territory.
+    // refuseInvertedRange() takes the range, so the anchor's own is passed.
+    const anchorRefusal = refuseInvertedRange(state, 'commitBlockInsertion',
+      block.startLine, block.endLine);
+    if (anchorRefusal) return anchorRefusal;
     const endLine = block.endLine;
     const nextLine = state.lines[endLine]; // 0-indexed: line right after the block, or undefined at EOF
     const needsTrailingBlank = nextLine !== undefined && nextLine.trim() !== '';
@@ -122,6 +174,35 @@
     return { lines: r.lines, blocks, op, newStartLine };
   }
 
+  // ── T8 review MEDIUM-1: the one correct way to undo a failed render ─────
+  // Six sites in this file share the shape "commit optimistically, re-render,
+  // and if the render failed put `lines` back". The inlined version of that
+  // last step was `const rollback = stack.undo(lines); lines = rollback ?
+  // rollback.lines : prevLines;` — correct only while EVERY commit pushed an
+  // op. Since commitRangeEdit()/commitRangeRemoval()/commitBlockInsertion()
+  // learned to REFUSE an inverted range (above), a commit can return
+  // `op: null` having pushed nothing, and UndoStack.undo() pops `_done`
+  // unconditionally (lib/editor/lineops.js) — so at the two sites that never
+  // inspected `result.op` (insertBlockBelow / deleteBlockViaGutter) a refusal
+  // followed by a render failure popped and reversed the user's PREVIOUS,
+  // UNRELATED edit. Latent only because those two check blockOwnsNoLine()
+  // first; S2 gives li blocks a ＋ and it goes live.
+  //
+  // One helper rather than two `if (result.op === null) return;` lines,
+  // because the idiom is copy-pasted and the seventh site will not remember
+  // either. Declared in the pure core so it is reachable from node: the branch
+  // cannot be driven through a gesture today, and a guard that can only be
+  // checked by grepping for its own source text is the shape that already
+  // failed review once on this plan.
+  //
+  // `state` needs `.lines` (the CURRENT, optimistically-assigned array) and
+  // `.stack`. Returns the array `lines` should become.
+  function rollbackFailedRender(state, result, prevLines) {
+    if (!result || result.op === null) return prevLines;
+    const rollback = state.stack.undo(state.lines);
+    return rollback ? rollback.lines : prevLines;
+  }
+
   function headingDepthOf(line) {
     const m = line.match(/^(#{1,6})\s?/);
     return m ? m[1].length : 1;
@@ -141,7 +222,7 @@
   }
 
   if (typeof module === 'object' && module.exports) {
-    module.exports = { extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, headingDepthOf, withHeadingDepth };
+    module.exports = { extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, rollbackFailedRender, headingDepthOf, withHeadingDepth };
     return; // node: pure core only
   }
 
@@ -150,6 +231,8 @@
   const inlineMd = window.md2docInlineMd;
   const tableMd = window.md2docTableMd;
   const listMd = window.md2docListMd;
+  const indentClamp = window.md2docIndentClamp;
+  const convertMd = window.md2docConvertMd;
   const historyLib = window.md2docHistory;
   let lines = ED.lines, blocks = ED.blocks, mtimeMs = ED.mtimeMs;
   // 檔案原本的換行符。lines 內部永遠是不含 \r 的純內容行；只有 save()
@@ -257,7 +340,7 @@
   // Task 8: the SAME Chromium behaviour, one substrate over — see
   // `suppressTableFocusout` just above for the full description of the quirk.
   // A structural list key (Enter / Tab / Shift+Tab on a per-li block) moves,
-  // splits or removes the very <li> whose `.ed-li-text` currently has focus,
+  // splits or removes the very block whose `.ed-li-text` currently has focus,
   // so Chromium runs its unfocus step — firing a synchronous focusout — with
   // the run still in its PRE-mutation shape and `currentBurst` still live.
   // Unguarded, that focusout reaches resolveBurst(), whose li branch happily
@@ -281,6 +364,8 @@
       return fn();
     } finally {
       suppressLiFocusout = false;
+      // S1: indents (and therefore run boundaries) may have just moved.
+      refreshRunStarts();
     }
   }
 
@@ -598,6 +683,21 @@
     const blockId = Number(blockEl.getAttribute('data-block-id'));
     const block = blocks.find((b) => b.id === blockId);
     if (!block) return;
+    // Task 4 fix round 1 (Critical, second path): a block that owns no source
+    // line has an INVERTED range (endLine === startLine - 1) — see
+    // blockOwnsNoLine(). Everything below assumes a well-formed interval:
+    // extractBlockSource() of an inverted range is '', so the textarea opens
+    // EMPTY, and commit() -> commitEdit() -> commitRangeEdit(5, 4, text)
+    // INSERTS the text as a new line instead of replacing anything, leaving
+    // the clicked item untouched and a stray line in the file (measured:
+    // '# Doc\n\n- a\n\n- - b\n' + 'ZZZ' -> '# Doc\n\n- a\n\nZZZ\n- - b\n').
+    // The only such blocks today are list items (RULING F-O independently
+    // forbids a textarea inside one), and they are never armed, so before
+    // Task 4 gave every block a ⠿ this was reached by a plain body click and
+    // stayed unreported. Guarded HERE rather than at the click delegator so
+    // every caller — the delegated degraded-block click, openRawViaGutter(),
+    // the burst-degrade path — is closed by one check.
+    if (blockOwnsNoLine(blockEl)) { refuseStructuralListEdit(NO_SOURCE_LINE_MESSAGE); return; }
 
     const original = blockEl.innerHTML;
     const source = extractBlockSource(lines, block);
@@ -701,8 +801,7 @@
         // consistent with what the server actually has. Deliberately does
         // NOT call restore() — the editor (and the user's unsaved text)
         // stays open and visible; see the comment above.
-        const rollback = stack.undo(lines);
-        lines = rollback ? rollback.lines : prevLines;
+        lines = rollbackFailedRender({ lines, stack }, result, prevLines);
         return false;
       }
       // Success: rerenderAll() already replaced the whole .content subtree
@@ -729,10 +828,11 @@
   // A block's rendered content is the .ed-block's single element child
   // (see lib/md2doc.js's editMode wrapper: `<div class="ed-block"
   // ...>${inner}</div>` where `inner` is exactly one <p>/<h#>/... tag).
-  // Per-li exception (Task 6 / Phase 4): for data-block-type="li" the
-  // .ed-block IS the <li> itself — its editable content is the child
-  // <div class="ed-li-text"> (Task 4), not firstElementChild (which would
-  // land on the optional .ed-li-check span or a nested <ul>/<ol>).
+  // Per-li exception (Task 6 / Phase 4): for data-block-type="li" the block's
+  // editable content is its child <div class="ed-li-text">, not
+  // firstElementChild — S1 made that distinction load-bearing rather than
+  // merely defensive, since a flat list block's FIRST element child is always
+  // the .ed-li-marker span (and the .ed-li-check span may follow it).
   function blockContentEl(blockEl) {
     if (blockEl.getAttribute && blockEl.getAttribute('data-block-type') === 'li') {
       // Walk childNodes for the DIV with class ed-li-text (Task 4 shape).
@@ -783,58 +883,432 @@
     return !!tableEl && tableMd.serializeTable(tableEl).unsupported.length === 0;
   }
 
-  // Task 6 (Phase 4): per-li eligibility check — build a one-item probe
-  // UL/OL containing ONLY this li's non-list children (the .ed-li-check span
-  // and the .ed-li-text div), then serialize it. Returns false when any
-  // inline content is unsupported, so that li stays unarmed without affecting
-  // its siblings. Uses the live li's own parent tag (UL or OL) so an ordered
-  // task-item probes correctly as an ordered list.
-  function canWysiwygForLi(liEl) {
-    if (!liEl) return false;
-    const parentTag = liEl.parentElement ? liEl.parentElement.nodeName : 'UL';
-    const probe = document.createElement(parentTag);
-    const liClone = liEl.cloneNode(false); // shallow: no nested ul/ol
-    const kids = liEl.childNodes;
-    for (let i = 0; i < kids.length; i++) {
-      const k = kids[i];
-      // Copy non-list children only (the check span and the text div).
-      if (k.nodeName !== 'UL' && k.nodeName !== 'OL') {
-        liClone.appendChild(k.cloneNode(true));
-      }
+  // Task 6 (Phase 4): per-li eligibility check — serialize THIS block alone
+  // and refuse to arm it if anything in it cannot round-trip. Returns false
+  // when any inline content is unsupported, so one bad item never degrades its
+  // siblings.
+  //
+  // S1: no probe element is built any more. Pre-S1 this had to clone the <li>
+  // into a synthetic UL/OL because serializeList() only took a list ROOT;
+  // serializeBlocks() takes the block elements directly, so the live element
+  // is passed as a one-element run. Both halves of the result are checked:
+  // `unsupportedByLi` carries the per-block inline names, `unsupported` is its
+  // strict superset (it additionally collects stray TEXT, foreign children,
+  // and — flat model, controller note T2-B — the 'P' of a loose item, which
+  // reaches the inline serializer as an ordinary unhandled element name).
+  //
+  // STRUCTURAL_ONLY names are excluded. 'MULTILINE' (a hard-wrapped item, which
+  // legitimately owns a RANGE of lines) is reported so the structural gate can
+  // refuse Tab / Enter on it, but spec §4.1 keeps text editing unaffected — and
+  // arming IS text editing. Roughly a fifth of real-world list items are
+  // hard-wrapped, so treating the flag as an arming veto turns whole documents
+  // read-only. Filtered by NAME LIST rather than by a hard-coded string so the
+  // serializer stays the single source of truth.
+  function armBlockingNames(unsupported) {
+    return unsupported.filter((n) => listMd.STRUCTURAL_ONLY_UNSUPPORTED.indexOf(n) === -1);
+  }
+
+  // A block that owns NO SOURCE LINE has nothing to edit, and arming it is
+  // actively destructive. Under same-line nesting ('- - b') the outer item's
+  // content begins with its child, so blockmap.js gives it
+  // endLine === startLine - 1 — an empty range, not an interval. The commit
+  // helpers do not special-case that: the per-li degrade path (taken whenever
+  // the run holds a loose or hard-wrapped item) hands
+  // editedBlock.startLine/endLine straight to commitRangeEdit(), whose
+  // replaceLines() computes `slice(0, start-1).concat(new, slice(end))` — with
+  // end < start those two slices OVERLAP, so the original line survives AND the
+  // new one is inserted:
+  //
+  //   '# D\n\n- a\n\n- - b\n'  --type Z-->  '# D\n\n- a\n\n- Z\n- - b\n'
+  //
+  // Refusing here closes every such path with one rule, instead of teaching
+  // seven commit helpers about a range shape none of them expect. The block is
+  // still rendered, still selectable, and its CHILD — which does own its line —
+  // stays fully editable.
+  function blockOwnsNoLine(blockEl) {
+    const raw = blockEl.getAttribute('data-block-id');
+    if (raw === null) return false; // provisional block: no record yet, not our call
+    const rec = blocks.find((b) => b.id === Number(raw));
+    return !!rec && rec.endLine < rec.startLine;
+  }
+
+  // Task 4 fix round 1: the message the two blockOwnsNoLine() guards above
+  // (openRawEditor / deleteBlockViaGutter) pass into the SHARED
+  // refuseStructuralListEdit() helper (defined further down, next to
+  // listRunSupportsStructuralEdit() — see its comment for why this is a
+  // parameter and not a second function). One constant so both call sites
+  // stay byte-identical instead of two hand-typed copies drifting apart.
+  const NO_SOURCE_LINE_MESSAGE = '此項目沒有自己的來源行，無法刪除或直接編輯';
+  // T7 fix round 1 (LOW-2): insertBlockBelow()'s own wording. A second
+  // constant rather than a reuse, because the one above NAMES the two
+  // operations it refuses — an insert that answered '無法刪除' would be
+  // telling the user something that is not true of the button they pressed.
+  const NO_SOURCE_LINE_INSERT_MESSAGE = '此項目沒有自己的來源行，無法在其後插入區塊';
+
+  // The list markers standing at the head of one source line, left to right.
+  // A same-line nest ('- 1. b') puts one marker per nesting level on the line;
+  // this reads them back so a re-emitted ancestor line can keep the bullet
+  // character / ordinal delimiter the file already uses. Stops at the first
+  // non-marker, so the last entry is the innermost item's own marker.
+  function sourceMarkerChain(line) {
+    const out = [];
+    let rest = typeof line === 'string' ? line : '';
+    for (;;) {
+      // The optional trailing group is a GFM task checkbox: it is CONTENT, not
+      // marker, but it sits between this marker and the next one, so the walk
+      // has to step over it or the chain stops at the first task item.
+      const m = /^(\s*)(?:([-*+])|(\d{1,9})([.)]))(\s+)(?:\[[ xX]\]\s+)?/.exec(rest);
+      if (!m) return out;
+      out.push({ bullet: m[2] || null, delim: m[4] || null });
+      rest = rest.slice(m[0].length);
+    }
+  }
+
+  // Rewrites a serialized marker to use the SOURCE's bullet char / ordinal
+  // delimiter, keeping the serializer's own width and ordinal. Both
+  // substitutions are single characters, so the marker's column count — which
+  // the child's indent prefix was computed against (spec §3.4) — cannot move.
+  //
+  // Why not just keep the serializer's canonical '-' / '1.': the degrade path
+  // rewrites ONE line and leaves its siblings' bytes alone, and marked starts a
+  // NEW list token at a bullet-char or delimiter change. Canonicalising this
+  // line alone therefore splits the surrounding list in two ('+ a' + '- …'),
+  // which is a visible change to items the user never edited.
+  // Takes the BULLET ('- ', '2. '), never the whole marker: a task item's
+  // marker is bullet + checkbox ('1. [ ] '), and the ordinal delimiter is then
+  // no longer at the end of the string for the substitution to find.
+  function bulletInSourceStyle(bullet, src) {
+    if (!src) return bullet;
+    if (src.bullet) return /^[-*+]/.test(bullet) ? src.bullet + bullet.slice(1) : bullet;
+    if (src.delim) return bullet.replace(/([.)])(\s*)$/, src.delim + '$2');
+    return bullet;
+  }
+
+
+  // Round 5 — the other half of the same-line-nesting problem. Refusing to ARM
+  // a zero-line block (above) keeps it from being the TARGET of a commit; it
+  // does nothing about the fact that its marker physically STANDS ON its
+  // child's source line. '- - b' is one line carrying two markers, and the
+  // child's own line range IS that line — so the per-li degrade path, which
+  // replaces [editedBlock.startLine, editedBlock.endLine] with only the lines
+  // lineMeta attributes to the edited block, overwrote every ancestor marker
+  // standing on it:
+  //
+  //   '# D\n\n- a\n\n- - b\n'  --type Z-->  '# D\n\n- a\n\n  - bZ\n'
+  //
+  // The child lost its parent — a semantic change (the previous item swallows
+  // it), not a reformat.
+  //
+  // So the replacement re-emits every such ancestor's MARKER on a line of its
+  // own, ahead of the edited block's lines. That is the canonical form the
+  // whole-run path already produces for a tight run ('- a\n-\n  - b'), it
+  // round-trips ('-\n  - b' and '- - b' are the same tree to marked), and it
+  // removes the zero-line shape from the file, so the ancestor becomes armable
+  // afterwards.
+  //
+  // A content-free TASK ancestor is NOT in this list, and must not be: marked
+  // only reads '[ ]' / '[x]' as a checkbox when content follows on the SAME
+  // line, so a line of its own would downgrade it to literal text. Round 6
+  // moved that case into the serializer, which now carries such an item as a
+  // prefix on its child's line — so it emits no lineMeta entry of its own and
+  // this walk never sees it, while the child's own emitted line (which the
+  // caller slices anyway) already carries its marker. The two forms therefore
+  // stay in one place: lib/editor/list-md.js decides, this only replays.
+  //
+  // MARKER ONLY, never the ancestor's emitted line: an item whose own content
+  // resumes AFTER its child ('- - b' … '  tail') owns that content on a line
+  // OUTSIDE this commit range, so emitting the serializer's full line for it
+  // would duplicate the text. Its indent prefix and marker WIDTH come from
+  // lineMeta's own record rather than from a guess — an ordered outer
+  // contributes three columns, not two (spec §3.4's errata table) — while the
+  // bullet CHARACTERS are taken back from the source line.
+  //
+  // Only ancestors whose startLine EQUALS the edited block's are collected:
+  // that is what "stands on the same source line" means. A zero-line ancestor
+  // higher up the document, or one belonging to an earlier sibling, names a
+  // different line and must not be touched.
+  function sharedMarkerLinesBefore(lineMeta, firstIdx, editedBlock) {
+    const out = [];
+    // The markers on that source line are its nesting levels, outermost first,
+    // and the LAST one is the edited block's own — so a block's marker is found
+    // by its DEPTH, not by counting the entries collected here. A task ancestor
+    // occupies a marker on the line while contributing no lineMeta entry at
+    // all (see above), which is exactly what a running counter would misalign.
+    const chain = sourceMarkerChain(lines[editedBlock.startLine - 1]);
+    const base = editedBlock.indent - (chain.length - 1);
+    for (let k = 0; k < firstIdx; k++) {
+      const m = lineMeta[k];
+      if (!m || m.blockId === null || m.blockId === undefined) continue;
+      const rec = blocks.find((b) => b.id === Number(m.blockId));
+      if (!rec || rec.endLine >= rec.startLine) continue; // owns a line of its own
+      if (rec.startLine !== editedBlock.startLine) continue;
+      const marker = bulletInSourceStyle(m.marker, chain[rec.indent - base]);
+      out.push((m.indentPrefix + marker).replace(/\s+$/, ''));
+    }
+    return out;
+  }
+
+  function canWysiwygForLi(blockEl) {
+    if (!blockEl) return false;
+    if (blockOwnsNoLine(blockEl)) return false;
+    const res = listMd.serializeBlocks([blockEl]);
+    return armBlockingNames(res.unsupported).length === 0 && res.unsupportedByLi.length === 0;
+  }
+
+  // ── S1: one run scan replaces every "walk up to the outermost UL/OL" ─────
+  // The flat model has no <ul>/<ol> nodes left to walk up to: every list item
+  // is a sibling `.ed-block[data-block-type="li"]` and its depth is
+  // `data-indent`. Six helpers used to reach the enclosing list by DOM
+  // ancestry; they all now go through the scan below.
+  //
+  // RUN (spec §3.8): the sibling items bound to the same parent item. Scanning
+  // outward from a block, a run ends at the first li with a SMALLER indent, at
+  // the first same-indent li whose data-list-type differs, or at the first
+  // non-li block. DEEPER items never break the run — they are descendants of
+  // one of its members.
+  //
+  // Rules (a)/(b)/(c) are bit-for-bit the rule lib/editor/list-md.js's
+  // serializeBlocks() applies internally when it restarts an ordinal. If the
+  // two ever disagree, the symptom is a wrong ordinal or a wrong commit range.
+  //
+  // Rule (d) — a run never crosses a `data-list-start="1"` — has no counterpart
+  // in serializeBlocks() because it never needs one: §3.8's three rules cannot
+  // tell two ADJACENT top-level lists of the same type apart (marked emits a
+  // fresh list token for a bullet-char change, so '- a' followed by '* c' is
+  // two lists whose blocks are all indent 0 / type ul), and before flattening
+  // the two <ul> roots carried that distinction. lib/md2doc.js's renderer
+  // stamps the boundary; this scan honours it, so serializeBlocks() is never
+  // handed a span that straddles two lists and the two can never disagree on a
+  // span that actually reaches it.
+
+  function allBlockEls() {
+    return Array.prototype.slice.call(contentEl.querySelectorAll('.ed-block'));
+  }
+
+  function liAttrs(el) {
+    if (!el || !el.getAttribute || el.getAttribute('data-block-type') !== 'li') return null;
+    return {
+      el: el,
+      indent: Number(el.getAttribute('data-indent')) || 0,
+      listType: el.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul',
+      listStart: el.getAttribute('data-list-start') === '1',
+    };
+  }
+
+  // The nearest li `.ed-block` ancestor of `node` (inclusive), or null.
+  // Text nodes are legal input (Selection boundary points are usually text
+  // nodes), so this walks parentNode by hand rather than using .closest().
+  function closestLiBlock(node) {
+    let n = node;
+    while (n) {
+      if (n.nodeType === 1 && n.getAttribute &&
+          n.classList && n.classList.contains('ed-block') &&
+          n.getAttribute('data-block-type') === 'li') return n;
+      n = n.parentNode;
     }
-    probe.appendChild(liClone);
-    return listMd.serializeList(probe).unsupported.length === 0;
+    return null;
   }
 
-  // Walk up from `el` to find the outermost UL/OL whose parent is NOT a <li>
-  // (i.e. the list-run root — the UL/OL that is directly inside .ed-block or
-  // the document, not a nested sub-list inside another li).
-  function listRunRootOf(el) {
-    let cur = el;
-    let root = null;
-    while (cur) {
-      if (cur.nodeName === 'UL' || cur.nodeName === 'OL') {
-        if (!cur.parentElement || cur.parentElement.nodeName !== 'LI') {
-          root = cur;
+  // Spec §3.8's run of `blockEl`, as an array of block elements in document
+  // order. Empty when `blockEl` is not a live li block.
+  function runBlocksOf(blockEl) {
+    const self = liAttrs(blockEl);
+    if (!self) return [];
+    const all = allBlockEls();
+    const i = all.indexOf(blockEl);
+    if (i < 0) return [];
+    const out = [blockEl];
+    if (!self.listStart) {
+      for (let k = i - 1; k >= 0; k--) {
+        const a = liAttrs(all[k]);
+        if (!a || a.indent < self.indent) break;
+        if (a.indent === self.indent) {
+          if (a.listType !== self.listType) break;
+          out.unshift(all[k]);
         }
+        // Rule (d), scoped to THIS depth. A list-start DEEPER than `self` is a
+        // nested sublist hanging off one of the run's own members — it must not
+        // end the run it lives inside. Only a list-start at `self`'s depth (or
+        // shallower, already handled above) is a boundary for this run.
+        if (a.listStart && a.indent <= self.indent) break;
       }
-      cur = cur.parentElement;
     }
-    return root;
+    for (let k = i + 1; k < all.length; k++) {
+      const a = liAttrs(all[k]);
+      if (!a || a.indent < self.indent) break;
+      if (a.listStart && a.indent <= self.indent) break; // rule (d), this depth
+      if (a.indent === self.indent) {
+        if (a.listType !== self.listType) break;
+        out.push(all[k]);
+      }
+    }
+    return out;
   }
 
-  // Returns { startLine, endLine, firstId } from the first and last .ed-block
-  // li descendants of rootEl, looked up in state.blocks by their data-block-id
-  // (document order is monotonic — Task 3 asserts it — so first/last suffices).
-  function runRangeOf(state, rootEl) {
-    const liEls = Array.prototype.slice.call(rootEl.querySelectorAll('.ed-block'));
-    if (!liEls.length) return null;
-    const firstId = Number(liEls[0].getAttribute('data-block-id'));
-    const lastId  = Number(liEls[liEls.length - 1].getAttribute('data-block-id'));
-    const firstBlock = state.blocks.find((b) => b.id === firstId);
-    const lastBlock  = state.blocks.find((b) => b.id === lastId);
-    if (!firstBlock || !lastBlock) return null;
-    return { startLine: firstBlock.startLine, endLine: lastBlock.endLine, firstId };
+  // The COMMIT UNIT for any list edit: the contiguous block span made up of
+  // the OUTERMOST run reachable from `blockEl` plus every descendant of that
+  // run's members. Returned in document order; empty when `blockEl` is not a
+  // live li block.
+  //
+  // Why the outermost run and not `blockEl`'s own: serializeBlocks() rebuilds
+  // the marker-width stack (spec §3.4) as it walks, so a span that STARTS at
+  // indent 2 has no width recorded for depths 0 and 1 and emits its first line
+  // with NO indent at all — i.e. committing a nested run on its own would
+  // promote it to top level and destroy the nesting. Starting at the outermost
+  // depth is also exactly what the pre-S1 code did (listRunRootOf() walked up
+  // to the UL/OL whose parent was not an <li>, i.e. the whole top-level list),
+  // so the committed byte ranges are unchanged by the flattening.
+  //
+  // What DID change — deliberately, per spec §3.8 rule (b) — is that two
+  // adjacent top-level lists of DIFFERENT type are two spans. Pre-S1 they were
+  // already two separate <ul>/<ol> roots, so this is the same behaviour
+  // expressed without the containers.
+  function listRunOf(blockEl) {
+    const self = liAttrs(blockEl);
+    if (!self) return [];
+    const all = allBlockEls();
+    const i = all.indexOf(blockEl);
+    if (i < 0) return [];
+    // 1. Walk back to the shallowest li that still owns `blockEl` — its
+    //    outermost ancestor item. Stops at the first non-li block.
+    // The walk stops on its own the moment it reaches indent 0, which is where
+    // every list token's first item sits — so it can never cross into the
+    // PREVIOUS list, and rule (d) needs no break of its own here. It must NOT
+    // be skipped for a list-start block at indent > 0: that is a NESTED list's
+    // first item, whose outermost ancestor is still above it in the same list,
+    // and returning a nested-only span would emit the run with no indent
+    // prefix at all — i.e. de-nest it on commit.
+    let anchor = i;
+    let anchorIndent = self.indent;
+    for (let k = i - 1; k >= 0 && anchorIndent > 0; k--) {
+      const a = liAttrs(all[k]);
+      if (!a) break;
+      if (a.indent < anchorIndent) { anchor = k; anchorIndent = a.indent; }
+    }
+    // 2. That ancestor's own §3.8 run gives the span's first and last MEMBER.
+    const run = runBlocksOf(all[anchor]);
+    if (!run.length) return [];
+    const startIdx = all.indexOf(run[0]);
+    let endIdx = all.indexOf(run[run.length - 1]);
+    // 3. Extend past the last member to cover its subtree.
+    // `a.indent <= anchorIndent` already stops at the next list token's first
+    // item (every token starts at indent 0 relative to its own nesting), so no
+    // separate rule-(d) break belongs here — and a DEEPER list-start is a
+    // nested sublist of the last run member, which the span must include.
+    for (let k = endIdx + 1; k < all.length; k++) {
+      const a = liAttrs(all[k]);
+      if (!a || a.indent <= anchorIndent) break;
+      endIdx = k;
+    }
+    return all.slice(startIdx, endIdx + 1);
+  }
+
+  // Returns { startLine, endLine, firstId } for a run span (as returned by
+  // listRunOf()), looked up in state.blocks by data-block-id. Document order is
+  // monotonic in block id, so first/last suffices.
+  //
+  // A span may contain a PROVISIONAL block — splitListItemAtCaret()'s new item,
+  // which has no data-block-id because it does not exist in `lines` yet. Those
+  // are skipped: the range is the source lines the span currently OCCUPIES, and
+  // a provisional block occupies none. (Pre-S1 this fell out for free because
+  // the provisional <li> carried no `ed-block` class and the querySelectorAll
+  // never saw it; the flat model needs it to be a real block element, so the
+  // skip has to be explicit.) Returns null when no member is resolvable.
+  function runRangeOfBlocks(state, runEls) {
+    if (!runEls || !runEls.length) return null;
+    const resolved = [];
+    runEls.forEach((el) => {
+      const raw = el.getAttribute('data-block-id');
+      if (raw === null) return;
+      const b = state.blocks.find((x) => x.id === Number(raw));
+      if (b) resolved.push(b);
+    });
+    if (!resolved.length) return null;
+    const firstBlock = resolved[0];
+    const lastBlock = resolved[resolved.length - 1];
+    return { startLine: firstBlock.startLine, endLine: lastBlock.endLine, firstId: firstBlock.id };
+  }
+
+  // Convenience wrapper kept at the old call shape: takes any node inside a
+  // list item and resolves its own commit span's line range.
+  function runRangeOf(state, node) {
+    return runRangeOfBlocks(state, listRunOf(closestLiBlock(node)));
+  }
+
+  // Re-derives `data-run-start` across the whole document. The attribute is
+  // pure CSS chrome (Task 5 resets the ordered counter on it) and no
+  // serializer reads it, but a structural key changes indents WITHOUT a
+  // re-render for the duration of the commit's round trip, so leaving it stale
+  // would show wrong ordinals for that window. Same rule as the renderer's
+  // liRunStartsHere() and serializeBlocks()'s own ordinal restart.
+  function refreshRunStarts() {
+    const all = allBlockEls();
+    let prev = null;
+    const types = [];
+    all.forEach((el) => {
+      const a = liAttrs(el);
+      if (!a) { prev = null; types.length = 0; return; }
+      // Rule (d): a new list token always opens a new run, and closes the runs
+      // open AT ITS OWN DEPTH AND DEEPER — never the shallower ones, which
+      // belong to the list this token is nested inside. data-list-start is
+      // renderer-owned and never rewritten here: it is the only carrier of the
+      // boundary between two adjacent same-type list tokens.
+      if (a.listStart) types.length = Math.min(types.length, a.indent);
+      const isStart = !prev || a.indent > prev.indent || types[a.indent] !== a.listType;
+      for (let k = types.length - 1; k > a.indent; k--) types[k] = undefined;
+      types[a.indent] = a.listType;
+      prev = a;
+      if (isStart) el.setAttribute('data-run-start', '1');
+      else el.removeAttribute('data-run-start');
+    });
+  }
+
+  // The single place a block's depth is written: `data-indent` is what every
+  // serializer and scan reads, and `--ed-indent` is the CSS mirror the flat
+  // renderer emits alongside it. Writing one without the other makes the
+  // screen disagree with the model for the length of a commit round trip.
+  function setBlockIndent(blockEl, indent) {
+    blockEl.setAttribute('data-indent', String(indent));
+    blockEl.style.setProperty('--ed-indent', String(indent));
+  }
+
+  // Spec §3.4, applied to the DOM: hand the (already-mutated) commit span to
+  // the pure clamp in lib/editor/indent-clamp.js and write back whatever it
+  // says. `opBlockEl` is the block the gesture moved, `opOldIndent` its indent
+  // BEFORE the move (the spec's global convention).
+  //
+  // Scoped to the commit SPAN, never to the whole document: the span is
+  // exactly the set of blocks the following commit re-serializes, so a clamp
+  // confined to it can never widen the byte range an operation touches. On a
+  // document that was legal to begin with — which is every document, since
+  // data-indent is derived from marked's own nesting — this is a no-op, and it
+  // is meant to be. It is here so the ONE definition of "legal indent" lives
+  // in one testable place instead of being re-derived by each key handler.
+  //
+  // Blocks are matched by data-block-id, so a PROVISIONAL block (a split's new
+  // item, id-less) is passed through untouched rather than being addressed by
+  // position.
+  // `opts` is handed straight to clampIndents() — today only `{ removed: true }`,
+  // used by the ⠿ delete below, which must clamp the span it is ABOUT to take a
+  // member out of. The span passed in therefore still CONTAINS `opBlockEl` (it
+  // has to: `opIndex` is an index into it, and rule 2's scope starts after it);
+  // clampIndents() reports no indent for a removed block, so the write-back
+  // below never touches the element that is on its way out.
+  function applyIndentClamp(spanEls, opBlockEl, opOldIndent, opts) {
+    if (!indentClamp || !spanEls || !spanEls.length) return;
+    const opIndex = spanEls.indexOf(opBlockEl);
+    if (opIndex < 0) return;
+    const model = spanEls.map((el, i) => ({
+      id: i, // index-as-id: the span IS the universe here
+      type: el.getAttribute('data-block-type') === 'li' ? 'li' : 'other',
+      indent: Number(el.getAttribute('data-indent')) || 0,
+    }));
+    indentClamp.clampIndents(model, opIndex, opOldIndent, opts || {}).forEach((r) => {
+      const el = spanEls[r.blockId];
+      if (el && (Number(el.getAttribute('data-indent')) || 0) !== r.indent) {
+        setBlockIndent(el, r.indent);
+      }
+    });
   }
 
   function placeCaretAtEnd(el) {
@@ -955,8 +1429,7 @@
     lines = result.lines;
     const okRender = await safeRerenderAll();
     if (!okRender) {
-      const rollback = stack.undo(lines);
-      lines = rollback ? rollback.lines : prevLines;
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
     }
   }
 
@@ -1008,19 +1481,34 @@
         editEl.setAttribute('contenteditable', 'true');
         editEl.classList.add('ed-wys-armed');
       } else if (blockType === 'li') {
-        // Task 6 (Phase 4): per-li arming. Each <li class="ed-block"> is
-        // armed independently: only its own .ed-li-text div becomes
+        // Task 6 (Phase 4): per-li arming. Each
+        // `.ed-block[data-block-type="li"]` is armed independently: only its
+        // own .ed-li-text div becomes
         // contenteditable when canWysiwygForLi holds, so one unsupported item
         // does not degrade its siblings.
         if (editEl && canWysiwygForLi(blockEl)) {
           editEl.setAttribute('contenteditable', 'true');
           editEl.classList.add('ed-wys-armed');
         }
-        // MUST return here — a <li> gets NO ⠿/＋ gutter chrome (overlay
-        // chrome is P4). The unconditional appendChild calls below would
-        // inject <button> children into the <li>, which list-md.js would
-        // classify as content and inline-md.js would flag 'BUTTON' unsupported,
-        // silently degrading every list item. Do NOT remove this return.
+        // S1: the li now gets the same ⠿ as every other block, at every
+        // indent depth. This is only safe because list-md.js's
+        // serializeBlocks() skips the chrome BY CLASS TOKEN (its LI_CHROME
+        // allowlist) — if that allowlist is ever narrowed, every <button>
+        // here reaches the inline serializer as content, every li reports
+        // 'BUTTON' unsupported and the WHOLE document degrades read-only.
+        //
+        // S2 Task 7 (§6's S1 note item 3, 「＋ 對 li 在 S1 隱藏，S2 解除」): the
+        // ＋ is back, in the same order as every other type. What S1 was
+        // waiting for is now true — insertBlockBelow() gates a li anchor on
+        // listRunSupportsStructuralEdit(), anchors the insertion at the end of
+        // the anchor's SUBTREE (so a parent's children are never straddled),
+        // and takes the 清單 kind through the run's own re-serialization, which
+        // is where §3.4's marker-width stack lives. '.ed-insert' is already in
+        // list-md.js's LI_CHROME allowlist, so this adds no NEW element type
+        // for serializeBlocks() to report as unsupported — the `clean` probe in
+        // the S1 li-gutter scenario is what actually holds that.
+        blockEl.appendChild(buildGutterInsertButton());
+        blockEl.appendChild(buildGutterHandle());
         return;
       } else if (editEl && blockType === 'table' && canWysiwygForTable(editEl)) {
         // Task 5 (Phase 3): table cells armed PERMANENTLY at arm time
@@ -1077,51 +1565,55 @@
     return el;
   }
 
-  // The single shared ⠿ menu (heading ± / MD 原始碼 / close) — built once,
-  // moved into whichever block's DOM the user opened it on, same pattern as
-  // `selToolbar` elsewhere in this file. `gutterMenuBlockEl` names which
-  // block it's currently open for.
+  // The single shared ⠿ menu (spec §3.7: 轉換成 › / 複製 / 刪除 / MD 原始碼)
+  // — built once, moved into whichever block's DOM the user opened it on,
+  // same pattern as `selToolbar` elsewhere in this file. `gutterMenuBlockEl`
+  // names which block it's currently open for. Because the node is a
+  // SINGLETON, every per-type visibility decision has to be re-applied on
+  // each open (see toggleGutterMenu below), never set once at build time.
+  //
+  // S2: the heading ± pair is gone from here — §3.5 moved that gesture onto
+  // Tab / Shift+Tab, which call the same changeHeadingDepth() this menu used
+  // to. So is ✕: §3.7 closes the menu by Esc or an outside click, both of
+  // which were already wired (the document-level keydown / click handlers
+  // further down), so removing the button removes a button, not a capability.
   let gutterMenuBlockEl = null;
-  let gutterMenuMinus, gutterMenuPlus;
+  let gutterMenuConvert, gutterMenuDuplicate, gutterMenuDelete, gutterMenuMd;
+  // The 轉換成 submenu: a SECOND singleton, built lazily on demand and torn
+  // down with the menu. It carries `ed-handle-menu` as well as its own class
+  // so it inherits the panel's whole visual language AND so the document-level
+  // outside-click handler's `closest('.ed-handle-menu')` exclusion covers it
+  // without a second selector.
+  let convertSubmenu = null;
 
   function buildGutterMenu() {
     const el = document.createElement('div');
     el.className = 'ed-handle-menu';
 
-    gutterMenuMinus = document.createElement('button');
-    gutterMenuMinus.type = 'button';
-    gutterMenuMinus.className = 'ed-handle-menu-btn';
-    gutterMenuMinus.textContent = '−';
-    gutterMenuMinus.setAttribute('aria-label', 'Decrease heading level');
-    gutterMenuMinus.addEventListener('click', (e) => {
-      e.stopPropagation();
-      const blockEl = gutterMenuBlockEl;
-      closeGutterMenu();
-      changeHeadingDepth(blockEl, -1);
-    });
+    function item(label, aria, onClick) {
+      const b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'ed-handle-menu-btn';
+      b.textContent = label;
+      b.setAttribute('aria-label', aria);
+      b.addEventListener('click', onClick);
+      el.appendChild(b);
+      return b;
+    }
 
-    gutterMenuPlus = document.createElement('button');
-    gutterMenuPlus.type = 'button';
-    gutterMenuPlus.className = 'ed-handle-menu-btn';
-    gutterMenuPlus.textContent = '+';
-    gutterMenuPlus.setAttribute('aria-label', 'Increase heading level');
-    gutterMenuPlus.addEventListener('click', (e) => {
+    // 轉換成 is the one item that does NOT close the menu — it grows a
+    // submenu, and a second press folds it back up.
+    gutterMenuConvert = item('轉換成 ›', 'Convert this block', (e) => {
       e.stopPropagation();
-      const blockEl = gutterMenuBlockEl;
-      closeGutterMenu();
-      changeHeadingDepth(blockEl, 1);
+      if (convertSubmenu) { closeConvertSubmenu(); return; }
+      openConvertSubmenu(gutterMenuConvert);
     });
 
-    const mdBtn = document.createElement('button');
-    mdBtn.type = 'button';
-    mdBtn.className = 'ed-handle-menu-btn';
-    mdBtn.textContent = 'MD 原始碼';
-    mdBtn.setAttribute('aria-label', 'Switch to raw markdown edit');
-    mdBtn.addEventListener('click', (e) => {
+    gutterMenuDuplicate = item('複製', 'Duplicate this block', (e) => {
       e.stopPropagation();
       const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
-      openRawViaGutter(blockEl);
+      duplicateBlockViaMenu(blockEl);
     });
 
     // §10-gap fix: block-level DELETE. Reuses commitListBlockRemoval()
@@ -1131,38 +1623,65 @@
     // just calling it from here too, not touching its implementation) via
     // deleteBlockViaGutter() below, which resolves any open burst first
     // (requirement: structural ops always go through switchAwayFrom()).
-    const deleteBtn = document.createElement('button');
-    deleteBtn.type = 'button';
-    deleteBtn.className = 'ed-handle-menu-btn';
-    deleteBtn.textContent = '刪除';
-    deleteBtn.setAttribute('aria-label', 'Delete this block');
-    deleteBtn.addEventListener('click', (e) => {
+    gutterMenuDelete = item('刪除', 'Delete this block', (e) => {
       e.stopPropagation();
       const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
       deleteBlockViaGutter(blockEl);
     });
 
-    const closeBtn = document.createElement('button');
-    closeBtn.type = 'button';
-    closeBtn.className = 'ed-handle-menu-btn';
-    closeBtn.textContent = '✕';
-    closeBtn.setAttribute('aria-label', 'Close menu');
-    closeBtn.addEventListener('click', (e) => {
+    gutterMenuMd = item('MD 原始碼', 'Switch to raw markdown edit', (e) => {
       e.stopPropagation();
+      const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
+      openRawViaGutter(blockEl);
     });
 
-    el.appendChild(gutterMenuMinus);
-    el.appendChild(gutterMenuPlus);
-    el.appendChild(mdBtn);
-    el.appendChild(deleteBtn);
-    el.appendChild(closeBtn);
     return el;
   }
   const gutterMenu = buildGutterMenu();
 
+  // Spec §3.2's twelve v1 targets, rendered as a panel anchored to the right
+  // of the 轉換成 row. The panel is a CHILD of the menu, and the menu is
+  // `position: absolute`, so it is the submenu's own containing block and
+  // `left: 100%` (lib/md2doc.js) resolves against the menu's padding box —
+  // no viewport arithmetic, and the panel travels with the menu when the menu
+  // is moved into another block.
+  function openConvertSubmenu(anchorBtn) {
+    closeConvertSubmenu();
+    const sub = document.createElement('div');
+    sub.className = 'ed-handle-menu ed-handle-submenu';
+    convertMd.CONVERT_TARGETS.forEach((t) => {
+      const b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'ed-handle-menu-btn';
+      b.textContent = t.label;
+      b.setAttribute('aria-label', 'Convert to ' + t.id);
+      b.addEventListener('click', (e) => {
+        e.stopPropagation();
+        const blockEl = gutterMenuBlockEl;
+        closeGutterMenu();
+        convertBlockViaMenu(blockEl, t.id);
+      });
+      sub.appendChild(b);
+    });
+    sub.style.top = anchorBtn.offsetTop + 'px';
+    anchorBtn.parentNode.appendChild(sub);
+    convertSubmenu = sub;
+  }
+
+  function closeConvertSubmenu() {
+    if (convertSubmenu) { convertSubmenu.remove(); convertSubmenu = null; }
+  }
+
   function closeGutterMenu() {
+    // The submenu lives INSIDE the menu, so removing the menu already detaches
+    // it — but `convertSubmenu` would keep pointing at the detached node and
+    // the next 轉換成 press would read it as "already open" and merely fold a
+    // panel nobody can see. Same stale-singleton hazard `gutterMenuBlockEl`
+    // documents just below, and the reason rerenderAll()'s reset list needs no
+    // second entry: it already calls this.
+    closeConvertSubmenu();
     gutterMenu.remove();
     gutterMenuBlockEl = null;
   }
@@ -1176,11 +1695,40 @@
     // on a DIFFERENT block would otherwise leave two floating menus up at
     // once. closeInsertMenu() is idempotent (safe even when nothing is open).
     closeInsertMenu();
+    // A menu re-opened on another block must never inherit the previous
+    // block's expanded submenu — it was built against THAT block and its
+    // targets close over `gutterMenuBlockEl` at click time, so a stale panel
+    // is a panel that converts the wrong block.
+    closeConvertSubmenu();
     gutterMenuBlockEl = blockEl;
     const blockType = blockEl.getAttribute('data-block-type');
-    const isHeading = blockType === 'heading';
-    gutterMenuMinus.hidden = !isHeading;
-    gutterMenuPlus.hidden = !isHeading;
+    // Spec §7: a table block has no 轉換成 at all (there is no target that
+    // could carry a table's cells, and every one of the twelve would destroy
+    // them).
+    //
+    // 'hr' and 'html' are withheld for a different, measured reason: the
+    // gesture would LIE. convert-md strips a block's marker to get its
+    // content, and an <hr> has no content — its source line IS the marker.
+    // Measured: 'hr' → 項目符號列表 writes '- ---', which marked re-lexes
+    // as an hr again, so the file's bytes change, the block type does not,
+    // and no banner is shown. 'hr' → 文字 is a byte no-op, also silent.
+    // An 'html' block is raw passthrough for the same reason: there is no
+    // marker to strip and no content to re-host. Nothing is lost either way,
+    // but an item that appears to work and does nothing is worse than an
+    // item that is not offered.
+    gutterMenuConvert.hidden = (blockType === 'table' || blockType === 'hr' || blockType === 'html');
+    gutterMenuDuplicate.hidden = false;
+    gutterMenuDelete.hidden = false;
+    // RULING F-O: 'MD 原始碼' is hidden for a list item PERMANENTLY, not as a
+    // phased measure. openRawEditor() replaces the block's innerHTML with a
+    // <textarea>, and a li is one line of a run that is serialized as a whole
+    // — a textarea inside it is content the serializer cannot represent, and
+    // restore() would have to rebuild the marker/check/text chrome from a
+    // string. Every other block type keeps it: the menu is a SINGLETON moved
+    // between blocks, so this must be reset on every open, not set once.
+    // (test/editor-reader-rebind.test.js drives raw-edit through this button
+    // by its exact text on a paragraph.)
+    gutterMenuMd.hidden = (blockType === 'li');
     blockEl.appendChild(gutterMenu);
   }
 
@@ -1392,26 +1940,117 @@
   // recovery idiom used throughout this file), THEN acts.
   async function insertBlockBelow(blockEl, kind) {
     if (!blockEl) return;
-    const blockId = Number(blockEl.getAttribute('data-block-id'));
+    // T7: captured BEFORE switchAwayFrom(), because that is what can renumber
+    // the ids — see captureBlockIdentity()'s comment.
+    const identity = captureBlockIdentity(blockEl);
+    // S2 Task 7: the FOURTH and last call site of the hole 轉換 (Task 2), 刪除
+    // and 複製 (Task 6) already closed, and the one that was latent only
+    // because a li had no ＋ to press. Finding 5a's delegated mousedown
+    // preventDefault() names '.ed-insert' as well as '.ed-handle', so the
+    // burst survives the press and the commit that lands inside
+    // switchAwayFrom() below can be a rewrite of THIS block's own source —
+    // in which case reresolveBlockEl()'s source fingerprint is guaranteed to
+    // miss, because WE are the reason the source changed, and the gesture is
+    // dropped with '文件已更新，請重試這個操作' having done nothing. The
+    // narrowed re-resolve (startLine + type, no fingerprint) is used ONLY
+    // when the session that just committed was this block's OWN;
+    // reresolveBlockEl() keeps its fingerprint for everybody else.
+    const selfSession = ownsOpenSession(blockEl);
     const ok = await switchAwayFrom();
     if (!ok) return;
     let liveBlockEl = blockEl;
     if (!document.body.contains(blockEl)) {
-      liveBlockEl = document.querySelector('.ed-block[data-block-id="' + blockId + '"]');
-      if (!liveBlockEl) return;
+      liveBlockEl = reresolveBlockEl(identity) ||
+        (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
+      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    }
+    // T7 fix round 1 (LOW-2): same refusal deleteBlockViaGutter() makes below,
+    // for the same reason and against the same LIVE block. A block that owns
+    // no source line has endLine === startLine - 1 (blockOwnsNoLine()), and
+    // commitBlockInsertion() inserts at `endLine + 1` — which for an inverted
+    // range is the line ABOVE the block, i.e. inside whatever precedes it. It
+    // also reads `state.lines[endLine]` to decide the trailing blank, so it
+    // samples a line belonging to somebody else. Latent today only because a
+    // li block grows no ＋ until S2; S2 is next, and a guard that has to be
+    // remembered later is a guard that will not be.
+    if (blockOwnsNoLine(liveBlockEl)) {
+      refuseStructuralListEdit(NO_SOURCE_LINE_INSERT_MESSAGE);
+      return;
     }
-    const liveBlockId = Number(liveBlockEl.getAttribute('data-block-id'));
-    const block = blocks.find((b) => b.id === liveBlockId);
-    if (!block) return;
     const newLines = BLOCK_SKELETONS[kind];
     if (!newLines) return;
+
+    // ── S2 Task 7: a LIST ITEM anchor (§6's S1 note item 3) ────────────────
+    //
+    // Two things change, and both were measured against the pure core rather
+    // than reasoned from the plan:
+    //
+    // 1. THE INSERTION POINT IS THE END OF THE ANCHOR'S SUBTREE, not the
+    //    anchor's own last line. This is the ruling §4.3 already made for
+    //    複製 (「副本插在該 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
+    //    '# 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
+    //    subtree the same gesture yields
+    //    '# Doc\n\n- alpha\n  - child\n    - grand\n\n<ZWSP>\n', whose
+    //    token list holds no `code` at all. No kind needs to refuse.
+    //
+    // 2. THE 清單 KIND DOES NOT GO THROUGH commitBlockInsertion() AT ALL.
+    //    That function ALWAYS writes a leading blank line (see its own
+    //    comment), and for a list that blank is the §4.3 rule 2 defect:
+    //    measured, '# Doc\n\n- alpha\n  - child\n\n  -\n' has a NESTED
+    //    list with loose === true, so every item of it grows a <p>,
+    //    serializeBlocks() pushes 'P' for each and the run degrades read-only
+    //    with no banner. Same fork 複製 hit in Task 6, and the same answer:
+    //    route the li through its own run's re-serialization, which emits no
+    //    blank at all, re-runs §3.8's renumbering, and — the point of carry 2
+    //    — takes the new item's indent prefix from the serializer's own
+    //    marker-width stack instead of re-deriving it. There is deliberately
+    //    no `indentPrefixOf()` here: `' '.repeat(indent * 2)` is what §3.4
+    //    forbids, and even reading lineMeta's `indentPrefix` back would be a
+    //    second copy of an arithmetic list-md.js already owns.
+    //
+    // The §4.3 run-wide gate applies on the way in, like every other
+    // structural op. `columnOnly` is the honest option: no EXISTING item's
+    // content or line count is rewritten — the only bytes that move in a
+    // bystander are its marker and leading columns (§3.8 renumbering, applied
+    // as §3.4's colDelta by the carryOver replay), which is exactly the
+    // criterion listRunSupportsStructuralEdit() documents. Without it a
+    // single hard-wrapped item anywhere in the run would veto the ＋, which
+    // on this repo's own CHANGELOG.md is every run.
+    let anchorEl = liveBlockEl;
+    if (liveBlockEl.getAttribute('data-block-type') === 'li') {
+      const run = listRunOf(liveBlockEl);
+      if (!run.length) return;
+      if (!listRunSupportsStructuralEdit(run, null, { columnOnly: true })) {
+        refuseStructuralListEdit();
+        return;
+      }
+      const subtree = subtreeBlocksAfter(liveBlockEl,
+        Number(liveBlockEl.getAttribute('data-indent')) || 0);
+      anchorEl = subtree.length ? subtree[subtree.length - 1] : liveBlockEl;
+      if (kind === 'list') { await insertListItemAfter(liveBlockEl, run, anchorEl); return; }
+      // The subtree's last member is a li like any other, so it can own no
+      // source line for the same reason the anchor could — and it is the block
+      // commitBlockInsertion() is about to read `endLine` and `lines[endLine]`
+      // off. Re-checked against the block actually used.
+      if (blockOwnsNoLine(anchorEl)) {
+        refuseStructuralListEdit(NO_SOURCE_LINE_INSERT_MESSAGE);
+        return;
+      }
+    }
+    const liveBlockId = Number(anchorEl.getAttribute('data-block-id'));
+    const block = blocks.find((b) => b.id === liveBlockId);
+    if (!block) return;
     const result = commitBlockInsertion({ lines, blocks, stack }, liveBlockId, newLines);
     const prevLines = lines;
     lines = result.lines;
     const okRender = await safeRerenderAll();
     if (!okRender) {
-      const rollback = stack.undo(lines);
-      lines = rollback ? rollback.lines : prevLines;
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
       return;
     }
     // §10-gap fix (review): mark the freshly-inserted block "pristine" —
@@ -1423,33 +2062,856 @@
     await focusInsertedBlock(result.newStartLine, kind);
   }
 
+
+  // 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
+  // stays TIGHT — see insertBlockBelow()'s note 2), §3.8's renumbering for
+  // free, and the new item's indent prefix straight out of list-md.js's
+  // marker-width stack.
+  //
+  // `lastEl` is the end of the anchor's subtree, so the new item is the
+  // anchor's SIBLING and lands after the anchor's children rather than
+  // between them.
+  async function insertListItemAfter(liEl, run, lastEl) {
+    // Captured BEFORE the new item enters the span: it carries no
+    // data-block-id (it does not exist in `lines` yet), so runRangeOfBlocks()
+    // would skip it — but on an insertion after the span's LAST member the
+    // derived range would then silently stop one line short of nothing at all.
+    // Passing the pre-mutation range is the same discipline duplicateListItem()
+    // uses, for the same reason.
+    const range = runRangeOfBlocks({ lines, blocks, stack }, run);
+    if (!range) return;
+    const at = run.indexOf(lastEl);
+    if (at < 0) return;
+    const newLi = buildProvisionalListItem(liEl);
+    const span = run.slice(0, at + 1).concat([newLi], run.slice(at + 1));
+    mutateListRun(() => {
+      lastEl.parentNode.insertBefore(newLi, lastEl.nextSibling);
+    });
+    // No `mutatedEl`: nothing that already existed had its content rewritten,
+    // so every existing member is replayed from the file's own bytes and a
+    // '~5px' stays a '~5px'. The new item has no id and is skipped by
+    // bystanderCarryOver() on its own.
+    const carry = bystanderCarryOver(span);
+    // The SAME map commitListStructure() is about to use — runLineOfBlock()
+    // is an index INTO the lines that map produces, so rebuilding it here
+    // would only usually be the same answer.
+    const focusLine = runLineOfBlock(span, newLi, carry);
+    await commitListStructure(span, focusLine, false,
+      { presetRange: range, carryOver: carry });
+  }
+
+  // A brand-new, empty list item that will become real on the next commit —
+  // the same provisional-block shape splitListItemAtCaret() builds (no
+  // data-block-id: it owns no source line yet, and the commit's rerenderAll()
+  // replaces it with a real, server-numbered block).
+  //
+  // It inherits `data-list-type` and `data-task` from the anchor, NOT the
+  // 清單 menu label's implied bullet. §3.8 rule (b) is why: a different
+  // data-list-type ENDS the run, so a bullet dropped into an ordered run
+  // would split it into three list tokens and renumber what is left. Enter on
+  // a list item (splitListItemAtCaret above) already inherits both, so this is
+  // the established answer rather than a new one.
+  //
+  // `data-list-start` is deliberately NOT copied: it is the only carrier of
+  // "marked opened a new list token here" (§3.8 rule (d)) and a new sibling
+  // inside an existing run is never a token boundary — copying it would
+  // restart the ordinal counter mid-run.
+  function buildProvisionalListItem(anchorLi) {
+    const el = document.createElement('div');
+    el.className = 'ed-block';
+    el.setAttribute('data-block-type', 'li');
+    el.setAttribute('data-list-type', anchorLi.getAttribute('data-list-type') || 'ul');
+    const isTask = anchorLi.getAttribute('data-task') === '1';
+    el.setAttribute('data-task', isTask ? '1' : '0');
+    setBlockIndent(el, Number(anchorLi.getAttribute('data-indent')) || 0);
+    const marker = document.createElement('span');
+    marker.className = 'ed-li-marker';
+    marker.setAttribute('aria-hidden', 'true');
+    el.appendChild(marker);
+    // A fresh item is never checked — nothing in the anchor's line says
+    // otherwise. buildLiCheckbox() is the one place that markup lives, so the
+    // renderer and this stay byte-identical (see its own comment).
+    if (isTask) el.appendChild(buildLiCheckbox());
+    const text = document.createElement('div');
+    text.className = 'ed-li-text';
+    el.appendChild(text);
+    return el;
+  }
+
+  // ── S2 spec §4.3: 轉換成 ────────────────────────────────────────────────
+  //
+  // The written gesture order is fixed: closeGutterMenu() (the menu item's own
+  // click handler already did it) -> switchAwayFrom() -> re-locate the block by
+  // startLine -> operate. The SOURCE is the resolved `lines`, never the DOM.
+  //
+  // Why line-level rather than "mutate the DOM and re-serialize the run like
+  // every other structural op": list-md.js's serializeBlocks() pushes the
+  // uppercased block type into `unsupported` for any non-`li` block inside the
+  // span it is given, which is EXACTLY the shape a conversion produces — every
+  // li -> heading would hit the degrade path and refuse itself. Reading `lines`
+  // also means the inline content is never re-serialized, so escapeText() never
+  // runs over it and a `~5px` in the converted block stays `~5px`.
+  async function convertBlockViaMenu(blockEl, target) {
+    if (!blockEl || !target) return;
+    const identity = captureBlockIdentity(blockEl);
+    // Whether the session switchAwayFrom() is about to resolve belongs to THIS
+    // block. Finding 5a's mousedown preventDefault() deliberately keeps a dirty
+    // burst alive across the ⠿ press, so the commit that lands inside
+    // switchAwayFrom() below can be a rewrite of the very block we are about to
+    // convert — in which case reresolveBlockEl()'s source fingerprint is
+    // guaranteed to miss, because WE are the reason the source changed. That is
+    // not a dropped gesture; startLine + type still name the block, and the
+    // fingerprint's job (proving an UNRELATED commit did not move somebody else
+    // into this slot) is done by those two here.
+    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) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    }
+    // Same refusal deleteBlockViaGutter() makes, for the same reason: a block
+    // that owns no source line has an INVERTED range (endLine === startLine-1),
+    // and every commit helper handed one does something plausible and wrong.
+    if (blockOwnsNoLine(liveBlockEl)) { refuseStructuralListEdit(NO_SOURCE_LINE_MESSAGE); return; }
+    const liveBlockId = Number(liveBlockEl.getAttribute('data-block-id'));
+    const rec = blocks.find((b) => b.id === liveBlockId);
+    if (!rec) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    const kind = liveBlockEl.getAttribute('data-block-type');
+
+    // §4.3's run-wide gate: 轉換／複製／刪除／拖曳 all pass through
+    // listRunSupportsStructuralEdit() BEFORE any mutation, the same door
+    // Tab/Enter/checkbox already use. Its input is §3.4 rule 2's SCOPE, which
+    // is exactly what listRunOf() returns (the outermost run PLUS every
+    // descendant of its members) — see deleteListItemViaGutter()'s own note.
+    //
+    // ORDERING IS LOAD-BEARING, not incidental. This sits AHEAD of the
+    // not-yet-implemented refusals below and, further down, of stripMarker():
+    // a multi-line li must report §4.1's 「此清單含不支援的格式，無法調整結構」
+    // and not convert-md.js's per-block 「此區塊的格式無法轉換」, which is what
+    // it would get if stripMarker() saw it first (that function refuses a
+    // multi-line li too, for its own, narrower reason). The runtime scenario
+    // 'a multi-line li refuses with the §4.1 banner' asserts the MESSAGE, so
+    // it is what notices if this order is ever flipped.
+    //
+    // A conversion is NOT column-only (§4.1 修訂 2): it rewrites the item's
+    // own text or line count, so a multi-line li refuses as a TARGET while
+    // remaining a perfectly good bystander.
+    let liRun = null;
+    if (kind === 'li') {
+      liRun = listRunOf(liveBlockEl);
+      if (!liRun.length) return;
+      if (!listRunSupportsStructuralEdit(liRun, liveBlockEl)) { refuseStructuralListEdit(); return; }
+    }
+
+    // S2 Task 3: li → a LIST target. The block stays a li, so the run stays a
+    // run and the existing re-serialization machinery applies unchanged.
+    if (kind === 'li' && convertMd.targetIsList(target)) {
+      await convertListItemType(liveBlockEl, liRun, target);
+      return;
+    }
+    // S2 Task 4: li → a NON-list target. The item LEAVES the run, so the span
+    // has to be rebuilt in three pieces and §4.3 rule 1's blank lines put
+    // between them — the plain path below would leave the converted line
+    // mid-list with no separator and lazy continuation would swallow it into
+    // the item above (measured, §4.3 rule 1).
+    if (kind === 'li') {
+      await convertListItemAway(liveBlockEl, liRun, rec, target);
+      return;
+    }
+    // S2 Task 5: a non-list block BECOMES a li, so §4.3 rule 2's looseness
+    // policy applies — eat the separator to an adjacent run of the same list
+    // type, or the merged list goes LOOSE and every item of it degrades
+    // read-only. Same rule, same helper the li → li path above uses.
+    if (convertMd.targetIsList(target)) {
+      await convertBlockIntoList(liveBlockEl, rec, kind, target);
+      return;
+    }
+
+    const src = lines.slice(rec.startLine - 1, rec.endLine);
+    const stripped = convertMd.stripMarker(src, kind);
+    if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+    const newLines = convertMd.emitAs(stripped.content, target, {});
+
+    const result = commitRangeEdit({ lines, blocks, stack },
+      rec.startLine, rec.endLine, newLines.join('\n'));
+    // Nothing changed (converting an H2 to 標題 2) — and nothing was pushed
+    // onto the undo stack either, so there is nothing to render or roll back.
+    if (result.op === null) return;
+    const prevLines = lines;
+    lines = result.lines;
+    const okRender = await safeRerenderAll();
+    if (!okRender) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
+  // Is the editor session switchAwayFrom() would resolve open on THIS block?
+  // Both shapes count — the always-on WYSIWYG burst and the older raw-edit /
+  // table-cell `activeEditor` — because resolveOpenSession() commits either.
+  function ownsOpenSession(blockEl) {
+    if (currentBurst && currentBurst.blockEl === blockEl) return true;
+    if (activeEditor && activeEditor.blockEl === blockEl) return true;
+    return false;
+  }
+
+  // The narrowed re-resolve for the case above: startLine and type must still
+  // match, but the source is allowed to differ because our own switchAwayFrom()
+  // just rewrote it. Deliberately NOT folded into reresolveBlockEl() — every
+  // other caller of that function needs the fingerprint, and a shared helper
+  // that sometimes skips it is the shape that lets a future call site act on a
+  // block the user never pointed at.
+  function reresolveBlockElAfterSelfCommit(identity) {
+    if (!identity) return null;
+    const at = blocks.find((b) => b.startLine === identity.startLine);
+    if (!at || at.type !== identity.type) return null;
+    return document.querySelector('.ed-block[data-block-id="' + at.id + '"]');
+  }
+
+  // S2 Task 6 — 複製 (§4.3).
+  //
+  // The copy is inserted after the block's ENTIRE SUBTREE, never after its own
+  // line. The spec records the measurement and it reproduces here:
+  //   after the subtree  '- a\n  - a1\n- a\n- b\n'
+  //     -> items ['- a\n  - a1\n', '- a\n', '- b']   (a keeps its child)
+  //   after a's own line '- a\n- a\n  - a1\n- b\n'
+  //     -> items ['- a\n', '- a\n  - a1\n', '- b']   (the COPY got a1)
+  // Both lex cleanly and both are tight, so nothing but the item boundaries
+  // tells them apart — which is why the runtime scenario asserts the raws.
+  //
+  // TWO commit paths, and which one each case takes was MEASURED against the
+  // pure core, not reasoned from symmetry:
+  //
+  //  * a NON-li block goes through commitBlockInsertion(), which IS this
+  //    operation and already owns the blank-line policy (see :170-179).
+  //    Measured on ['# Doc','','alpha',''] with body ['alpha']:
+  //    '# Doc\n\nalpha\n\nalpha\n'.
+  //  * a li does NOT — this is the trap. commitBlockInsertion() ALWAYS
+  //    inserts a leading blank line. Measured on ['# Doc','','- a','- b','']
+  //    with body ['- a'] it returns '# Doc\n\n- a\n\n- a\n\n- b\n', and
+  //    marked.lexer() reports that as ONE list with loose === true. Every item
+  //    of a loose list renders as <p>, serializeBlocks() pushes 'P' for each of
+  //    them (list-md.js:462) and the WHOLE run degrades read-only with no
+  //    banner — §4.3 rule 2's defect, re-opened by a duplicate instead of by a
+  //    conversion. A li therefore duplicates through its own RUN's
+  //    re-serialization (duplicateListItem() below), which emits no blank at
+  //    all and re-runs §3.8's renumbering on the way.
+  //
+  // Neither path re-serializes the copy's CONTENT: the non-li path slices
+  // `lines`, and the li path carries the clone through bystanderCarryOver()
+  // under the ORIGINAL's block id, so list-md.js replays the file's own bytes
+  // for it and only re-states the marker. Both keep a `~5px` a `~5px`.
+  async function duplicateBlockViaMenu(blockEl) {
+    if (!blockEl) return;
+    const identity = captureBlockIdentity(blockEl);
+    // Finding 5a's mousedown preventDefault() deliberately keeps a dirty burst
+    // alive across the ⠿ press, so the commit that lands inside
+    // switchAwayFrom() below can be a rewrite of the very block we are about
+    // to duplicate — in which case reresolveBlockEl()'s SOURCE fingerprint is
+    // guaranteed to miss, because WE are the reason the source changed. Same
+    // narrowed recovery convertBlockViaMenu() uses, for the same reason; see
+    // reresolveBlockElAfterSelfCommit().
+    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) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    }
+    // Same refusal deleteBlockViaGutter() and convertBlockViaMenu() make, for
+    // the same reason: a block that owns no source line has an INVERTED range
+    // (endLine === startLine - 1) and every commit helper handed one does
+    // something plausible and wrong.
+    if (blockOwnsNoLine(liveBlockEl)) { refuseStructuralListEdit(NO_SOURCE_LINE_MESSAGE); return; }
+    const liveBlockId = Number(liveBlockEl.getAttribute('data-block-id'));
+    const rec = blocks.find((b) => b.id === liveBlockId);
+    if (!rec) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+
+    if (liveBlockEl.getAttribute('data-block-type') === 'li') {
+      await duplicateListItem(liveBlockEl);
+      return;
+    }
+
+    const result = commitBlockInsertion({ lines, blocks, stack }, liveBlockId,
+      lines.slice(rec.startLine - 1, rec.endLine));
+    if (result.op === null) return;
+    const prevLines = lines;
+    lines = result.lines;
+    if (!(await safeRerenderAll())) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
+  // The li half of 複製. The copy 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 (§4.3: 複製與刪除均為單一 undo), no leading blank, and
+  // §3.8's renumbering falls out of the re-serialization ('1. alpha' duplicated
+  // gives '1. alpha / 2. alpha / 3. bravo', not '1. alpha / 1. alpha / 2.
+  // bravo').
+  async function duplicateListItem(liEl) {
+    const run = listRunOf(liEl);
+    if (!run.length) return;
+    // §4.3's run-wide gate — 轉換／複製／刪除／拖曳 each make this call for
+    // themselves; there is no shared helper. Its input is §3.4 rule 2's scope,
+    // which is exactly what listRunOf() returns (the outermost run PLUS every
+    // descendant of its members). A duplicate is NOT column-only (§4.1 修訂 2:
+    // it adds the item's lines over again), so a multi-line li refuses as a
+    // TARGET while remaining a perfectly good bystander.
+    if (!listRunSupportsStructuralEdit(run, liEl)) { refuseStructuralListEdit(); return; }
+    // Captured BEFORE the copy enters the span. The copy carries the
+    // ORIGINAL's data-block-id — that is what makes bystanderCarryOver() replay
+    // its bytes rather than re-escape them — so runRangeOfBlocks() would
+    // resolve it to the original's record, and on a duplicate of the span's
+    // LAST member that silently re-states the range's end line.
+    const range = runRangeOfBlocks({ lines, blocks, stack }, run);
+    if (!range) return;
+
+    // §4.3, measured: after the SUBTREE, not after the item's own line.
+    // subtreeBlocksAfter() is the flat model's subtree — the contiguous run of
+    // following blocks at a STRICTLY greater indent — and listRunOf() already
+    // covers every one of them, so the insertion point is always inside `run`.
+    const subtree = subtreeBlocksAfter(liEl, Number(liEl.getAttribute('data-indent')) || 0);
+    const lastEl = subtree.length ? subtree[subtree.length - 1] : liEl;
+    const at = run.indexOf(lastEl);
+    if (at < 0) return;
+
+    const copy = liEl.cloneNode(true);
+    // `data-list-start` is the ONLY carrier of "marked's lexer opened a new
+    // list token here" (§3.8 rule (d)) and serializeBlocks() resets the
+    // ordinal counter on it. A copy is never a token boundary — it sits inside
+    // the run it was cloned from — so a clone that kept the attribute would
+    // restart the numbering: duplicating the first item of '1. alpha / 2.
+    // bravo' emits '1. alpha / 1. alpha / 2. bravo'.
+    copy.removeAttribute('data-list-start');
+    const span = run.slice(0, at + 1).concat([copy], run.slice(at + 1));
+    mutateListRun(() => {
+      lastEl.parentNode.insertBefore(copy, lastEl.nextSibling);
+    });
+    // No `mutatedEl`: nothing in this span had its CONTENT rewritten in the
+    // DOM, the copy included. The map is what keeps both lines byte-identical
+    // to the file — dropping it entirely re-serializes them through
+    // inline-md.js's escapeText() and a '~5px' comes back '\~5px' (measured;
+    // the 'the copy is not re-escaped' scenario is what notices).
+    //
+    // ⚠ MEASURED, and worth stating because it is NOT the usual contract:
+    // passing `liEl` here would be INERT, unlike at every other call site.
+    // bystanderCarryOver() keys the map on the block ID, and the copy carries
+    // the ORIGINAL's id — so the copy's own pass re-adds the very entry the
+    // exclusion just skipped. The argument is omitted because it is wrong in
+    // principle (nothing was mutated), not because a test would catch it.
+    //
+    // That shared id is also what makes ONE map entry serve both lines, while
+    // list-md.js re-states each line's marker from that element's OWN
+    // attributes — which is the §3.8 renumbering, and which is also how the
+    // copy keeps its 型態 / 縮排 / 勾選狀態.
+    await commitListStructure(span, null, false,
+      { presetRange: range, carryOver: bystanderCarryOver(span) });
+  }
   // Deletes `blockEl`'s ENTIRE line range (generalizing commitListBlockRemoval()
   // — unchanged, see its own comment — to any block type, not just an
   // emptied-out list). Same resolve-first / re-query-live-block-by-id
   // precondition as insertBlockBelow() above.
   async function deleteBlockViaGutter(blockEl) {
     if (!blockEl) return;
-    const blockId = Number(blockEl.getAttribute('data-block-id'));
+    // T7: same startLine + source-fingerprint recovery as insertBlockBelow()
+    // above, and the stake here is higher — an id shift used to make this
+    // delete a DIFFERENT block's lines, with the ⠿ menu the user pressed
+    // pointing at a block that survived.
+    const identity = captureBlockIdentity(blockEl);
+    // S2 Task 6: the SAME hole convertBlockViaMenu() closed in Task 2, which
+    // this path never got. Finding 5a's mousedown preventDefault() keeps a
+    // dirty burst alive across the ⠿ press, so the commit that lands inside
+    // switchAwayFrom() below can be a rewrite of the very block being deleted
+    // — and reresolveBlockEl()'s fingerprint is that block's SOURCE, so it is
+    // guaranteed to MISS, because WE are the reason the source changed.
+    // Measured before this line existed: edit a paragraph, press ⠿ without
+    // blurring, 刪除 — the gesture was dropped with '文件已更新，請重試這個操作'
+    // and the block stayed on screen. The narrowed re-resolve (startLine +
+    // type, no fingerprint) is used ONLY when the session that just committed
+    // was this block's OWN; reresolveBlockEl() keeps its fingerprint for
+    // everybody else.
+    const selfSession = ownsOpenSession(blockEl);
     const ok = await switchAwayFrom();
     if (!ok) return;
     let liveBlockEl = blockEl;
     if (!document.body.contains(blockEl)) {
-      liveBlockEl = document.querySelector('.ed-block[data-block-id="' + blockId + '"]');
-      if (!liveBlockEl) return;
+      liveBlockEl = reresolveBlockEl(identity) ||
+        (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
+      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
     }
     const liveBlockId = Number(liveBlockEl.getAttribute('data-block-id'));
     const block = blocks.find((b) => b.id === liveBlockId);
     if (!block) return;
+    // Task 4 fix round 1 (Critical): refuse a block that owns no source line.
+    // Its range is INVERTED (endLine === startLine - 1 — see blockOwnsNoLine()),
+    // and commitListBlockRemoval() -> commitRangeRemoval() does not guard
+    // `endLine >= startLine`: with sl=5, el=4 the blank-line absorption reads
+    // state.lines[sl - 2], which for an inverted range is a blank line
+    // belonging to a DIFFERENT block, finds it blank, and deletes it. Nothing
+    // visible happens — no error, no banner, the .ed-block count is unchanged
+    // — but the file loses a separator (measured: '# Doc\n\n- a\n\n- - b\n'
+    // -> '# Doc\n\n- a\n- - b\n').
+    //
+    // Same predicate canWysiwygForLi() already refuses on, so "cannot be
+    // armed" and "cannot be deleted" stay one decision. The ⠿ itself is NOT
+    // gated on it: Task 4 requires every block to have a handle, and hiding it
+    // would trade that requirement for a delete-path bug. Re-checked against
+    // the LIVE block, after switchAwayFrom()'s possible re-render renumbered
+    // the ids.
+    if (blockOwnsNoLine(liveBlockEl)) { refuseStructuralListEdit(NO_SOURCE_LINE_MESSAGE); return; }
+    // Spec §6, "S1 期間的已知危險" item 1: a LIST ITEM's delete is not a line
+    // splice. S1 is what first put a ⠿ on a li, and the plain range removal
+    // below corrupts a list three separate ways — see
+    // deleteListItemViaGutter() for the measurements and the routing.
+    if (liveBlockEl.getAttribute('data-block-type') === 'li') {
+      await deleteListItemViaGutter(liveBlockEl);
+      return;
+    }
     const result = commitListBlockRemoval({ lines, blocks, stack }, liveBlockId);
     const prevLines = lines;
     lines = result.lines;
     const okRender = await safeRerenderAll();
     if (!okRender) {
-      const rollback = stack.undo(lines);
-      lines = rollback ? rollback.lines : prevLines;
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
     }
   }
 
+  // Spec §6, "S1 期間的已知危險" item 1 — the ⠿ delete of a LIST ITEM.
+  //
+  // Up to S1 this path did not exist: armEditables() returned before the
+  // gutter chrome for a li, so the menu (and therefore its 刪除) was
+  // unreachable on one. S1 gives every block a ⠿, which connected the
+  // block-type-agnostic commitListBlockRemoval() to the most natural gesture
+  // in the new UI — and that function deletes ONE BLOCK'S LINE RANGE, which is
+  // the wrong unit for a list in three separate ways, all measured with a real
+  // gesture plus Ctrl+S:
+  //
+  //   * its blank-line absorption is correct for a standalone block and wrong
+  //     for a run member: the blank ABOVE the run still separates the
+  //     SURVIVORS from whatever precedes them. 'Para.\n\n1. a\n2. b\n3. c\n'
+  //     came back 'Para.\n2. b\n3. c\n' — one paragraph, three items gone,
+  //     no banner.
+  //   * no §3.4 clamp, so a child outlives its parent at an indent nothing
+  //     anchors: '# T\n\n- a\n    - deep\n- b\n' left '    - deep' four
+  //     columns after a heading, i.e. an INDENTED CODE BLOCK.
+  //   * no re-serialization of the survivors, so an ordered run kept its old
+  //     ordinals on disk ('2. b / 3. c') while the CSS counter showed 1,2 —
+  //     the file and the screen disagreeing until somebody types in that run.
+  //
+  // The sequence is convertEmptyTopLevelLiToParagraph()'s, not a new one:
+  // capture the span's range BEFORE mutating (removing the last item leaves
+  // commitListStructure() nothing to derive it from), clamp, remove, then
+  // commit the re-serialized survivors over that range with every one of them
+  // carried over verbatim — nothing here rewrites any survivor's CONTENT, only
+  // its marker and its leading columns.
+  async function deleteListItemViaGutter(liEl) {
+    const run = listRunOf(liEl);
+    if (!run.length) return;
+    // §4.3's run-wide gate, whose input is §3.4 rule 2's scope — which is
+    // exactly what listRunOf() returns (the outermost run PLUS every
+    // descendant of its members), so the deeper runs this delete is about to
+    // re-indent are covered, not just the target's own. Deleting is NOT
+    // column-only: it removes the target's lines outright, so a multi-line
+    // target refuses per §4.1.
+    if (!listRunSupportsStructuralEdit(run, liEl)) { refuseStructuralListEdit(); return; }
+    const range = runRangeOfBlocks({ lines, blocks, stack }, run);
+    if (!range) return;
+    const oldIndent = Number(liEl.getAttribute('data-indent')) || 0;
+    const survivors = run.filter((el) => el !== liEl);
+    mutateListRun(() => {
+      // Clamp FIRST, while `liEl` is still in the span: `{ removed: true }` is
+      // what tells the pure function that this block can no longer anchor
+      // anything, and rule 2's scope is measured from its position.
+      applyIndentClamp(run, liEl, oldIndent, { removed: true });
+      removeListItem(liEl);
+    });
+    // No `mutatedEl`: the deleted block is not among the survivors, and every
+    // survivor's own bytes are exactly what the file already holds. The marker
+    // is re-stated by the serializer regardless of the carry-over, which is
+    // what renumbers the run (§3.8) and applies the clamped indent.
+    await commitListStructure(survivors, null, false,
+      { presetRange: range, carryOver: bystanderCarryOver(survivors) });
+  }
+
+  // S2 Task 3 — 轉換成 › 項目符號列表 / 編號列表 / 待辦清單 on a li.
+  //
+  // The block STAYS a li, which is what makes this the easy list shape: the
+  // run stays a run, so nothing here has to reach for convert-md.js at all.
+  // The two attributes are flipped in the DOM and the whole span goes back
+  // through commitListStructure() exactly like every other structural list op
+  // — which is also what re-runs §3.8's renumbering (a type change splits the
+  // run at this item, so both halves restart at 1) and §3.4's marker-width
+  // stack (a child under a '1. ' parent moves from column 2 to column 3).
+  //
+  // `run` and the §4.3 gate are the CALLER's (convertBlockViaMenu): the gate
+  // has to sit ahead of every other refusal so a multi-line li reports §4.1's
+  // banner, and re-deriving the run here would walk `allBlockEls()` twice.
+  //
+  // MEASURED, and it contradicts the plan, which pinned blank lines either
+  // side of the converted item: none are emitted and none are needed.
+  // `marked.lexer('- alpha\n1. bravo\n- charlie\n')` already returns THREE
+  // list tokens — a marker-type change interrupts a list on its own. §4.3
+  // rule 1's blank line is about li → NON-LIST (Task 4), where a bare
+  // paragraph line really would be swallowed as a lazy continuation.
+  //
+  // `data-list-type` and `data-task` are §4.1's two ORTHOGONAL axes, so 待辦
+  // 清單 is 'ul' + task and switching to 項目符號列表 removes the checkbox
+  // rather than merely unchecking it — a plain bullet has nowhere in the
+  // markdown to store checkedness.
+  // ── §4.3 rule 2 (the looseness trap), in its 2026-08-30 revised form ──────
+  //
+  // MEASURED, twice, and the second measurement is what the revision is about:
+  //   marked.lexer('- a\n- b\n- c\n')   → ONE list, loose === false
+  //   marked.lexer('- a\n- b\n\n- c\n') → ONE list, loose === TRUE
+  // A blank line between two lists of the SAME marker type does not separate
+  // them; it makes the single list they form LOOSE. Every item of a loose list
+  // renders as `<p>…</p>`, serializeBlocks() reports 'P' for each of them
+  // (list-md.js:56-70 documents the ruling, :462 is the push) and the whole run
+  // degrades read-only — with NO banner, because nothing refused anything.
+  //
+  // The spec's original wording keyed the rule on 「來源是非清單」. That is
+  // wrong, and the counter-example was measured in the live editor during S2
+  // Task 3:
+  //   start   '# Doc\n\n- a\n\n1. b\n'  → list|space|list, BOTH tight
+  //   gesture 轉換成 › 項目符號列表 on `b`
+  //   bytes   '# Doc\n\n- a\n\n- b\n'   → ONE list, loose === true
+  //   after   every structural gesture on that run refuses with §4.1's banner
+  // One li → li conversion froze a run the user could no longer restructure.
+  // The ruling therefore keys on 「轉換結果是 li」: whatever the source was, if
+  // the RESULT is a li, the separator to a same-type neighbour must be eaten.
+  //
+  // Two consequences that are not obvious:
+  //
+  // 1. The blank line being eaten lies OUTSIDE listRunOf()'s span — it belongs
+  //    BETWEEN two runs, to neither. So the commit range has to be widened
+  //    past runRangeOfBlocks(listRunOf(...)) explicitly. This is one of only
+  //    two places where that happens (§3.4's 2026-08-30 erratum); the other is
+  //    §4.3 rule 1's edge blanks in convertListItemAway() above.
+  //
+  // 2. The run-wide gate has to hold for BOTH runs. Merging a DEGRADED run
+  //    into a healthy one freezes the healthy one too — and declining to merge
+  //    is no escape, because once the marker types match, markdown merges the
+  //    two whether or not the separator survives (it just goes loose instead).
+  //    The only correct answer there is to refuse the whole gesture, which is
+  //    what `ok: false` means.
+  //
+  // ⚠ The question is asked about the neighbour's RUN, not about the
+  // neighbour BLOCK — and this contradicts the plan's Task 5 sketch, which
+  // tests `previousBlockEl`'s own data-indent/data-list-type. MEASURED:
+  //   '- alpha\n  - beta\n\n- gamma\n' → ONE list, loose === true
+  // The block above the separator is `beta` at indent 1, so the sketch's
+  // predicate says "no merge" and commits exactly those degrading bytes. The
+  // list `gamma` actually joins is ALPHA's, and looseness is a property of the
+  // whole list token — so the comparison must be against listRunOf(neighbour)'s
+  // HEAD, which is the run's top-level identity.
+  //
+  // `range` is the commit range as the caller's own machinery derived it;
+  // `spanEls` the block span that range covers (used only to find the
+  // neighbouring blocks); `headAttrs` / `tailAttrs` the {listType, indent} the
+  // span's first and last TOP-LEVEL lines will carry AFTER the conversion —
+  // which is why they are passed in rather than read here: for li → li this
+  // runs BEFORE the DOM mutation, so a refusal never has a half-mutated run to
+  // undo.
+  function widenRangeForListMerge(range, spanEls, headAttrs, tailAttrs) {
+    const all = allBlockEls();
+    const first = spanEls[0];
+    const last = spanEls[spanEls.length - 1];
+    const i = all.indexOf(first);
+    const j = all.indexOf(last);
+    let startLine = range.startLine;
+    let endLine = range.endLine;
+    const sides = [
+      { el: i > 0 ? all[i - 1] : null, attrs: headAttrs, back: true },
+      { el: (j >= 0 && j + 1 < all.length) ? all[j + 1] : null, attrs: tailAttrs, back: false },
+    ];
+    for (let k = 0; k < sides.length; k++) {
+      const side = sides[k];
+      if (!side.el || !side.attrs) continue;
+      if (side.el.getAttribute('data-block-type') !== 'li') continue;
+      // The neighbour's OWN outermost run — see the ⚠ above.
+      const nrun = listRunOf(side.el);
+      if (!nrun.length) continue;
+      const head = nrun[0];
+      if ((Number(head.getAttribute('data-indent')) || 0) !== side.attrs.indent) continue;
+      const headType = head.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul';
+      if (headType !== side.attrs.listType) continue;
+      // Every line between two adjacent blocks is blank by construction
+      // (buildBlockMap() strips a token's trailing newlines, so no block ever
+      // owns a separator). Eating ALL of them is also 「正規化連續空行」:
+      // measured, '- a\n\n\n- b\n' is still ONE loose list, so stopping after
+      // one blank would leave the degrade in place.
+      let moved = false;
+      if (side.back) {
+        while (startLine >= 2 && String(lines[startLine - 2]).trim() === '') {
+          startLine -= 1; moved = true;
+        }
+      } else {
+        while (endLine < lines.length && String(lines[endLine]).trim() === '') {
+          endLine += 1; moved = true;
+        }
+      }
+      // No separator between us and it: they are already two runs that
+      // markdown keeps apart for a reason this rule does not touch (a
+      // delimiter change, `- a` / `* b`). Nothing to eat, nothing to gate.
+      if (!moved) continue;
+      // Consequence 2. `columnOnly` is the honest option here: this run's
+      // bytes are not being rewritten AT ALL (it sits entirely outside the
+      // commit range), so the only question worth asking of it is the
+      // `unsupported` one — and a hard-wrapped bystander li in there must not
+      // veto the merge, exactly as §4.1 keeps it legal everywhere else.
+      if (!listRunSupportsStructuralEdit(nrun, null, { columnOnly: true })) {
+        return { startLine: range.startLine, endLine: range.endLine, ok: false };
+      }
+    }
+    return { startLine: startLine, endLine: endLine, ok: true };
+  }
+
+  // The {listType, indent} a span member will carry once `liEl` has become
+  // `attrs`. Everything except the converted item keeps what it already has.
+  function postConvertLiAttrs(el, liEl, attrs) {
+    return {
+      listType: el === liEl
+        ? attrs.listType
+        : (el.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul'),
+      indent: Number(el.getAttribute('data-indent')) || 0,
+    };
+  }
+
+  async function convertListItemType(liEl, run, target) {
+    const range = runRangeOfBlocks({ lines, blocks, stack }, run);
+    if (!range) return;
+    const attrs = convertMd.listAttrsFor(target);
+    if (!attrs) return;
+    // §4.3 rule 2, in its revised form: the ruling keys on 「轉換結果是 li」,
+    // so it applies HERE too, not only to the 非清單 → 清單 path below. This
+    // is the S2 Task 3 defect — '- a' + blank + '1. b', both tight, and one
+    // 轉換成 › 項目符號列表 on `b` merged them into one LOOSE list that froze
+    // read-only with no banner. See widenRangeForListMerge()'s own note.
+    //
+    // The head/tail of the span are compared, not the converted item: a
+    // conversion in the MIDDLE of a run leaves the run's outer lines alone, and
+    // it is those that abut the separators. `tailEl` is the last member at the
+    // span's TOP-LEVEL indent — listRunOf() includes descendants, and a nested
+    // trailing item is not what the following list token would merge with.
+    // Computed BEFORE mutateListRun() so a refusal has nothing to undo.
+    const headEl = run[0];
+    const headIndent = Number(headEl.getAttribute('data-indent')) || 0;
+    let tailEl = headEl;
+    run.forEach((el) => {
+      if ((Number(el.getAttribute('data-indent')) || 0) === headIndent) tailEl = el;
+    });
+    const merged = widenRangeForListMerge(range, run,
+      postConvertLiAttrs(headEl, liEl, attrs), postConvertLiAttrs(tailEl, liEl, attrs));
+    if (!merged.ok) { refuseStructuralListEdit(); return; }
+    range.startLine = merged.startLine;
+    range.endLine = merged.endLine;
+    mutateListRun(() => {
+      liEl.setAttribute('data-list-type', attrs.listType);
+      liEl.setAttribute('data-task', attrs.task ? '1' : '0');
+      const box = liCheckEl(liEl);
+      if (attrs.task) {
+        // Insert BEFORE the surface: §4.1 fixes the child order as
+        // marker → check → text, and list-md.js's firstChildWithClass() plus
+        // the delegated checkbox-toggle listener both assume it.
+        if (!box) liEl.insertBefore(buildLiCheckbox(), liTextEl(liEl));
+      } else if (box) {
+        box.remove();
+      }
+    });
+    // NO `mutatedEl` — deliberately, and this contradicts the plan's Task 3
+    // sketch, which passes `liEl`. bystanderCarryOver(span, mutatedEl)
+    // EXCLUDES `mutatedEl` from the replay map, so naming the converted item
+    // is what sends ITS content back through inline-md.js's escapeText().
+    // Measured: serializeInline('~5px') === '\~5px', and the runtime scenario
+    // 'a list-type change never re-escapes the item’s own content' failed
+    // exactly that way before this line lost its second argument. Nothing
+    // here rewrote the item's CONTENT — only two attributes and a checkbox
+    // span, none of which the serializer reads from `.ed-li-text` — so its
+    // bytes belong to the file, same as every other member of the run.
+    // Carrying it is free: list-md.js emits `head + carriedSplit.content` for
+    // a carried line, i.e. it re-states the marker from the NEW attributes,
+    // and SRC_MARKER_RE eats the old bullet AND the old GFM checkbox off the
+    // carried source. That is what makes '- [x] alpha' → '- alpha' work.
+    await commitListStructure(run, null, false,
+      { presetRange: range, carryOver: bystanderCarryOver(run) });
+  }
+
+  // The `data-block-type` a conversion target will carry once it is committed.
+  // Only ever handed to indent-clamp's `operatedBecomes`, whose one question
+  // is "is this still a li?" — but naming the real type keeps the call honest
+  // if the pure function ever grows a second question.
+  function convertedBlockType(target) {
+    if (/^h[1-6]$/.test(target)) return 'heading';
+    if (target === 'quote') return 'blockquote';
+    if (target === 'code') return 'code';
+    return 'paragraph';
+  }
+
+  // S2 Task 4 — 轉換成 › 文字 / 標題 N / 程式碼 / 引用 on a li (§4.3 rule 1).
+  //
+  // The item LEAVES the run, so the run's own line range is rebuilt in three
+  // pieces: the survivors before it, the converted block's own lines (read
+  // from `lines`, never re-serialized — that is what keeps a `~5px` a `~5px`),
+  // and the survivors after it. §3.8's renumbering falls out of re-serializing
+  // each surviving half on its own; §4.3 rule 1's blank lines are the '\n\n'
+  // joins between the pieces.
+  //
+  // `run` and the §4.3 run-wide gate are the CALLER's (convertBlockViaMenu),
+  // for the reason spelled out there: the gate must sit ahead of every other
+  // refusal so a multi-line li reports §4.1's banner and not stripMarker()'s
+  // narrower one.
+  //
+  // Deliberately NOT re-checked here: `serializeBlocks().unsupported` on the
+  // two halves. The gate above already serialized the WHOLE run through
+  // listRunSupportsStructuralEdit(), and `unsupported` is a per-block fact, so
+  // splitting the span cannot add a name. A naive `unsupported.length > 0`
+  // re-check is worse than redundant — it refuses a HARD-WRAPPED bystander,
+  // which §4.1 explicitly keeps legal (MULTILINE is filtered out of the
+  // run-wide veto and re-checked against the TARGET's line range only).
+  // Measured; the 'a multi-line bystander is replayed, not refused' scenario
+  // is what notices.
+  async function convertListItemAway(liEl, run, rec, target) {
+    const range = runRangeOfBlocks({ lines, blocks, stack }, run);
+    if (!range) return;
+    const stripped = convertMd.stripMarker(lines.slice(rec.startLine - 1, rec.endLine), 'li');
+    if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+    const convertedLines = convertMd.emitAs(stripped.content, target, {});
+
+    const oldIndent = Number(liEl.getAttribute('data-indent')) || 0;
+    const idx = run.indexOf(liEl);
+    const before = run.slice(0, idx);
+    const after = run.slice(idx + 1);
+
+    // §3.4, and the FIRST production caller of the pure clamp's
+    // `operatedBecomes` branch (RULING T6-B). `liEl` stays in the span — the
+    // option is what tells clampIndents() that it can no longer anchor
+    // anything, and rule 2's scope is measured from its position — and it is
+    // NOT removed from the DOM: nothing below serializes it (its bytes come
+    // from convert-md.js), commitRangeEdit() + safeRerenderAll() rebuild the
+    // whole document from markdown anyway, and leaving it there means a
+    // FAILED render shows the pre-conversion item rather than a hole.
+    // mutateListRun() is still the wrapper, for its finally: `data-indent`
+    // just moved on the survivors, so `data-run-start` (the ordered counter's
+    // CSS reset) is stale for the length of the render round trip.
+    //
+    // ⚠ MEASURED, and it contradicts the plan's step 7: on the plan's own
+    // '- alpha / (2sp)- child / (4sp)- grandchild' fixture this clamp is a
+    // NO-OP on the emitted bytes. serializeBlocks() rebuilds its marker-width
+    // stack from EMPTY for each span it is given (list-md.js:502,
+    // `widths.slice(0, indent)`), so the first block of the `after` half
+    // always emits at column 0 whatever its data-indent says — which is
+    // exactly what the clamp would have done to it. The clamp earns its place
+    // one shape further out: when the scope holds TWO segments (§3.4 rule 3),
+    // their deltas differ and the width stack cannot derive that on its own.
+    // The 'the §3.4 segment deltas survive the split commit' scenario is that
+    // shape, and it is the one that goes red without this option.
+    mutateListRun(() => {
+      applyIndentClamp(run, liEl, oldIndent, { operatedBecomes: { type: convertedBlockType(target) } });
+    });
+
+    // No `mutatedEl`: the converted block is in neither half, and every
+    // survivor's bytes are exactly what the file already holds. Naming a block
+    // here EXCLUDES it from the replay map, which is what sends its content
+    // back through escapeText() — see convertListItemType()'s note.
+    const carry = bystanderCarryOver(before.concat(after));
+    const pieces = [];
+    if (before.length) pieces.push(listMd.serializeBlocks(before, { carryOver: carry }).md);
+    pieces.push(convertedLines.join('\n'));
+    if (after.length) pieces.push(listMd.serializeBlocks(after, { carryOver: carry }).md);
+    let md = pieces.join('\n\n');
+
+    // §4.3 rule 1 at the RUN's own edges. Inside the range the '\n\n' joins
+    // above already separate the pieces; outside it, the neighbouring line
+    // belongs to another block and may be a li of an ADJACENT run (a
+    // list-type change splits a run without a blank line — measured in Task
+    // 3), in which case '- alpha / bravo' re-lexes as one item. The blank is
+    // added only when the neighbour is not already blank, which is also what
+    // 「正規化連續空行」 amounts to here: no double separator is ever created.
+    if (!before.length && range.startLine > 1 &&
+        String(lines[range.startLine - 2]).trim() !== '') md = '\n' + md;
+    if (!after.length && range.endLine < lines.length &&
+        String(lines[range.endLine]).trim() !== '') md = md + '\n';
+
+    const result = commitRangeEdit({ lines, blocks, stack }, range.startLine, range.endLine, md);
+    if (result.op === null) return;
+    const prevLines = lines;
+    lines = result.lines;
+    if (!(await safeRerenderAll())) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
+  // S2 Task 5 — 轉換成 › 項目符號列表 / 編號列表 / 待辦清單 on a block that is
+  // NOT a list item (§4.3 rule 2, the return leg of rule 1).
+  //
+  // Line-level like every other conversion: the source comes from `lines`, so
+  // the content is never re-serialized and a `~5px` stays a `~5px`. The block
+  // owns its own lines and nothing else is re-emitted, so there is no run to
+  // serialize and no carryOver to build — the two neighbouring runs are
+  // deliberately left byte-untouched, and the ONLY thing that leaves the
+  // block's own range is the blank separator rule 2 eats.
+  //
+  // No §4.1 run-wide gate on the way in: the source is not a li, so it belongs
+  // to no run. The gate that DOES apply is the one inside
+  // widenRangeForListMerge(), on whichever neighbouring run this block is
+  // about to merge into.
+  async function convertBlockIntoList(blockEl, rec, kind, target) {
+    const attrs = convertMd.listAttrsFor(target);
+    if (!attrs) return;
+    const stripped = convertMd.stripMarker(lines.slice(rec.startLine - 1, rec.endLine), kind);
+    if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+    const newLines = convertMd.emitAs(stripped.content, target, {});
+
+    // emitAs() puts a list target at column 0 with no indent prefix, so the
+    // block's post-conversion identity is (target list type, indent 0) on both
+    // edges — it emits one item, however many physical lines that item spans.
+    const self = { listType: attrs.listType, indent: 0 };
+    const merged = widenRangeForListMerge(
+      { startLine: rec.startLine, endLine: rec.endLine }, [blockEl], self, self);
+    if (!merged.ok) { refuseStructuralListEdit(); return; }
+
+    const result = commitRangeEdit({ lines, blocks, stack },
+      merged.startLine, merged.endLine, newLines.join('\n'));
+    if (result.op === null) return;
+    const prevLines = lines;
+    lines = result.lines;
+    if (!(await safeRerenderAll())) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
+  // The `.ed-li-check` chrome for a li that has just BECOME a task item.
+  //
+  // ⚠ This markup must stay byte-identical to the renderer's, which builds the
+  // same span from a template literal at lib/md2doc.js:287-289:
+  //   <span class="ed-li-check" data-checked="0" role="checkbox"
+  //         aria-checked="false"></span>
+  // Attribute ORDER matters as well as content: `bystanderCarryOver()` and the
+  // burst baseline both compare innerHTML strings, and the very next successful
+  // render replaces this element with the renderer's own — so a mismatch would
+  // show up as a spurious diff for exactly one commit round trip. A new
+  // task item is always unchecked (nothing in a `- alpha` line says otherwise).
+  //
+  // It deliberately carries NO click handler: the toggle is a delegated
+  // listener on `.content` that resolves via closest('.ed-li-check').
+  // It adds no NEW element type either — 'ed-li-check' is already in
+  // list-md.js's closed LI_CHROME allowlist, so serializeBlocks() keeps
+  // skipping it instead of reporting SPAN as unsupported.
+  function buildLiCheckbox() {
+    const box = document.createElement('span');
+    box.className = 'ed-li-check';
+    box.setAttribute('data-checked', '0');
+    box.setAttribute('role', 'checkbox');
+    box.setAttribute('aria-checked', 'false');
+    return box;
+  }
+
   // The ⠿ menu's "MD 原始碼" escape hatch: discards (never commits) any
   // in-progress burst on THIS block — same "throw away my WYSIWYG edits,
   // switch to raw-edit against the untouched on-disk source" contract the
@@ -1631,17 +3093,49 @@
     }
     burst.history.flushTyping();
     // Task 7 (Phase 4): li burst — serialize the whole list run through
-    // serializeList(), commit via commitRangeEdit() over the full run range.
+    // serializeBlocks(), commit via commitRangeEdit() over the full run range.
     // Per-li degrade (spec §8): if OTHER lis in the run are unsupported,
     // commit only the edited li's own line range to avoid lossy round-trip
-    // of their content (serializeList strips unsupported inline elements from
+    // of their content (serializeBlocks strips unsupported inline elements from
     // `md`, so whole-run commit would silently delete their content).
     if (burst.blockType === 'li') {
-      const root = listRunRootOf(burst.editEl);
-      if (!root) { endBurstWithoutResolve(); return true; }
-      const { md: runMd, unsupported, unsupportedByLi } = listMd.serializeList(root);
+      const editedLiEl = closestLiBlock(burst.editEl);
+      const runEls = listRunOf(editedLiEl);
+      if (!runEls.length) { endBurstWithoutResolve(); return true; }
+      // T7 fix round 1 (HIGH-1): the §3.4 bystander replay belongs here too,
+      // and this was the ONE list commit path that never got it — which made
+      // "a line the user did not touch is never rewritten" false for the
+      // commonest gesture of all, TYPING. The fully-supported branch below
+      // commits `runMd` over the WHOLE run range, so every other item in the
+      // run was re-serialized from the DOM on every keystroke burst:
+      //
+      //   before: '- alpha one··\n  alpha two ~t\n- bravo one··\n  bravo two ~u\n- charlie ~v\n'
+      //   type one char into bravo, save
+      //   after:  '- alpha one<br>alpha two \~t\n- bravo one<br>bravo two \~uZ\n- charlie \~v\n'
+      //
+      // — alpha's two source lines collapsed onto one bearing the literal
+      // text '<br>' (the file lost a line) and charlie's '~v' was escaped,
+      // in two items the user never opened.
+      //
+      // `mutatedEl` is the edited li: its DOM holds keystrokes `lines` has
+      // not seen. bystanderCarryOver()'s dirty-burst exclusion already covers
+      // it here (this is past the zero-edit guard, and `burst.blockId` IS this
+      // li's id), so naming it is belt-and-braces — but it is the same fact
+      // stated in the same place as the five structural call sites, which is
+      // what stops the next reader having to re-derive it.
+      //
+      // The PARTIAL-run branch below is unaffected in OUTCOME, though not
+      // untouched: a replayed bystander can emit a different number of lines
+      // than a re-serialized one, so `first`/`last` shift. They index into
+      // `runLines`, which is `runMd` from this very call, so the slice stays
+      // self-consistent — and the bystanders' lines never reach `lines` on
+      // that path anyway, because it commits only the edited block's own
+      // source range.
+      const carry = bystanderCarryOver(runEls, editedLiEl);
+      const { md: runMd, unsupported, unsupportedByLi, lineMeta } =
+        listMd.serializeBlocks(runEls, { carryOver: carry });
       // Refuse if the EDITED li itself has unsupported inline content.
-      // RULING F-O: do NOT call openRawEditor() on a <li> element — injecting
+      // RULING F-O: do NOT call openRawEditor() on a list block — injecting
       // a textarea into list structure corrupts list-md serialization and
       // renders badly. Show banner + teardown + rerenderAll (file is untouched,
       // burst never wrote to `lines`) + return false.
@@ -1652,7 +3146,7 @@
         await safeRerenderAll();
         return false;
       }
-      const range = runRangeOf({ lines, blocks, stack }, root);
+      const range = runRangeOfBlocks({ lines, blocks, stack }, runEls);
       if (!range) { endBurstWithoutResolve(); return true; }
       let commitMd, commitStart, commitEnd;
       if (unsupported.length > 0) {
@@ -1671,25 +3165,42 @@
         // loose-'P', stray-TEXT and foreign-element cases in one shot.
         const editedBlock = blocks.find((b) => b.id === burst.blockId);
         if (!editedBlock) { endBurstWithoutResolve(); return true; }
-        // F-W (the trap): the slice offset MUST be the edited li's POSITION
-        // among the run's li blocks in DFS document order, NOT the source-line
-        // delta (editedBlock.startLine - range.startLine). The tight runMd
-        // emits exactly ONE line per li in DFS order (list-md.js pushes one
-        // line per item) and has NO blank lines, so a loose item present
-        // anywhere earlier in the run makes a later supported li's SOURCE
-        // startLine overshoot the tight runMd's line count — the old delta
-        // slice then returned '' and commitRangeRemoval DELETED the li's line.
-        // Indexing by li position is blank-line-robust: the k-th `.ed-block`
-        // li returned by querySelectorAll (pre-order DFS) is the k-th line of
-        // runMd (serializeList emits in the same pre-order DFS), so
-        // runLines[offset] is exactly THIS li's serialized line, independent
-        // of any loose blank lines in the source.
-        const runLiIds = Array.prototype.slice
-          .call(root.querySelectorAll('.ed-block'))
-          .map((el) => Number(el.getAttribute('data-block-id')));
-        const offset = runLiIds.indexOf(burst.blockId);
-        if (offset < 0) { endBurstWithoutResolve(); return true; }
-        commitMd = runMd.split('\n')[offset];
+        // F-W (the trap): the slice MUST be located among the run's emitted
+        // LINES, NOT by the source-line delta
+        // (editedBlock.startLine - range.startLine). runMd has no blank lines,
+        // so a loose item present anywhere earlier in the run makes a later
+        // supported li's SOURCE startLine overshoot runMd's line count — the
+        // old delta slice then returned '' and commitRangeRemoval DELETED the
+        // li's line.
+        //
+        // `lineMeta` is the serializer's own authoritative line -> blockId
+        // mapping and is read instead of re-deriving anything from the DOM.
+        // Two reasons position arithmetic cannot be used: a block the
+        // serializer refuses emits NO line (controller note T2-C), and a
+        // hard-wrapped block emits SEVERAL — so a block maps to the index
+        // RANGE of the entries bearing its id, and the commit replaces that
+        // whole range. Taking only the first line here is what overwrote a
+        // later item's source with a continuation line. lineMeta's blockId is
+        // the raw getAttribute() string, hence the String() comparison (same
+        // convention as the unsupportedByLi gate above).
+        const runLines = runMd.split('\n');
+        let first = -1;
+        let last = -1;
+        lineMeta.forEach((m, k) => {
+          if (m.blockId !== editedIdStr) return;
+          if (first < 0) first = k;
+          last = k;
+        });
+        if (first < 0) { endBurstWithoutResolve(); return true; }
+        // Round 5/6: the edited block's source line may also carry the markers
+        // of zero-line ancestors (same-line nesting, '- - b'). They emit their
+        // own lines in runMd but are not attributed to this block, so slicing
+        // by id alone dropped them and the child lost its parent. A plain
+        // ancestor is re-emitted on a line of its own; a TASK ancestor has to
+        // stay on the child's line or its checkbox degrades to literal text.
+        // See sharedMarkerPrefixFor().
+        commitMd = sharedMarkerLinesBefore(lineMeta, first, editedBlock)
+          .concat(runLines.slice(first, last + 1)).join('\n');
         commitStart = editedBlock.startLine;
         commitEnd = editedBlock.endLine;
       } else {
@@ -1709,26 +3220,19 @@
       lines = liCommitResult.lines;
       const liOk = await safeRerenderAll();
       if (!liOk) {
-        const liRollback = stack.undo(lines);
-        lines = liRollback ? liRollback.lines : liPrevLines;
+        lines = rollbackFailedRender({ lines, stack }, liCommitResult, liPrevLines);
         return false;
       }
       return true;
     }
-    // Task 4 (Phase 3): a list burst serializes through list-md.js's
-    // serializeList() (it takes the list ROOT element, exactly what
-    // burst.editEl already is for a 'list' burst — see armEditables() above)
-    // instead of inline-md.js's serializeInline(); Task 5: a table burst
-    // serializes through table-md.js's serializeTable() the same way (it
-    // takes the TABLE element, exactly what burst.editEl already is for a
+    // Task 5: a table burst serializes through table-md.js's serializeTable()
+    // (it takes the TABLE element, exactly what burst.editEl already is for a
     // 'table' burst). Every other block type (paragraph/heading) keeps using
-    // serializeInline() unchanged.
-    // LEGACY (pre-per-li): the 'list' branch below is unreachable in the
-    // per-li architecture — blockmap no longer emits type:'list' blocks, so
-    // no startBurst() call can produce blockType === 'list'. Kept until the
-    // whole 'list' surface is removed in a later cleanup task.
-    const result = burst.blockType === 'list' ? listMd.serializeList(burst.editEl)
-      : burst.blockType === 'table' ? tableMd.serializeTable(burst.editEl)
+    // inline-md.js's serializeInline() unchanged.
+    // S1 removed the pre-per-li 'list' branch that lived here: blockmap has not
+    // emitted type:'list' blocks since Phase 4, so no startBurst() call could
+    // produce blockType === 'list' and the branch was already dead code.
+    const result = burst.blockType === 'table' ? tableMd.serializeTable(burst.editEl)
       : inlineMd.serializeInline(burst.editEl);
     if (result.unsupported.length > 0) {
       // Degrade-never-lose (same contract as Phase 2's openWysiwygEditor()
@@ -1745,23 +3249,16 @@
       return false;
     }
     // Final-review Finding 5 (carried over): an emptied-out heading must not
-    // commit '#'.repeat(depth) + ' ' with nothing after the space. A list
-    // burst's `depth` is always null (blockDepthOf() only computes it for
-    // 'heading'), so it takes the plain result.md branch, same as a
-    // paragraph.
+    // 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);
-    // Task 4 fix (review, Important): a list burst that serialized to ''
-    // means every item was removed (each <li> always emits a non-empty
-    // marker line — see list-md.js — so a 0-line result can ONLY happen
-    // with 0 <li>s left) — delete the block's line range entirely instead
-    // of committing a single stray blank line. See commitListBlockRemoval()'s
-    // own comment for the exact byte-level contract.
-    // LEGACY (pre-per-li): the 'list' branch below is unreachable in the
-    // per-li architecture — kept until the whole 'list' surface is removed.
-    const commitResult = (burst.blockType === 'list' && result.md === '')
-      ? commitListBlockRemoval({ lines, blocks, stack }, burst.blockId)
-      : commitEdit({ lines, blocks, stack }, burst.blockId, newText);
+    // 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
+    // by commitListStructure()'s own md === '' path.
+    const commitResult = commitEdit({ lines, blocks, stack }, burst.blockId, newText);
     if (commitResult.op === null) {
       endBurstWithoutResolve();
       return true;
@@ -1770,8 +3267,7 @@
     lines = commitResult.lines;
     const ok = await safeRerenderAll();
     if (!ok) {
-      const rollback = stack.undo(lines);
-      lines = rollback ? rollback.lines : prevLines;
+      lines = rollbackFailedRender({ lines, stack }, commitResult, prevLines);
       // Burst stays open: DOM/history untouched, banner already shown by
       // safeRerenderAll(). rerenderAll() never ran its belt-and-braces
       // `currentBurst = null` reset on this failure path (that reset only
@@ -1800,6 +3296,49 @@
     return document.querySelector('.ed-block[data-block-id="' + target.id + '"]');
   }
 
+  // ── T7: surviving a commit that renumbers every block id ───────────────
+  // A gutter gesture (⠿ delete, ＋ insert) resolves any open burst FIRST, and
+  // that resolution can commit a DIFFERENT block's dirty editor, re-render,
+  // and detach the element the gesture started from. Recovering by
+  // `data-block-id` is not recovery at all: blockmap.js assigns ids 0..n-1 in
+  // document order on EVERY render (`nextId = {v:0}`), so a commit that
+  // changes the block COUNT shifts every later id and the captured id then
+  // names the target's NEIGHBOUR. Measured: a fenced code block raw-edited
+  // into two paragraphs changes the count WITHOUT changing the line count, so
+  // '⠿ → 刪除' on the last paragraph deleted the one before it instead.
+  //
+  // Same defect class the S1 table fix closed (ensureTableBurstOpen()'s own
+  // comment), and the same remedy: `startLine` is the stable handle, and the
+  // block's own SOURCE LINES are the fingerprint proving the block sitting
+  // there afterwards really is the same one. When the intervening commit moved
+  // the target's own start line there is nothing left to resolve — the
+  // fingerprint fails, the caller DROPS the gesture and says so. Never
+  // guessed: completing every gesture is worth less than never acting on a
+  // block the user did not point at.
+  function blockSourceOf(block) {
+    return lines.slice(block.startLine - 1, block.endLine).join('\n');
+  }
+  function captureBlockIdentity(blockEl) {
+    if (!blockEl) return null;
+    const raw = blockEl.getAttribute('data-block-id');
+    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) };
+  }
+  function reresolveBlockEl(identity) {
+    if (!identity) return null;
+    const at = blocks.find((b) => b.startLine === identity.startLine);
+    if (!at || at.type !== identity.type || blockSourceOf(at) !== identity.source) return null;
+    return document.querySelector('.ed-block[data-block-id="' + at.id + '"]');
+  }
+
+  // What a caller says when it refuses to act rather than act on the wrong
+  // block. Dismiss-only, same shape as refuseStructuralListEdit()'s banner —
+  // the previous behaviour was to return silently, which reads to the user as
+  // "the menu item is broken" and invites a second press.
+  const DROPPED_GESTURE_MESSAGE = '文件已更新，請重試這個操作';
+
   // Finds the block whose startLine === `startLine` in the current `blocks`
   // array and focuses its WYSIWYG surface. `caretToEnd` = true places the
   // caret after the last character; false (default) places it at the start.
@@ -1827,7 +3366,7 @@
   }
 
   // ── Task 8 (Phase 4): structural commit for a per-li block run ──────────
-  // Spec §3: a single <li> cannot emit its own line (ordinals and ancestor
+  // Spec §3: a single list item cannot emit its own line (ordinals and ancestor
   // marker widths are tree-global), so the commit unit for ANY structural
   // change is the contiguous list RUN — re-serialize the whole run, replace
   // its line range once. That keeps every structural key at exactly ONE undo
@@ -1837,18 +3376,20 @@
   // handler — Task 9's delegated checkbox-toggle click handler calls this too.
   //
   // The DOM mutation must already have happened when this is called; it reads
-  // the live run back out through listMd.serializeList(). `focusStartLine` is
+  // the live run back out through listMd.serializeBlocks(). `focusStartLine` is
   // the (post-commit) line the caret should end up on — see
-  // runLineOfListItem() below for how a caller computes it — or null to leave
+  // runLineOfBlock() below for how a caller computes it — or null to leave
   // focus wherever the re-render puts it. Returns true on success, false when
   // the commit's own re-render failed (rolled back the same way every other
   // commit path in this file does: stack.undo() + restore `lines`).
   //
-  // `runEl` is normally the `.ed-li-text` surface the key came from, but any
-  // node still inside the run works (listRunRootOf() walks up from it, and the
-  // run ROOT itself resolves to itself). A caller whose mutation DETACHES that
-  // surface — empty-Enter's li removal — must pass the run root instead, or
-  // this cannot find the run at all.
+  // S1: `runEls` is the POST-mutation run span itself (listRunOf() on any block
+  // still in the run), not a node to walk up from — the flat model has no list
+  // container left to resolve. A caller whose mutation REMOVED the block the
+  // key came from therefore computes the span from a surviving sibling, or
+  // passes an empty array plus a `presetRange` when the run has no members
+  // left; an empty span serializes to '' and takes the range-removal path
+  // below, exactly as an emptied run did before.
   // Both "cannot locate the run" refusals below re-render before returning: the
   // caller's DOM mutation has ALREADY happened by the time this function runs,
   // so bailing out without a render would leave the screen showing a structural
@@ -1861,20 +3402,100 @@
   // re-serializes the WHOLE run — an unsupported li anywhere in it would have
   // its content silently deleted if the gate is skipped. The keydown handlers
   // (Tab, Enter) and the Task 9 checkbox click handler both enforce this.
-  async function commitListStructure(runEl, focusStartLine, caretToEnd, presetRange) {
-    const root = listRunRootOf(runEl);
-    if (!root) { endBurstWithoutResolve(); await safeRerenderAll(); return false; }
-    const { md } = listMd.serializeList(root);
+  // Spec §3.4's bystander rule, resolved against the live file state: every
+  // block in the commit span that the gesture did not itself touch, mapped to
+  // the source lines it owns right now, so listMd.serializeBlocks() can replay
+  // them instead of running them back through the (measurably lossy) inline
+  // round trip. See its own carryOver comment for the measurement.
+  //
+  // ── T7: EVERY untouched block, keyed on its LINE RANGE ─────────────────
+  // This used to name only the blocks the serializer reported in
+  // `multiLineBlockIds`, and both halves of that were wrong.
+  //
+  //  * WRONG SET. `multiLineBlockIds` answers "does the surface text hold a
+  //    '\n'", which is blind to a markdown HARD BREAK (two trailing spaces →
+  //    <br>, no newline in the DOM). Such an item was never carried, so a Tab
+  //    on a SIBLING re-serialised it: its two source lines collapsed onto one
+  //    line bearing the literal text '<br>', and the file lost a line in an
+  //    item nobody touched. list-md.js's detector has since been widened, but
+  //    the truth about how many lines a block owns lives HERE — in `blocks` —
+  //    not in a DOM heuristic, so that is what this reads.
+  //  * WRONG QUESTION. Even a genuinely single-line bystander must not be
+  //    re-serialised: escapeText() escapes a tilde marked never treats as
+  //    markup, so an untouched '~5px' came back '\~5px'. Carrying EVERY
+  //    untouched block makes "a line the user did not touch is never
+  //    rewritten" a property of the commit, rather than a special case for
+  //    hard-wrapped items. (Chosen over teaching inline-md.js not to escape a
+  //    lone '~': that changes a global serialisation rule and every other
+  //    caller with it, and it would still leave the next such character to
+  //    find. Controller note T7-B picked the same half.)
+  //
+  // The probe serialisation this used to run for the id list is gone with it,
+  // which also takes one of the four serializeBlocks() passes a single Tab
+  // used to make off the hot path.
+  //
+  // Three exclusions, all about "whose bytes are authoritative":
+  //
+  //  * `mutatedEl` — the block the gesture REWROTE in the DOM before calling
+  //    the commit (Enter's split cuts its text in two; the empty-item outdent
+  //    clears its surface). Replaying its source would undo exactly that. A
+  //    column-only caller (Tab, the checkbox toggle) names nothing here, on
+  //    purpose: it changed an integer, not content, so its own target is a
+  //    bystander of itself and must come back byte-identical too.
+  //  * the block of an open burst whose surface has ACTUALLY been edited. Its
+  //    DOM holds keystrokes `lines` has not seen, and replaying `lines` would
+  //    silently throw them away. The dirty test is resolveBurst()'s own
+  //    zero-edit guard, so both places agree on what "edited" means — and an
+  //    UNEDITED burst is deliberately still replayed, because that is the
+  //    common case for Tab (click into an item, press Tab) and re-serializing
+  //    it would rewrite bytes the user only pressed an indent key on.
+  //  * a block with no resolvable, non-inverted range — a provisional split
+  //    item owns no source lines at all (no id yet), and a same-line nest's
+  //    outer item has endLine === startLine - 1. Neither has bytes to replay,
+  //    and slicing an inverted range would hand back the WRONG line. The
+  //    predicate is blockOwnsNoLine() itself rather than a second hand-typed
+  //    copy of `endLine < startLine`, so a change to that definition reaches
+  //    here too.
+  function bystanderCarryOver(span, mutatedEl) {
+    const dirtyId = (currentBurst && currentBurst.editEl &&
+      burstBaselineHtml(currentBurst.editEl) !== currentBurst.original)
+      ? String(currentBurst.blockId) : null;
+    const out = {};
+    let any = false;
+    (span || []).forEach((el) => {
+      if (!el || el === mutatedEl) return;
+      const raw = el.getAttribute('data-block-id');
+      if (raw === null || raw === dirtyId) return;
+      const rec = blocks.find((b) => b.id === Number(raw));
+      if (!rec || blockOwnsNoLine(el)) return;
+      out[raw] = lines.slice(rec.startLine - 1, rec.endLine);
+      any = true;
+    });
+    return any ? out : null;
+  }
+
+  // `opts`: { presetRange, carryOver }. `carryOver` is the map
+  // bystanderCarryOver() built — the CALLER builds it, once, right after its
+  // own DOM mutation, and hands the SAME object to runLineOfBlock() as well:
+  // the two must agree line-for-line (a replayed bystander can emit a
+  // different number of lines than a re-serialized one would), and building it
+  // twice also meant walking `blocks` twice per keystroke. Omitted (or null)
+  // means "no bystander replay", which is only correct for a span whose blocks
+  // all have their bytes in the DOM.
+  async function commitListStructure(runEls, focusStartLine, caretToEnd, opts) {
+    const span = runEls || [];
+    const presetRange = opts && opts.presetRange;
+    const { md } = listMd.serializeBlocks(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
     // and passes it in; everyone else lets it be derived here.
-    const range = presetRange || runRangeOf({ lines, blocks, stack }, root);
+    const range = presetRange || runRangeOfBlocks({ lines, blocks, stack }, span);
     if (!range) { endBurstWithoutResolve(); await safeRerenderAll(); return false; }
     const result = (md === '')
-      // Every <li> emits a non-empty marker line, so md === '' can only mean
-      // the run has no items left — delete the range outright (absorbing one
-      // adjacent blank separator) instead of committing a stray blank line.
+      // Every list block emits a non-empty marker line, so md === '' can only
+      // mean the run has no items left — delete the range outright (absorbing
+      // one adjacent blank separator) instead of committing a stray blank line.
       // Same contract commitListBlockRemoval() documents.
       ? commitRangeRemoval({ lines, blocks, stack }, range.startLine, range.endLine)
       : commitRangeEdit({ lines, blocks, stack }, range.startLine, range.endLine, md);
@@ -1890,10 +3511,7 @@
     if (result.op !== null) lines = result.lines;
     const ok = await safeRerenderAll();
     if (!ok) {
-      if (result.op !== null) {
-        const rollback = stack.undo(lines);
-        lines = rollback ? rollback.lines : prevLines;
-      }
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
       // Deliberately NOT a second safeRerenderAll(), unlike the two refusals
       // above: this shape is different — a render WAS attempted and failed, so
       // rerenderAll() left `.content` untouched by contract and already showed
@@ -1909,30 +3527,47 @@
     return true;
   }
 
-  // The line `targetLi` will occupy once the run it belongs to is committed by
-  // commitListStructure() above. list-md.js's one-li==one-line write invariant
-  // means the run's serialized markdown has exactly one line per <li> in
-  // document order (its emission walk — item line, then that item's nested
-  // lists, then the next sibling — is a pre-order DFS, i.e. exactly the order
-  // querySelectorAll('li') returns), so the target's line is the run's own
-  // startLine plus its index in that walk. Holds even when the PRE-commit
-  // source had multi-line items, because the commit replaces the whole range
-  // with the canonical one-line-per-item form.
-  // Returns null when the run (or the item) cannot be located.
-  function runLineOfListItem(rootEl, targetLi) {
-    const range = runRangeOf({ lines, blocks, stack }, rootEl);
-    if (!range) return null;
-    const lis = Array.prototype.slice.call(rootEl.querySelectorAll('li'));
-    const idx = lis.indexOf(targetLi);
+  // The line `targetBlock`'s own marker will occupy once the run span it belongs
+  // to is committed by commitListStructure() above.
+  //
+  // Counted in EMITTED LINES, not in blocks: a block index is only the line
+  // offset while every block emits exactly one line, and neither end of that
+  // holds — a refused block emits none (controller note T2-C) and a
+  // hard-wrapped one emits several. `lineMeta` is the serializer's own
+  // line -> blockId mapping, so the answer is the index of the FIRST entry
+  // bearing this block's id (its marker line; continuation entries follow).
+  // Returns null when the run (or the block) cannot be located.
+  function runLineOfBlock(runEls, targetBlock, carryOver) {
+    const range = runRangeOfBlocks({ lines, blocks, stack }, runEls);
+    if (!range || !targetBlock) return null;
+    const targetId = targetBlock.getAttribute('data-block-id');
+    // The SAME carryOver commitListStructure() will use — passed in by the
+    // caller rather than rebuilt here, because a rebuild is only *usually* the
+    // same answer and this index has to be exactly it: a replayed bystander
+    // can emit a different number of lines than a re-serialized one would (a
+    // blank continuation is dropped on the re-serialize path but replayed
+    // verbatim here), and this answer is an index INTO those lines.
+    const { lineMeta } = listMd.serializeBlocks(runEls, { carryOver: carryOver || null });
+    // A provisional block (split's new item) has no id yet, so it cannot be
+    // found by one — fall back to counting the lines emitted before it.
+    if (targetId === null) {
+      const at = runEls.indexOf(targetBlock);
+      if (at < 0) return null;
+      const before = runEls.slice(0, at).map((el) => el.getAttribute('data-block-id'));
+      let n = 0;
+      lineMeta.forEach((m) => { if (before.indexOf(m.blockId) !== -1) n++; });
+      return range.startLine + n;
+    }
+    const idx = lineMeta.findIndex((m) => m.blockId === targetId);
     if (idx === -1) return null;
     return range.startLine + idx;
   }
 
   // Degrade-never-lose gate for structural keys: refuse the key outright when
-  // ANY li in the run is unsupported (loose <p>-wrapped item, foreign element,
-  // stray text directly under the UL/OL, unsupported inline markup).
-  // serializeList() strips what it cannot represent from `md`, so committing
-  // such a run deletes that content silently.
+  // ANY block in the run span is unsupported (loose <p>-wrapped item, foreign
+  // child element, stray text directly inside the block, unsupported inline
+  // markup). serializeBlocks() strips what it cannot represent from `md`, so
+  // committing such a run deletes that content silently.
   //
   // RULING F-R — why the gate is RUN-WIDE, and why that does not contradict
   // spec §8's per-li narrowing. §8 governs which li you may TYPE in: a text
@@ -1947,8 +3582,93 @@
   // answer, not an over-broad one.
   //
   // Called BEFORE any mutation, so a refusal costs nothing to undo.
-  function listRunSupportsStructuralEdit(rootEl) {
-    return !!rootEl && listMd.serializeList(rootEl).unsupported.length === 0;
+  //
+  // ── Task 6: MULTILINE is a TARGET-ONLY refusal ─────────────────────────
+  // Everything above stays true for content the serializer cannot represent.
+  // A hard-wrapped item is a different animal: it is ordinary, valid markdown
+  // that the serializer represents perfectly well — it just owns several lines
+  // instead of one. Feeding it into the run-wide rule was measured, on this
+  // repo's own CHANGELOG.md, to refuse Tab on 100% of list items (80.6% of that
+  // file's 72 items are hard-wrapped, so effectively every run holds one). S1's
+  // headline gesture was therefore dead on any real document.
+  //
+  // Spec §4.1 splits the roles instead: hard-wrapped refuses as the operation
+  // TARGET (its own line range is what a split / convert / delete would have to
+  // rewrite, and no caller here knows how), and as a BYSTANDER it is carried
+  // through untouched — see commitListStructure()'s carryOver below, which
+  // replays its source bytes rather than re-serializing it.
+  //
+  // `targetEl` is the block the gesture acts on. It is NOT optional in spirit:
+  // omitting it falls back to the old run-wide answer, which is the safe
+  // direction but also the useless one, so every call site names its target.
+  //
+  // ── DEVIATION from spec §4.1, with the measurement that forced it ──────
+  // §4.1 lists Tab among the operations a hard-wrapped item refuses AS THE
+  // TARGET. Implemented literally, that does not deliver the acceptance
+  // condition this task was given ("Tab must work on CHANGELOG.md"), and the
+  // reason is arithmetic rather than opinion: measured on this repo's
+  // CHANGELOG.md at v2.10.2, 58 of 72 list items are hard-wrapped and NOT ONE
+  // of the 14 single-line items shares a run with one. Target-only refusal
+  // therefore moves the number of items that accept Tab from 14/72 to 14/72 —
+  // it changes nothing at all on that document, because there the
+  // hard-wrapped item is never the bystander, it is the item you want to
+  // indent.
+  //
+  // What the rest of §4.1's list has in common is that it REWRITES the item's
+  // content or its line count: a split cuts the text in two, a conversion
+  // re-authors it as a fence or a paragraph, a delete removes its lines, a
+  // duplicate re-emits them. None of those has a defined answer for an item
+  // whose content spans several source lines, which is what the refusal is
+  // protecting.
+  //
+  // Tab and Shift+Tab are not in that family. They change one integer and
+  // nothing else, and the resulting byte change is EXACTLY §3.4's colDelta —
+  // "對其 [startLine, endLine] 每一行套用同一欄位差", the same mechanism the
+  // spec already defines for a bystander, pointed at the target instead. So
+  // `opts.columnOnly` lets the indent keys through, and every other structural
+  // caller keeps §4.1's refusal untouched.
+  //
+  // `columnOnly` is a CRITERION, not the name of two keys (T7, and §4.1 has
+  // been amended to match so the next such operation needs no fresh ruling):
+  // an operation is column-only when it changes no content, no line count, and
+  // nothing but leading columns or the characters inside a marker. The GFM
+  // checkbox toggle qualifies on exactly the same arithmetic as Tab — '[ ] '
+  // and '[x] ' are the same width, so its colDelta is 0 — and it was the
+  // second caller to need it. Anything that rewrites the item's TEXT or its
+  // LINE COUNT (split, convert, delete, duplicate) is not column-only and must
+  // keep refusing a multi-line target.
+  //
+  // The one thing that must not happen is replaying stale bytes over live
+  // keystrokes; bystanderCarryOver() below is what draws that line, by
+  // excluding a burst whose surface has actually been edited.
+  function listRunSupportsStructuralEdit(runEls, targetEl, opts) {
+    if (!runEls || !runEls.length) return false;
+    const res = listMd.serializeBlocks(runEls);
+    const multi = res.multiLineBlockIds || [];
+    // Anything OTHER than MULTILINE still refuses run-wide, unchanged.
+    for (let i = 0; i < res.unsupported.length; i++) {
+      if (res.unsupported[i] !== 'MULTILINE') return false;
+    }
+    if (opts && opts.columnOnly) return true;
+    if (!targetEl) return multi.length === 0;
+    // T7: the AUTHORITATIVE multi-line test, and it is not `multi`.
+    // `multiLineBlockIds` reports a '\n' in the item's surface text, which
+    // sees a LAZY continuation and is blind to a markdown HARD BREAK (two
+    // trailing spaces -> <br>, no newline in the DOM). Enter on such an item
+    // was therefore accepted, and re-serialised its two source lines into one
+    // line bearing the literal text '<br>' — precisely the rewrite §4.1's
+    // refusal exists to prevent. How many lines a block owns is a fact about
+    // the FILE, so it is read off `blocks` here rather than guessed from the
+    // DOM in list-md.js (which was tried: '<br>' also matches the placeholder
+    // Chromium leaves when the last character is deleted, and an emptied item
+    // must stay removable). `multi` is kept as well — it costs nothing and
+    // covers any surface newline that is not a line-range fact.
+    const targetRaw = targetEl.getAttribute('data-block-id');
+    const targetRec = blocks.find((b) => b.id === Number(targetRaw));
+    if (targetRec && targetRec.endLine > targetRec.startLine) return false;
+    // getAttribute() strings on both sides — the same convention
+    // unsupportedByLi[].blockId uses.
+    return multi.indexOf(targetRaw) === -1;
   }
 
   // Esc inside a burst: revert to snapshot 0 (the pre-focus baseline) and
@@ -2062,13 +3782,31 @@
     if (currentBurst.blockType === 'li') {
       if (handleLiKeydown(e, editEl)) return;
     }
-    // Task 4 (Phase 3): a list burst's Enter/Tab/Shift+Tab semantics are
-    // materially different from paragraph/heading (split/indent/outdent
-    // instead of commit/br) — handleListKeydown() owns that entire surface
-    // (including its own Escape/Ctrl+Z/Ctrl+Y, mirrored from below) and
-    // returns before any of the paragraph/heading branches run.
-    if (currentBurst.blockType === 'list') {
-      handleListKeydown(e, editEl);
+    // 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
+    // surprise and (because it fires focusout) an unasked-for commit.
+    //
+    //   heading   — one level down / up, clamped to H1..H6 by
+    //               changeHeadingDepth(), which is the same source-level
+    //               transform the ⠿ menu's ± buttons already use.
+    //   paragraph — a true no-op. Not "unhandled": preventDefault() and
+    //               return, so the block is byte-identical afterwards.
+    //
+    // T7 correction: that is the WHOLE list, not a sample of it. This branch
+    // runs only for a block with an open burst, and armEditables() opens one
+    // for exactly four block types — paragraph, heading, li, table. `li` has
+    // already returned above (handleLiKeydown()), and a table cell never
+    // reaches here at all (it runs through handleTableCellKeydown(), whose Tab
+    // keeps its cell-navigation contract). Blockquote and fenced code are
+    // never armed — they are degraded blocks whose click opens the raw
+    // textarea — so no "consumed no-op" branch has ever executed for them,
+    // whatever the commit message that introduced this said.
+    if (e.key === 'Tab') {
+      e.preventDefault();
+      if (currentBurst.blockType === 'heading') {
+        changeHeadingDepth(currentBurst.blockEl, e.shiftKey ? -1 : 1);
+      }
       return;
     }
     if (e.key === 'Enter') {
@@ -2109,136 +3847,93 @@
   // by history.snap() per the Global Constraint ("every structural mutation
   // -> history snap").
 
-  // Nearest ancestor <li> of `node` (inclusive), never crossing `root` —
-  // same walk-up pattern as closestMarkAncestor() above, specialized to LI.
-  function closestListItem(node, root) {
-    let n = node;
-    while (n && n !== root) {
-      if (n.nodeType === 1 && n.nodeName === 'LI') return n;
-      n = n.parentNode;
-    }
-    return null;
-  }
-
-  function caretListItem(root) {
+  // S1: the caret's own li block, or null. closestLiBlock() replaces the old
+  // "nearest ancestor <li>, never crossing root" walk — a flat block has no
+  // list ancestor to cross, and the block boundary is the natural stop.
+  function caretLiBlock() {
     const sel = window.getSelection();
     if (!sel.rangeCount) return null;
-    return closestListItem(sel.getRangeAt(0).startContainer, root);
+    return closestLiBlock(sel.getRangeAt(0).startContainer);
   }
 
   // Task 4 fix (review, Critical): a NON-collapsed selection whose two
-  // boundary points resolve to DIFFERENT <li> elements (or either resolves
+  // boundary points resolve to DIFFERENT list blocks (or either resolves
   // to none) has no defined split semantics under the brief's caret-based
   // Enter contract — splitListItemAtCaret()'s Range extractContents() was
-  // anchored only to the START container's own <li>, so a cross-item
+  // anchored only to the START container's own item, so a cross-item
   // selection silently deleted whatever the selection covered in the OTHER
   // item(s) before the (wrong) split ran. True only for a genuinely
   // cross-item selection; a same-item multi-character selection is still a
   // normal (delete-then-split) Enter, handled by splitListItemAtCaret()
   // itself.
-  function selectionSpansMultipleListItems(root) {
+  function selectionSpansMultipleListItems() {
     const sel = window.getSelection();
     if (!sel.rangeCount) return false;
     const range = sel.getRangeAt(0);
     if (range.collapsed) return false;
-    const startLi = closestListItem(range.startContainer, root);
-    const endLi = closestListItem(range.endContainer, root);
+    const startLi = closestLiBlock(range.startContainer);
+    const endLi = closestLiBlock(range.endContainer);
     return !startLi || !endLi || startLi !== endLi;
   }
 
-  // Any UL/OL that is a direct child of `li` — per list-md.js's documented
-  // DOM shape, a nested sublist (if any) is always exactly one such
-  // trailing child; scanning ALL children (not just the last) is defensive
-  // against an edit having transiently left it somewhere else.
-  function directNestedListOf(li) {
-    for (let i = 0; i < li.childNodes.length; i++) {
-      const c = li.childNodes[i];
-      if (c.nodeType === 1 && (c.nodeName === 'UL' || c.nodeName === 'OL')) return c;
-    }
-    return null;
-  }
-
-  // Task 8: `li`'s own nested list whose tag is exactly `nodeName` ('UL'/'OL'),
-  // or null. outdentListItem() below needs the TYPE-MATCHED sublist, not merely
-  // the first one: appending adopted items into a sublist of the other type
-  // silently rewrites their markers (a bullet adopted into an <ol> comes back
-  // as '1.'). Emitting a second sublist of the other type instead is fine —
-  // list-md.js's serializeListNode() iterates every nested list of an item.
-  function directNestedListOfType(li, nodeName) {
-    for (let i = 0; i < li.childNodes.length; i++) {
-      const c = li.childNodes[i];
-      if (c.nodeType === 1 && c.nodeName === nodeName) return c;
-    }
-    return null;
+  // S1 replacement for directNestedListOf(): "does this item own children?" is
+  // now "is the NEXT block an li at a strictly greater indent?". A block's
+  // children are, by construction of the flat renderer's DFS walk, the
+  // contiguous run of deeper blocks immediately following it.
+  // RULING F-Q's guard reads this.
+  function liBlockHasChildren(blockEl) {
+    const self = liAttrs(blockEl);
+    if (!self) return false;
+    const all = allBlockEls();
+    const i = all.indexOf(blockEl);
+    if (i < 0) return false;
+    const next = liAttrs(all[i + 1]);
+    return !!next && next.indent > self.indent;
   }
 
   // Task 8: the per-li edit surface (`<div class="ed-li-text">`, see
-  // lib/md2doc.js's renderEditModeList) that holds `li`'s own inline content.
-  // Falls back to the <li> itself for the pre-per-li bare shape, so the
-  // structural helpers below keep working against either DOM.
-  function liTextEl(li) {
-    for (let i = 0; i < li.childNodes.length; i++) {
-      const c = li.childNodes[i];
+  // lib/md2doc.js's renderEditModeList) that holds this block's own inline
+  // content, or null. S1 removed the pre-per-li "fall back to the <li> itself"
+  // shape: a flat li block ALWAYS has exactly one .ed-li-text child (the
+  // renderer emits it unconditionally, and splitListItemAtCaret() below
+  // reproduces it), so a null here means the element is not a list block at
+  // all — which callers must not paper over.
+  function liTextEl(blockEl) {
+    for (let i = 0; i < blockEl.childNodes.length; i++) {
+      const c = blockEl.childNodes[i];
       if (c.nodeType === 1 && c.nodeName === 'DIV' &&
           c.classList && c.classList.contains('ed-li-text')) return c;
     }
-    return li;
+    return null;
   }
 
-  // Task 8: the non-editable checkbox chrome (spec §6) of `li`, if any.
-  function liCheckEl(li) {
-    for (let i = 0; i < li.childNodes.length; i++) {
-      const c = li.childNodes[i];
+  // Task 8: the non-editable checkbox chrome (spec §6) of `blockEl`, if any.
+  function liCheckEl(blockEl) {
+    for (let i = 0; i < blockEl.childNodes.length; i++) {
+      const c = blockEl.childNodes[i];
       if (c.nodeType === 1 && c.nodeName === 'SPAN' &&
           c.classList && c.classList.contains('ed-li-check')) return c;
     }
     return null;
   }
 
-  // An item is "empty" (brief: "Enter on EMPTY item = remove it") when it
-  // has no nested sublist (removing it would orphan real content — refuse
-  // that case rather than silently dropping children) and its own text is
-  // blank (covers a bare placeholder <br> too — a <br>-only li's
-  // textContent is '').
-  // LEGACY (pre-per-li): used only by handleListKeydown()'s whole-list surface,
-  // which is itself already unreachable (blockmap emits no type:'list' blocks in
-  // the per-li architecture, so no burst can have blockType 'list' — see
-  // resolveBurst()'s own LEGACY note); kept because that surface's empty-Enter
-  // REMOVES the item, which is why the sublist refusal is still correct there.
-  // The per-li path uses liOwnTextIsBlank() below; see RULING F-Q on its own
-  // comment for why the two must differ.
-  function isEmptyListItem(li) {
-    if (directNestedListOf(li)) return false;
-    return li.textContent.replace(/ /g, ' ').trim() === '';
-  }
-
   // Task 8 / RULING F-Q: "empty" for the PER-LI Enter contract (spec §11 row 3)
-  // means the item's OWN text is blank. A nested sublist does NOT disqualify it,
-  // unlike isEmptyListItem() above: that predicate guards a path which REMOVES
-  // the item, where refusing is the only way not to orphan its children, while
-  // row 3's press OUTDENTS the item and the subtree travels with it — so there
+  // means the item's OWN text is blank. Owning children does NOT disqualify it:
+  // row 3's press OUTDENTS the item and the subtree travels with it, so there
   // is nothing to orphan. Spec §4 / §11 row 3 state the outdent with no
-  // carve-out, so gating row 3 on isEmptyListItem() silently sent an empty
-  // item that owned a sublist to the row-1 SPLIT instead (two empty items, the
+  // carve-out, so gating row 3 on "has no children" silently sent an empty item
+  // that owned a sublist to the row-1 SPLIT instead (two empty items, the
   // subtree re-parented under the second).
   //
-  // "Own text" is the `.ed-li-text` surface's text, which by construction
-  // excludes the nested list (a sibling of that div inside the <li>). NBSP is
-  // normalised to a space so a surface holding only a non-breaking space still
-  // counts as blank, and a bare placeholder <br> counts too (its textContent is
-  // '') — both carried over from isEmptyListItem().
-  function liOwnTextIsBlank(li) {
-    const textEl = liTextEl(li);
-    if (textEl !== li) return textEl.textContent.replace(/ /g, ' ').trim() === '';
-    // Bare (pre-per-li) shape: no wrapper div, so sum the item's own non-list
-    // children explicitly rather than reading li.textContent, which would
-    // include every descendant item's text.
-    let text = '';
-    for (let i = 0; i < li.childNodes.length; i++) {
-      const c = li.childNodes[i];
-      if (c.nodeName !== 'UL' && c.nodeName !== 'OL') text += c.textContent;
-    }
-    return text.replace(/ /g, ' ').trim() === '';
+  // "Own text" is the `.ed-li-text` surface's text, which in the flat model is
+  // the item's own content by construction — descendants are separate blocks,
+  // not descendants of this element. NBSP is normalised to a space so a surface
+  // holding only a non-breaking space still counts as blank, and a bare
+  // placeholder <br> counts too (its textContent is '').
+  function liOwnTextIsBlank(blockEl) {
+    const textEl = liTextEl(blockEl);
+    if (!textEl) return false;
+    return textEl.textContent.replace(/\u00a0/g, ' ').trim() === '';
   }
 
   // Task 8 / RULING F-U: true when `el` holds nothing any serializer would emit
@@ -2265,35 +3960,36 @@
     return true;
   }
 
-  // Splits `li` into two siblings at the caret via Range surgery — the same
-  // extractContents()-based pattern wrapRangeIn() above already uses, so
-  // inline formatting (a caret mid-<strong>, say) splits cleanly instead of
+  // Splits `blockEl` into two sibling BLOCKS at the caret via Range surgery —
+  // the same extractContents()-based pattern wrapRangeIn() above already uses,
+  // so inline formatting (a caret mid-<strong>, say) splits cleanly instead of
   // being torn.
   //
-  // Task 8 (per-li arch): the caret lives inside `li`'s own
-  // `<div class="ed-li-text">` surface, not directly under the <li>, so the
-  // tail range runs to the END OF THAT DIV and the new sibling gets a
-  // .ed-li-text div of its own to hold it. The provisional <li> deliberately
-  // carries NO data-block-id / data-indent / data-list-type: list-md.js reads
-  // those only for per-li unsupported ATTRIBUTION, and the very next
-  // commitListStructure() + re-render replaces it with a real, server-numbered
-  // block anyway. A `.ed-li-check` sibling IS reproduced (unchecked) so that
-  // splitting a task item yields another task item rather than silently
-  // converting the tail half to a plain bullet.
+  // The caret lives inside the block's own `<div class="ed-li-text">` surface,
+  // so the tail range runs to the END OF THAT DIV and the new block gets a
+  // .ed-li-text div of its own to hold it. The provisional block deliberately
+  // carries NO data-block-id: list-md.js reads it only for per-li unsupported
+  // ATTRIBUTION, and the very next commitListStructure() + re-render replaces
+  // this element with a real, server-numbered block anyway. It DOES carry
+  // data-block-type / data-list-type / data-task / data-indent, all of which
+  // serializeBlocks() reads to emit the line, plus a `.ed-li-marker` and (for a
+  // task item) an unchecked `.ed-li-check`, so splitting a task item yields
+  // another task item rather than silently converting the tail half to a plain
+  // bullet.
   //
-  // A trailing nested sublist travels with the NEW (second) item — per
-  // list-md.js's documented shape it is always `li`'s last child, i.e. it
-  // physically follows the caret, so this is the same deterministic
-  // "whichever half it follows in DOM order" rule the pre-Task-8 version had,
-  // and it matches the spec's Enter contract (the new block inherits the
-  // subtree).
+  // S1: the subtree needs no handling at all. A block's children are the
+  // contiguous deeper blocks that FOLLOW it, and the new block is inserted
+  // directly after the old one — so the subtree lands under the NEW item for
+  // free, which is the same "whichever half it follows in DOM order" rule the
+  // nested version had and what the spec's Enter contract requires.
   //
-  // Returns the new <li>, or null when the caret is not inside `li`'s own
-  // surface (nothing mutated).
-  function splitListItemAtCaret(li) {
+  // Returns the new block element, or null when the caret is not inside
+  // `blockEl`'s own surface (nothing mutated).
+  function splitListItemAtCaret(blockEl) {
     const sel = window.getSelection();
     if (!sel.rangeCount) return null;
-    const textEl = liTextEl(li);
+    const textEl = liTextEl(blockEl);
+    if (!textEl) return null;
     const range = sel.getRangeAt(0).cloneRange();
     // Containment is checked BEFORE deleteContents() so the refusal below is a
     // true no-op rather than "the selection was deleted, then we gave up".
@@ -2303,220 +3999,141 @@
     tailRange.setStart(range.startContainer, range.startOffset);
     tailRange.setEnd(textEl, textEl.childNodes.length);
     const tailFrag = tailRange.extractContents();
-    const newLi = document.createElement('li');
-    const check = liCheckEl(li);
+
+    const newBlock = document.createElement('div');
+    newBlock.className = 'ed-block';
+    newBlock.setAttribute('data-block-type', 'li');
+    newBlock.setAttribute('data-list-type', blockEl.getAttribute('data-list-type') || 'ul');
+    newBlock.setAttribute('data-task', blockEl.getAttribute('data-task') === '1' ? '1' : '0');
+    setBlockIndent(newBlock, Number(blockEl.getAttribute('data-indent')) || 0);
+    const marker = document.createElement('span');
+    marker.className = 'ed-li-marker';
+    marker.setAttribute('aria-hidden', 'true');
+    newBlock.appendChild(marker);
+    const check = liCheckEl(blockEl);
     if (check) {
       const newCheck = check.cloneNode(false);
       newCheck.setAttribute('data-checked', '0');
       newCheck.setAttribute('aria-checked', 'false');
-      newLi.appendChild(newCheck);
-    }
-    if (textEl === li) {
-      // Pre-per-li bare shape: no .ed-li-text wrapper to reproduce.
-      newLi.appendChild(tailFrag);
-    } else {
-      const newText = document.createElement('div');
-      newText.className = 'ed-li-text';
-      newText.appendChild(tailFrag);
-      newLi.appendChild(newText);
-    }
-    const sub = directNestedListOf(li);
-    if (sub) newLi.appendChild(sub);
-    li.parentNode.insertBefore(newLi, li.nextSibling);
-    return newLi;
-  }
-
-  // Removes `li` from its list. If that empties out a NESTED sublist (never
-  // the burst's own root list — editEl's own parent is the block <div>, not
-  // an <li>, so this never touches the root), the now-empty <ul>/<ol> is
-  // cleaned up too rather than left dangling.
-  function removeListItem(li) {
-    const parentList = li.parentNode;
-    parentList.removeChild(li);
-    if (parentList.childElementCount === 0 &&
-        parentList.parentNode && parentList.parentNode.nodeName === 'LI') {
-      parentList.parentNode.removeChild(parentList);
-    }
-  }
-
-  // Tab: `li` becomes the LAST child of its previous sibling's own nested sublist
-  // of the SAME ordered/unordered type as the list `li` is moving out of
-  // (creating one when `prev` has no type-matched sublist). No previous sibling
-  // -> no-op (brief). Returns true iff a mutation actually happened, so the
-  // caller only snaps history on a real change.
+      newBlock.appendChild(newCheck);
+    }
+    const newText = document.createElement('div');
+    newText.className = 'ed-li-text';
+    newText.appendChild(tailFrag);
+    newBlock.appendChild(newText);
+    blockEl.parentNode.insertBefore(newBlock, blockEl.nextSibling);
+    return newBlock;
+  }
+
+  // S1: removing an item is removing its element. There is no list container
+  // left to clean up when it empties — the run simply has one member fewer.
+  // Callers must have established that the block owns no children (see
+  // liBlockHasChildren()); the flat model would otherwise leave orphans behind
+  // at a deeper indent than anything above them.
+  function removeListItem(blockEl) {
+    blockEl.parentNode.removeChild(blockEl);
+  }
+
+  // The contiguous run of blocks immediately after `blockEl` whose indent is
+  // strictly greater than `indent` — i.e. that item's subtree in the flat
+  // model. Used by the outdent below, which moves the subtree with its owner.
+  function subtreeBlocksAfter(blockEl, indent) {
+    const all = allBlockEls();
+    const i = all.indexOf(blockEl);
+    const out = [];
+    if (i < 0) return out;
+    for (let k = i + 1; k < all.length; k++) {
+      const a = liAttrs(all[k]);
+      if (!a || a.indent <= indent) break;
+      out.push(all[k]);
+    }
+    return out;
+  }
+
+  // Tab (spec §3.5, 清單項 row): the item's indent goes up by one, clamped by
+  // spec §3.4 rule 1 — "the previous block's indent + 1", with an upper bound of
+  // 0 when the previous block is not a list item. Returns true iff something
+  // actually moved, so the caller only commits on a real change.
   //
-  // RULING F-T: the target must be type-matched, and the type that matters is
-  // the MOVING item's own current list — not whichever sublist `prev` happens to
-  // own first. `directNestedListOf(prev)` returned that first sublist regardless
-  // of its tag, so Tab on a bullet whose previous sibling owned an <ol> appended
-  // the bullet into that <ol>, and list-md.js derives an item's marker from its
-  // list node (serializeListNode()'s `ordered`) — silently re-emitting an item
-  // the user never touched as '1.'/'2.'. Identical root cause to
-  // outdentListItem()'s adoption target below; see directNestedListOfType().
-  function indentListItem(li) {
-    const prev = li.previousElementSibling;
-    if (!prev || prev.nodeName !== 'LI') return false;
-    const listTag = li.parentNode.nodeName; // captured before the move detaches li
-    let nested = directNestedListOfType(prev, listTag);
-    if (!nested) {
-      nested = document.createElement(listTag === 'OL' ? 'ol' : 'ul');
-      prev.appendChild(nested);
-    }
-    li.parentNode.removeChild(li);
-    nested.appendChild(li);
-    return true;
-  }
-
-  // Shift+Tab (spec §11 row 6, user-verified against Notion): `li` moves out
-  // to become the NEXT sibling of the <li> that owns its current list, and its
-  // former FOLLOWING same-level siblings are ADOPTED as its children. Top
-  // level (no owning <li>) -> no-op (row 8).
+  // ── Task 6: THE SUBTREE NO LONGER FOLLOWS ──────────────────────────────
+  // Up to v2.10.2 an indent dragged the item's whole subtree with it. That was
+  // never a decision, it was an artifact: pre-S1 Tab re-parented the <li> and
+  // the nested <ul> travelled inside it, and the flat rewrite reproduced the
+  // observable behaviour rather than changing two things at once.
   //
-  // Task 8 replaces the pre-Task-8 "siblings stay" rule. Why adoption is the
-  // right shape: the outdented item rises one column, so any item that used to
-  // follow it at the OLD level would otherwise have to rise with it (losing
-  // its relationship to the item above it) or stay put and become a sibling of
-  // the item it used to follow. Notion's answer — and the spec's — is that
-  // those items keep their exact visual indent and become children of the
-  // item that just passed them. That is also the only one of the three
-  // outcomes that is a pure re-parenting: no item's rendered indent column
-  // changes except `li`'s own.
+  // Spec §3.5 says the opposite, and the user chose it explicitly after seeing
+  // both behaviours side by side: the children keep their own indent and
+  // therefore become the operated item's SIBLINGS. So '- a / - b / (2sp)- b1'
+  // + Tab on b now gives '- a / (2sp)- b / (2sp)- b1', not
+  // '- a / (2sp)- b / (4sp)- b1'. The row-5 scenario in
+  // test/editor-client-runtime.test.js pinned the old expectation and was
+  // migrated with this change.
   //
-  // Two hazards this walk is written around (both real against server-rendered
-  // list HTML, and both silent if got wrong):
-  //   1. The list carries marked's pretty-print "\n" text nodes BETWEEN items.
-  //      A blanket "remove every following node" loop would drop them (which is
-  //      harmless — list-md.js treats them as insignificant, see its
-  //      isBlankText()) but the same loop would ALSO drop any following node
-  //      that is neither an <li> nor whitespace, i.e. silently delete real
-  //      content. So only <li>s (collected) and blank text nodes (discarded)
-  //      are detached; anything else is left exactly where it is. Such a node
-  //      makes the whole run unsupported anyway (serializeList() flags a
-  //      non-LI child of a UL/OL), so listRunSupportsStructuralEdit() has
-  //      already refused the key before this function is reached — this is
-  //      defense in depth, not a live path.
-  //   2. The emptied parent list is removed only when it has no ELEMENT
-  //      children left — `childElementCount === 0`, i.e. the pre-Task-8 test,
-  //      which was already right. (`childNodes.length` would NOT be: the
-  //      leading "\n" text node in front of the moved item always survives, so
-  //      the list is never empty by NODE count even when it holds nothing.
-  //      childElementCount counts elements only, so whitespace text nodes are
-  //      already invisible to it.) The distinction is load-bearing because the
-  //      two candidate predicates differ in exactly one case — a non-LI ELEMENT
-  //      left behind in the list — and there childElementCount KEEPS the list,
-  //      which is what preserves the very node hazard 1 above deliberately
-  //      declined to move. A "still has an <li> child" test would instead have
-  //      deleted the list with that node inside it, making hazard 1's care
-  //      self-defeating.
+  // Nothing replaces the subtree walk: leaving the children alone IS the new
+  // rule, and §3.4's clamp confirms it is legal (a child at old+1 sits under a
+  // parent that is now also at old+1, whose bound is old+2).
   //
-  // Adoption target (third silent failure mode): the followers are appended into
-  // `li`'s own sublist of the SAME type as the list they came from, creating one
-  // if `li` has no matching sublist. Reusing whatever sublist `li` happened to
-  // have would rewrite the adopted items' markers — a bullet adopted into an
-  // <ol> comes back as '1.'. See directNestedListOfType().
-  function outdentListItem(li) {
-    const parentList = li.parentNode;
-    const grandLi = parentList.parentNode;
-    if (!grandLi || grandLi.nodeName !== 'LI') return false;
-    const grandList = grandLi.parentNode;
-    // Notion adoption: former following siblings become `li`'s own children.
-    const followers = [];
-    let n = li.nextSibling;
-    while (n) {
-      const next = n.nextSibling;
-      if (n.nodeName === 'LI') {
-        followers.push(n);
-        parentList.removeChild(n);
-      } else if (n.nodeType === 3 && /^\s*$/.test(n.textContent)) {
-        parentList.removeChild(n); // marked's pretty-print artifact — see hazard 1
-      }
-      n = next;
-    }
-    if (followers.length) {
-      let sub = directNestedListOfType(li, parentList.nodeName);
-      if (!sub) {
-        sub = document.createElement(parentList.nodeName === 'OL' ? 'ol' : 'ul');
-        li.appendChild(sub);
-      }
-      followers.forEach((f) => sub.appendChild(f));
-    }
-    parentList.removeChild(li);
-    grandList.insertBefore(li, grandLi.nextSibling);
-    if (parentList.childElementCount === 0) grandLi.removeChild(parentList); // see hazard 2
+  // S1: this is integer arithmetic on data-indent, not re-parenting. It
+  // reproduces the pre-S1 semantics exactly — there, an item with no previous
+  // <li> SIBLING could not indent, and in the flat model an item whose previous
+  // BLOCK is shallower-or-equal gets the same answer via the clamp (a deeper
+  // previous block belongs to the previous sibling's subtree and only raises
+  // the bound, which the +1 never reaches).
+  //
+  // RULING F-T is now structural rather than defensive: the moved item keeps
+  // its own data-list-type, so it can no longer be silently re-markered by
+  // being appended into a sublist of the other type.
+  function indentListItem(blockEl) {
+    const self = liAttrs(blockEl);
+    if (!self) return false;
+    // Rule (d): the first item of a LIST has nothing above it to nest under.
+    // Without this the §3.4 clamp would happily read the previous list's last
+    // item as "the previous block" and indent this one underneath it, merging
+    // two lists the user never asked to join. Pre-S1 this fell out of
+    // `previousElementSibling` being null inside the item's own <ul>.
+    if (self.listStart) return false;
+    const all = allBlockEls();
+    const i = all.indexOf(blockEl);
+    if (i < 0) return false;
+    const prev = liAttrs(all[i - 1]);
+    const max = prev ? prev.indent + 1 : 0;
+    const next = Math.min(self.indent + 1, max);
+    if (next === self.indent) return false;
+    setBlockIndent(blockEl, next);
     return true;
   }
 
-  function handleListKeydown(e, editEl) {
-    if (e.key === 'Enter') {
-      e.preventDefault();
-      if (e.shiftKey) {
-        insertBrAtCaret();
-        snapBurstIfActive(editEl, 'br');
-        return;
-      }
-      const li = caretListItem(editEl);
-      if (!li) return;
-      if (selectionSpansMultipleListItems(editEl)) {
-        // Refuse rather than silently deleting the spanned content — no
-        // mutation, no history snap. Collapse to the end of the selection
-        // so a repeat Enter (now a plain caret) behaves predictably.
-        // (Explicit removeAllRanges()/addRange() — same pattern every other
-        // Range-mutation in this file uses — rather than mutating the Range
-        // returned by getRangeAt() in place, which isn't guaranteed to sync
-        // back to the live Selection.)
-        const sel = window.getSelection();
-        if (sel.rangeCount) {
-          const r = sel.getRangeAt(0).cloneRange();
-          r.collapse(false);
-          sel.removeAllRanges();
-          sel.addRange(r);
-        }
-        return;
-      }
-      if (isEmptyListItem(li)) {
-        removeListItem(li);
-        snapBurstIfActive(editEl, 'list-remove');
-        editEl.blur(); // ends the burst -> commits, per the brief
-        return;
-      }
-      splitListItemAtCaret(li);
-      snapBurstIfActive(editEl, 'list-split');
-      return;
-    }
-    if (e.key === 'Tab') {
-      e.preventDefault();
-      const li = caretListItem(editEl);
-      if (!li) return;
-      const changed = e.shiftKey ? outdentListItem(li) : indentListItem(li);
-      if (changed) {
-        placeCaretAtEnd(li);
-        snapBurstIfActive(editEl, e.shiftKey ? 'list-outdent' : 'list-indent');
-      }
-      return;
-    }
-    if (e.key === 'Escape') {
-      e.preventDefault();
-      revertBurstAndEnd(editEl);
-      return;
-    }
-    if ((e.ctrlKey || e.metaKey) && !e.shiftKey && e.key === 'z') {
-      e.preventDefault();
-      burstUndo(editEl);
-      return;
-    }
-    if ((e.ctrlKey || e.metaKey) && (e.key === 'y' || (e.shiftKey && e.key === 'Z'))) {
-      e.preventDefault();
-      burstRedo(editEl);
-      return;
-    }
+  // Shift+Tab (spec §11 row 6 / §3.5, user-verified against Notion): the item
+  // rises one level, its OWN subtree rises with it, and its former FOLLOWING
+  // same-level siblings keep their indent — which is exactly what makes them
+  // its children afterwards. Top level (indent 0) -> no-op (row 8).
+  //
+  // S1: the three clauses of §3.5 collapse into two integer writes. Clause 2
+  // (the "adoption" the pre-S1 version implemented by physically re-parenting
+  // every follower into a freshly-created sublist of the matching type) is now
+  // free: leaving the followers' indent alone IS the adoption, and because they
+  // keep their own data-list-type they can no longer come back re-markered as
+  // '1.' — the third silent failure mode the nested implementation had to
+  // hand-guard against. Clause 3 is the same subtree walk indentListItem()
+  // above uses, with delta -1.
+  function outdentListItem(blockEl) {
+    const self = liAttrs(blockEl);
+    if (!self || self.indent === 0) return false;
+    const subtree = subtreeBlocksAfter(blockEl, self.indent);
+    setBlockIndent(blockEl, self.indent - 1);
+    subtree.forEach((el) => {
+      const a = liAttrs(el);
+      if (a) setBlockIndent(el, Math.max(0, a.indent - 1));
+    });
+    return true;
   }
 
   // ── Task 8 (Phase 4): Notion key semantics on per-li blocks ─────────────
   // Spec §4's "key semantics on li surfaces", acceptance rows 1, 3, 5, 6, 7,
   // 8. Structurally different from Task 4's whole-list handleListKeydown()
-  // above (which stays for the legacy 'list' surface): there, a key mutated
-  // one big contenteditable and the commit waited for focusout. Here each li
-  // is its own block AND its own surface, so a provisional <li> is not a real
+  // (deleted in S1 along with the rest of the legacy 'list' surface): there, a
+  // key mutated one big contenteditable and the commit waited for focusout.
+  // Here each li is its own block AND its own surface, so a provisional block is not a real
   // block until the run is committed and re-rendered — every mutating key
   // therefore commits immediately (spec §3: "any structural change
   // re-serializes the whole run → one line-range replace"), which is also what
@@ -2526,9 +4143,17 @@
   // convertEmptyTopLevelLiToParagraph() below and RULING F-J).
 
   // Shared refusal for a structural key on a run that cannot round-trip —
-  // see listRunSupportsStructuralEdit().
-  function refuseStructuralListEdit() {
-    showBanner('此清單含不支援的格式，無法調整結構', null, null);
+  // see listRunSupportsStructuralEdit(). Also reused (with an explicit
+  // `message` override) by the two blockOwnsNoLine() guards near
+  // openRawEditor() / deleteBlockViaGutter() above — a block that owns no
+  // source line at all is a different reason to refuse than "the run holds
+  // an unsupported format", so it gets its own wording, but there is still
+  // only ONE dismiss-only banner helper: two near-identical refusal
+  // functions in this closure collided once already (Task 4 fix round 1)
+  // and shadowed each other silently (last-declaration-wins), so the
+  // no-source-line callers pass their own text instead of a second function.
+  function refuseStructuralListEdit(message) {
+    showBanner(message || '此清單含不支援的格式，無法調整結構', null, null);
   }
 
   // Row 3, top-level press: spec §4 — "at top level the next press converts
@@ -2545,23 +4170,35 @@
   // 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.
-  async function convertEmptyTopLevelLiToParagraph(root, li) {
+  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
     // anchor, because a removal never shifts a block that starts ahead of it,
     // and the run's re-serialization only rewrites lines from the run's own
     // start onward — so this startLine survives the commit and is the stable
     // handle back to that block (ids are re-derived by every render).
-    const range = runRangeOf({ lines, blocks, stack }, root);
+    const range = runRangeOfBlocks({ lines, blocks, stack }, runEls);
     const liBlock = blocks.find((b) => b.id === Number(li.getAttribute('data-block-id')));
+    // `b.id !== liBlock.id` is not redundant: a block that owns no source line
+    // has endLine === startLine - 1, so it satisfies `endLine < startLine`
+    // AGAINST ITSELF and would be picked as its own predecessor. Unreachable
+    // today (such a block is never armed, so this row-3 path cannot start on
+    // one) but it is the same class of bug as the arming one above, and the
+    // guard costs nothing.
     const precedingBlock = liBlock
-      ? blocks.filter((b) => b.endLine < liBlock.startLine).pop()
+      ? blocks.filter((b) => b.id !== liBlock.id && b.endLine < liBlock.startLine).pop()
       : null;
+    // S1: the post-mutation span is the pre-mutation one minus the removed
+    // block. It cannot be re-derived from `li` afterwards (the element is
+    // detached), and re-deriving it from a survivor would be wrong for the
+    // last-item case, where the answer must be an EMPTY span (serializes to
+    // '', which is what takes commitListStructure()'s range-removal path).
+    const survivors = runEls.filter((el) => el !== li);
     mutateListRun(() => removeListItem(li));
-    // The key's own surface is inside the li that was just removed, so it is
-    // detached now — commit against the run ROOT (see commitListStructure()'s
-    // `runEl` note).
-    const ok = await commitListStructure(root, null, false, range);
+    // No `mutatedEl`: `li` is not IN `survivors`, and every block that is was
+    // left exactly as the file has it.
+    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
@@ -2585,32 +4222,52 @@
       snapBurstIfActive(editEl, 'br');
       return true;
     }
-    const root = listRunRootOf(editEl);
-    if (!root) return true;
-    // The CARET's li, not editEl's: a run has one editable surface per item,
+    // The CARET's block, not editEl's: a run has one editable surface per item,
     // and the caret can legitimately sit in a different one than the burst was
-    // opened on (placing a Range inside another li's surface does not move
-    // focus). closestListItem(editEl) is the fallback when the selection is
+    // opened on (placing a Range inside another item's surface does not move
+    // focus). closestLiBlock(editEl) is the fallback when the selection is
     // absent or outside the run.
-    const li = caretListItem(root) || closestListItem(editEl, root);
+    const li = caretLiBlock() || closestLiBlock(editEl);
     if (!li) return true;
+    // S1: the commit span, re-derived AFTER each mutation below (an indent
+    // change can move a block between runs). This one is the PRE-mutation span
+    // the gates run against.
+    let run = listRunOf(li);
+    if (!run.length) return true;
 
     if (e.key === 'Tab') {
-      if (!listRunSupportsStructuralEdit(root)) { refuseStructuralListEdit(); return true; }
-      // Row 5 (Tab): indentListItem() moves ONLY the caret item and its own
-      // subtree — later siblings are untouched. Row 6 (Shift+Tab):
-      // outdentListItem() raises it one level and adopts its former following
-      // siblings. Rows 7/8: 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 changed = mutateListRun(() => (e.shiftKey ? outdentListItem(li) : indentListItem(li)));
+      // `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;
+      const changed = mutateListRun(() => {
+        if (!(e.shiftKey ? outdentListItem(li) : indentListItem(li))) return false;
+        applyIndentClamp(run, li, oldIndent);
+        return true;
+      });
       if (!changed) return true;
-      commitListStructure(editEl, runLineOfListItem(root, li), 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;
     }
 
     // Enter.
-    if (selectionSpansMultipleListItems(root)) {
+    if (selectionSpansMultipleListItems()) {
       // Refuse rather than silently deleting the spanned content — no
       // mutation, no commit, no banner. Collapse to the end of the selection
       // so a repeat Enter (now a plain caret) behaves predictably.
@@ -2627,7 +4284,11 @@
       }
       return true;
     }
-    if (!listRunSupportsStructuralEdit(root)) { refuseStructuralListEdit(); return true; }
+    // Enter's target is the caret's own item in every one of its three
+    // outcomes (split, empty-outdent, convert-to-paragraph) — each rewrites
+    // that item's own line range, which is exactly what a hard-wrapped item
+    // refuses (spec §4.1).
+    if (!listRunSupportsStructuralEdit(run, li)) { refuseStructuralListEdit(); return true; }
     if (liOwnTextIsBlank(li)) {
       // Row 3: one press = one outdent, with the SAME semantics as Shift+Tab
       // (adoption included). RULING F-Q: an item that OWNS a sublist takes this
@@ -2647,11 +4308,15 @@
         // quirk), and only once the outdent above has actually happened, since a
         // refused press must leave the DOM byte-identical.
         const textEl = liTextEl(li);
-        if (textEl !== li && liSurfaceHoldsNothing(textEl)) textEl.innerHTML = '';
+        if (textEl && liSurfaceHoldsNothing(textEl)) textEl.innerHTML = '';
         return true;
       });
       if (outdented) {
-        commitListStructure(editEl, runLineOfListItem(root, li), true);
+        run = listRunOf(li);
+        // `li` is the mutated block (the outdent may have cleared its
+        // surface), so its own bytes are the DOM's, not the file's.
+        const carry = bystanderCarryOver(run, li);
+        commitListStructure(run, runLineOfBlock(run, li, carry), true, { carryOver: carry });
         return true;
       }
       // Already at top level, so this is row 3's "next press converts the block
@@ -2662,14 +4327,22 @@
       // did not touch. Refuse instead — a complete no-op (nothing mutated,
       // nothing committed, burst left open) until the user empties or moves the
       // children themselves.
-      if (directNestedListOf(li)) return true;
-      convertEmptyTopLevelLiToParagraph(root, li);
+      if (liBlockHasChildren(li)) return true;
+      convertEmptyTopLevelLiToParagraph(run, li);
       return true;
     }
     // Row 1: split at the caret; the caret goes to the START of the new block.
     const newLi = mutateListRun(() => splitListItemAtCaret(li));
     if (!newLi) return true;
-    commitListStructure(editEl, runLineOfListItem(root, newLi), false);
+    run = listRunOf(newLi);
+    // `li` had its text CUT IN TWO in the DOM; replaying its source would put
+    // the whole of it back and duplicate the half that moved into `newLi`.
+    // Named explicitly rather than leaning on the dirty-burst exclusion: the
+    // caret can sit in a different item than the burst was opened on (see
+    // where `li` is derived above), and then the burst names the wrong block.
+    // `newLi` is provisional (no data-block-id) and excludes itself.
+    const carry = bystanderCarryOver(run, li);
+    commitListStructure(run, runLineOfBlock(run, newLi, carry), false, { carryOver: carry });
     return true;
   }
 
@@ -3167,8 +4840,17 @@
     if (!document.body.contains(tableEl)) {
       const liveBlockEl = startLine != null ? blockElAtLine(startLine) : null;
       liveTableEl = liveBlockEl ? blockContentEl(liveBlockEl) : null;
-      if (!liveTableEl || !liveTableEl.classList || !liveTableEl.classList.contains('ed-wys-table')) return null;
-      if (identity == null || tableIdentityOf(liveTableEl) !== identity) return null;
+      // T7: both refusals used to `return null` in silence — the drag, the
+      // insert, the alignment change simply did not happen and nothing on
+      // screen said why, which is indistinguishable from a broken control.
+      // Dropping is still the right answer (see the S1 comment above); saying
+      // nothing was not.
+      if (!liveTableEl || !liveTableEl.classList || !liveTableEl.classList.contains('ed-wys-table')) {
+        showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null;
+      }
+      if (identity == null || tableIdentityOf(liveTableEl) !== identity) {
+        showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null;
+      }
     }
     if (currentBurst && currentBurst.blockType === 'table' && currentBurst.editEl === liveTableEl) return liveTableEl;
     const cell = tableCellsOf(liveTableEl)[0];
@@ -3308,8 +4990,8 @@
   // grips below are the fix: real, adequately-sized (≥18×24px) elements the
   // user can actually see and aim for. Both grips are overlay elements
   // `position: fixed`-appended to document.body — never DOM CHILDREN of a
-  // contenteditable cell, even though the row grip now visually overlaps one
-  // (P0-a moved it just INSIDE the table's left border; see the geometry
+  // contenteditable cell, even though the row grip's inner half visually
+  // overlaps one (it straddles the table's left border; see the geometry
   // note in the "Notion-style row/column grip handles" section below). So —
   // unlike the old zones, which
   // sat INSIDE an already-permanently-contenteditable cell and needed the
@@ -3323,8 +5005,9 @@
   // row gets a grip, the header <tr> included (spec §3.10/§4.6: in markdown a
   // table's first row IS its header, so position alone decides header
   // identity — dragging a data row above the header PROMOTES it, and the old
-  // header becomes a data row). The header's grip is offset DOWN by
-  // TE_HEADER_GRIP_DY_PX so it stays clear of the column-grip band.
+  // header becomes a data row). EVERY row's grip — the header's included —
+  // uses the SAME geometry: centred on the table's left border, vertically
+  // centred on its own row. There is no per-row-type special case.
   //
   // After a small movement threshold (distinguishing "click to open the
   // menu" from "press-and-drag"), a drop-indicator line tracks the pointer
@@ -3612,9 +5295,8 @@
   // hovering any cell of — EVERY row, the header included (spec §3.10: the
   // header is draggable too, since position alone decides header identity;
   // only its CLICK differs, highlighting instead of opening the
-  // delete-only menu). On the header row the grip is additionally offset
-  // DOWN by TE_HEADER_GRIP_DY_PX so it does not collide with the column
-  // grip's own band above the table; `colGrip` is a horizontal 6-dot handle
+  // delete-only menu) — positioned identically on every row, header
+  // included; `colGrip` is a horizontal 6-dot handle
   // shown just ABOVE whichever column the pointer is hovering (every
   // column, header included — the column menu's delete/align both apply to
   // header cells too). Built once by buildTableGrip() below and driven by
@@ -3622,15 +5304,20 @@
   // listener (wired near the bottom of this file) that already drives
   // updateTableInsertBubbles() — see its own comment for the coalescing
   // contract this reuses.
-  // Review fix (P0-a): neither grip is separated from the table any more.
-  // The COLUMN grip's centerline coincides with the table's top edge, so its
-  // hit rect straddles that border by ~half its own height on each side. The
-  // ROW grip sits fully INSIDE the table instead — its LEFT edge on the
-  // table's left border, extending inward — because the space just outside
-  // that border belongs to the block's own gutter ⠿ (spec §4.2 衝突 2). The
-  // visible consequence of that choice is that the leftmost ~20px (the row
-  // grip's own CSS width) of the first column is covered by the grip, so a
-  // click there does not place the caret; it is a known, accepted trade.
+  // Review fix (P0-a) + user acceptance (uniform geometry): neither grip is
+  // separated from the table, and both use the SAME rule — the grip's own
+  // CENTRELINE coincides with the table border it belongs to, so its hit
+  // rect straddles that border by half its own size on each side. COLUMN
+  // grip: centred on the table's TOP edge. ROW grip: centred on the table's
+  // LEFT edge. An earlier revision insetted the row grip fully INSIDE the
+  // table to dodge the block's own gutter ⠿; that was reverted — the ⠿
+  // occupies only the block's top ~20px while a row grip sits at its own
+  // row's mid-height, so the two never actually intersect, and the inset put
+  // the grip on top of the first cell's TEXT (user-acceptance defect). The
+  // gutter is given its own room in CSS instead (`.content { padding-left }`
+  // plus `.ed-handle/.ed-insert { left: -36px }`, both edit-mode-only — see
+  // lib/md2doc.js), so the straddling grip reaches only into the first
+  // cell's PADDING, never its text.
   // Either way the grip's hit rect DOES overlap the insert bubble's hit
   // rect (the bubble extends TB_BUBBLE_SIZE/2 = 9px past the edge on its
   // own axis). Non-intersection via rect separation is no longer possible
@@ -3698,17 +5385,6 @@
     gripColIndex = null;
   }
 
-  // spec §4.2 衝突 2/3：row grip 一律落在表格**內側**（dx=0，左緣貼齊表格
-  // 左邊界向內延伸），避開頁面 gutter 的 ⠿；表頭列的 grip 額外**往下**
-  // 偏移，避開 colGrip 佔住的 [tableTop−12, tableTop+12] 帶。往左或往上
-  // 都會重新製造衝突，所以只有這一個方向。
-  // updateTableEdgeGrips() 與 pointInRowGripZone() 共用這張表——兩邊各算
-  // 一次就是 grip「看得到但按不到」的經典成因。
-  const TE_HEADER_GRIP_DY_PX = 16;
-  function rowGripOffsetFor(rowEl, tableEl) {
-    return { dx: 0, dy: rowEl === headerRowOf(tableEl) ? TE_HEADER_GRIP_DY_PX : 0 };
-  }
-
   // Bug fix (user acceptance) — history: grips were originally BOTH
   // border-straddling (P0-a), and were visible on hover but UNREACHABLE by a
   // real pointer. Root cause — a pointer travelling from inside a cell
@@ -3720,15 +5396,12 @@
   // gripCenter(), which jump straight to the grip's own coordinates) could
   // ever land on it; a real mouse gesture could not.
   //
-  // Current geometry (spec §4.2 衝突 2, this file's row-grip-inside-table
-  // change above): the ROW grip no longer straddles the border — its left
-  // edge sits ON the table's left border, extending INWARD, fully inside the
-  // table (see rowGripOffsetFor() above). A pointer travelling from a cell to
-  // the row grip's centre therefore never leaves the table, so the
-  // corridor-crossing bug described above no longer applies to the row grip.
-  // The COLUMN grip is UNCHANGED and still straddles the table's top border
-  // (half above the border, half below), so the corridor-crossing bug above
-  // still applies to it exactly as originally described.
+  // Current geometry (uniform, both axes): BOTH grips straddle their own
+  // table border — the row grip half outside / half inside the table's LEFT
+  // border, the column grip half above / half below its TOP border. So the
+  // corridor-crossing bug described above applies to BOTH of them exactly as
+  // originally described, and both keep-zones below cover the corresponding
+  // outside-the-border corridor.
   //
   // Review fix (Important, first pass over-permissive): the first version of
   // this fix kept a grip visible while the pointer was ANYWHERE within the
@@ -3741,15 +5414,14 @@
   // SPECIFIC shown grip's own anchor (pointInRowGripZone()/
   // pointInColGripZone() below) instead of the whole table.
   //
-  // What each keep-zone covers TODAY: pointInRowGripZone() is the union of
-  // (the row grip's own rect, padded by TE_GRIP_ZONE_PAD_PX for sub-pixel
-  // rounding) and (the vertical span between the grip and its anchor row —
-  // needed because a header-row grip, offset DOWN by TE_HEADER_GRIP_DY_PX,
-  // can sit below the row's own bottom edge; see rowGripOffsetFor() above).
-  // pointInColGripZone() keeps the ORIGINAL corridor shape: the straight
-  // strip between the grip's own top edge and the table's top border, x
-  // clamped to the anchor column's own horizontal extent, padded — because
-  // the column grip still straddles the border.
+  // What each keep-zone covers TODAY: both keep the ORIGINAL corridor shape,
+  // mirrored per axis. pointInRowGripZone() is the union of (the row grip's
+  // own rect, padded by TE_GRIP_ZONE_PAD_PX for sub-pixel rounding) and (the
+  // straight strip between the grip's own LEFT edge and the table's LEFT
+  // border, y clamped to the anchor ROW's own vertical extent, padded).
+  // pointInColGripZone() is the same with the axes swapped: the strip
+  // between the grip's own top edge and the table's top border, x clamped to
+  // the anchor COLUMN's own horizontal extent, padded.
   // A pointer outside either grip's own zone is a genuine exit and still
   // hides the grip via hideTableGrips(), same as before. Neither fix touches
   // either grip's size or z-index, so the click-priority guarantee (bubble
@@ -3771,15 +5443,13 @@
       !document.body.contains(gripRowEl) || !document.body.contains(gripRowTableEl)) return false;
     const gr = rowGrip.getBoundingClientRect();
     if (pointInPaddedRect(x, y, gr, TE_GRIP_ZONE_PAD_PX)) return true;
-    // grip 現在在表格內側，所以「從儲存格走向 grip」全程都在表格上，由
-    // updateTableEdgeGrips() 的 onValidCell 分支處理。這裡只需要涵蓋
-    // grip 自己的矩形、以及它與所錨定那一列之間的垂直落差（表頭 grip 被
-    // 往下偏移，可能超出該列的上下緣）。
+    // grip 跨在表格左邊界上，所以「從儲存格走向 grip」必定經過邊界外側的
+    // 那半個 grip 寬度。走廊＝從 grip 自己的左緣到表格左緣，垂直方向夾在
+    // 所錨定那一列的上下緣（加 TE_GRIP_ZONE_PAD_PX 的次像素寬容）。
     const rowRect = gripRowEl.getBoundingClientRect();
-    const top = Math.min(rowRect.top, gr.top) - TE_GRIP_ZONE_PAD_PX;
-    const bottom = Math.max(rowRect.bottom, gr.bottom) + TE_GRIP_ZONE_PAD_PX;
-    return x >= gr.left - TE_GRIP_ZONE_PAD_PX && x <= gr.right + TE_GRIP_ZONE_PAD_PX &&
-      y >= top && y <= bottom;
+    const tableRect = gripRowTableEl.getBoundingClientRect();
+    return x >= gr.left && x <= tableRect.left &&
+      y >= rowRect.top - TE_GRIP_ZONE_PAD_PX && y <= rowRect.bottom + TE_GRIP_ZONE_PAD_PX;
   }
 
   function pointInColGripZone(x, y) {
@@ -3808,10 +5478,9 @@
   function updateTableEdgeGrips(x, y, target) {
     // Both grips are `position: fixed` overlays appended to document.body
     // (same as the hover-insert bubbles) rather than descendants of the
-    // table — regardless of whether they PAINT outside it (the column grip,
-    // straddling the top border) or inside it (the row grip, whose left edge
-    // sits on the table's left border and which extends inward over the
-    // first column). So the moment the real pointer crosses from a cell onto
+    // table — both PAINT half outside it (the column grip straddling the top
+    // border, the row grip straddling the left border). So the moment the
+    // real pointer crosses from a cell onto
     // the grip itself, `target` is the grip and is no
     // longer inside any '.ed-block[data-block-type="table"]' or 'th, td'.
     // Without this guard, that transition would hit the "nothing found"
@@ -3845,8 +5514,9 @@
 
     // Row grip: every row, including the header — the first row of a
     // markdown table IS the header, so any row must be draggable to the
-    // top to become it (rowGripOffsetFor() shifts the header's own grip
-    // down, clear of the column-grip band, so the two never collide). The
+    // top to become it. ONE position rule for all of them (user acceptance:
+    // 「grip 位置都一樣」) — centred on the table's left border, vertically
+    // centred on its own row; no header special case. The
     // one exception is a header-only table (no body rows): its single row
     // is thead's only row, and dragging it away would empty the thead —
     // serializeTable() would degrade it and the user's table would vanish
@@ -3859,10 +5529,10 @@
       // (20x28) — offsetWidth/Height read 0 while `hidden` (display: none)
       // is still true on the FIRST show of a hover session, before the
       // `hidden = false` assignment below takes effect.
+      const gw = rowGrip.offsetWidth || 20;
       const gh = rowGrip.offsetHeight || 28;
-      const off = rowGripOffsetFor(rowEl, tableEl);
-      rowGrip.style.left = (tableRect.left + off.dx) + 'px';
-      rowGrip.style.top = (r.top + r.height / 2 - gh / 2 + off.dy) + 'px';
+      rowGrip.style.left = (tableRect.left - gw / 2) + 'px';
+      rowGrip.style.top = (r.top + r.height / 2 - gh / 2) + 'px';
       rowGrip.hidden = false;
     } else {
       gripRowTableEl = null;
@@ -4719,11 +6389,22 @@
       const checkEl = e.target.closest && e.target.closest('.ed-li-check');
       if (checkEl) {
         e.preventDefault();
-        const li = checkEl.closest('li.ed-block');
+        const li = closestLiBlock(checkEl);
         if (!li) return;
-        const root = listRunRootOf(checkEl);
-        if (!root) return;
-        if (!listRunSupportsStructuralEdit(root)) { refuseStructuralListEdit(); return; }
+        const run = listRunOf(li);
+        if (!run.length) return;
+        // The toggle rewrites the checkbox INSIDE this item's own marker, so
+        // the item is the operation target (spec §4.1) — but by §4.1's own
+        // CRITERION (see listRunSupportsStructuralEdit()'s note) it is a
+        // COLUMN-ONLY operation and therefore not one of the refusals: it
+        // changes no content, no line count and no column at all ('[ ] ' and
+        // '[x] ' are the same width, so §3.4's colDelta is exactly 0). Without
+        // this a hard-wrapped task item — which on a real to-do list is most
+        // of them — answered '此清單含不支援的格式，無法調整結構' to a click
+        // on its own checkbox.
+        if (!listRunSupportsStructuralEdit(run, li, { columnOnly: true })) {
+          refuseStructuralListEdit(); return;
+        }
         // Resolve any open burst on another block before mutating. The span
         // is non-focusable, so mousedown on it does NOT steal focus — the
         // currently-focused surface's focusout never fires, and currentBurst
@@ -4736,22 +6417,31 @@
         if (!ok) return;
         // Re-find the li and its checkbox after the potential re-render.
         const targetLi = targetBlockId
-          ? document.querySelector('li.ed-block[data-block-id="' + targetBlockId + '"]')
+          ? document.querySelector(
+              '.ed-block[data-block-type="li"][data-block-id="' + targetBlockId + '"]')
           : null;
         const targetCheck = targetLi && targetLi.querySelector(':scope > .ed-li-check');
         if (!targetCheck) return;
         // Re-gate on the post-render DOM in case the burst resolution
         // changed the run's supported status.
-        const targetRoot = listRunRootOf(targetCheck);
-        if (!targetRoot) return;
-        if (!listRunSupportsStructuralEdit(targetRoot)) { refuseStructuralListEdit(); return; }
+        const targetRun = listRunOf(targetLi);
+        if (!targetRun.length) return;
+        if (!listRunSupportsStructuralEdit(targetRun, targetLi, { columnOnly: true })) {
+          refuseStructuralListEdit(); return;
+        }
         // Flip state, then serialize the whole run as one undo op.
         const wasChecked = targetCheck.getAttribute('data-checked') === '1';
         targetCheck.setAttribute('data-checked', wasChecked ? '0' : '1');
         targetCheck.setAttribute('aria-checked', String(!wasChecked));
         // focusStartLine = null: a checkbox click is not a caret gesture;
         // leave focus wherever the post-commit re-render puts it.
-        await commitListStructure(blockContentEl(targetLi), null, false);
+        // Column-only, so no `mutatedEl`: the flipped state travels in the
+        // re-stated MARKER (list-md.js builds '[x] ' as part of it, and
+        // splitSourceMarkers() strips the old one off the replayed line), and
+        // everything after that marker — this item's own continuation lines
+        // included — comes back byte-for-byte.
+        await commitListStructure(targetRun, null, false,
+          { carryOver: bystanderCarryOver(targetRun, null) });
         return;
       }
       // ⠿ handle: toggles its menu for the block it belongs to. ⠿ menu: its