@helping-ai-workflow/md2doc 2.11.1 → 3.0.0

package/lib/editor/client.js

@@ -174,6 +174,291 @@
     return { lines: r.lines, blocks, op, newStartLine };
   }
 
+  // ── S4 Task 3: relocating ONE block's lines (spec §4.5) ────────────────
+  //
+  // A move is ONE commitRangeEdit over
+  // `min(source, destination) .. max(source, destination)`. UndoStack's op is
+  // `{startLine, endLine, before, after}` — a SINGLE contiguous line range,
+  // with no notion of a source and a destination — so a move written as
+  // "removal here, insertion there" is two ops and two Ctrl+Z, which §3.4
+  // forbids. For a block that is not a li there is nothing to re-serialize:
+  // the lines are relocated VERBATIM, so nothing can be re-escaped and no
+  // marker arithmetic is involved.
+  //
+  // THE BLANK-LINE RULE, which the plan left to this task to define:
+  //
+  //   1. The block's own lines move byte-for-byte.
+  //   2. At the seam it LEAVES, the blank run that surrounded it is absorbed
+  //      and replaced by exactly ONE blank line — or by none when the block
+  //      was at the start or the end of the file.
+  //   3. At the seam it LANDS in, one blank line is emitted on each side of
+  //      it whose neighbouring line is not already blank.
+  //
+  // Neither existing helper is the right tool, and the plan says so:
+  // commitRangeRemoval() absorbs exactly one adjacent blank and
+  // commitBlockInsertion() always adds a leading one. Each is HALF of a move
+  // and the halves do not compose — the pair leaves the document one
+  // separator short at the seam that was left and one long at the seam that
+  // was landed in, and it is two undo ops.
+  //
+  // CONSEQUENCE, measured against marked.lexer + blockmap.buildBlockMap on
+  // every fixture in test/editor-client-runtime.test.js's T3 section before
+  // any byte was pinned: in a document whose blocks are separated by exactly
+  // one blank line — everything this editor's own serializer emits — a move
+  // is a PERMUTATION OF THE FILE'S LINES. Same lines, same count, same
+  // separators.
+  //
+  // The one exception, and it is deliberate: a document that already jams two
+  // blocks onto adjacent lines ('# A\n# B\n# C\n') has no blank at the
+  // landing seam to carry, so rule 3 CREATES one and the count goes up. It
+  // has to. MEASURED: 'paraA\n# H\n\nparaB\n' with paraA appended and no
+  // blank emitted is '# H\n\nparaB\nparaA\n', which marked.lexer answers as
+  // ONE paragraph — the move would have eaten a block. The count moves only
+  // in that direction, and only at a seam that had no separator to begin
+  // with.
+  //
+  // The final '' of a file that ends in a newline is the TERMINATOR, not a
+  // blank separator; `contentLen` below is what keeps rule 2 from eating the
+  // file's last newline when the block being moved is the last one.
+  //
+  // Pure: takes and returns plain data, and lives in the node-visible core
+  // beside the other commit helpers.
+  function planBlockMove(lines, blocks, src, dest) {
+    const isBlank = (s) => s !== undefined && s !== null && s.trim() === '';
+    const contentLen = lines.length - (lines.length && lines[lines.length - 1] === '' ? 1 : 0);
+    let above = 0;
+    while (src.startLine - 1 - above >= 1 && isBlank(lines[src.startLine - 2 - above])) above++;
+    let below = 0;
+    while (src.endLine + 1 + below <= contentLen && isBlank(lines[src.endLine + below])) below++;
+    // The source's own extraction range: its lines plus the whole blank run on
+    // either side of it. What goes BACK at that seam is rule 2's single blank,
+    // and only when the seam has a block on both sides of it.
+    const ds = src.startLine - above;
+    const de = src.endLine + below;
+    const srcFill = (ds >= 2 && de < contentLen) ? [''] : [];
+    const blockLines = lines.slice(src.startLine - 1, src.endLine);
+    // `dest === null` is the {mode:'append'} target: the insertion point is
+    // one line past the last block's last line.
+    const ins = dest ? dest.startLine
+      : (blocks.length ? blocks[blocks.length - 1].endLine + 1 : contentLen + 1);
+    // Dropped where it already is. `ins === ds` is "on my own top edge";
+    // `ins === de + 1` is "on the seam immediately below me" — visually the
+    // same place, and the byte no-op the drag's own release-where-you-started
+    // case depends on. Every other `ins` inside the extraction range is a
+    // blank line, which no block's startLine can name.
+    if (ins >= ds && ins <= de + 1) return null;
+    const prevLine = ins >= 2 ? lines[ins - 2] : null;
+    const nextLine = ins <= lines.length ? lines[ins - 1] : null;
+    const lead = (prevLine !== null && !isBlank(prevLine)) ? [''] : [];
+    const trail = (nextLine !== null && !isBlank(nextLine)) ? [''] : [];
+    const payload = lead.concat(blockLines, trail);
+    // ONE range, covering both seams. Everything between them is carried
+    // through untouched — which is what makes this a single undo op instead
+    // of a removal and an insertion.
+    if (ins > de + 1) {
+      const after = srcFill.concat(lines.slice(de, ins - 1), payload);
+      const newStart = ds + srcFill.length + (ins - 1 - de) + lead.length;
+      return { startLine: ds, endLine: ins - 1, after: after,
+        newRange: { startLine: newStart, endLine: newStart + blockLines.length - 1 } };
+    }
+    const after = payload.concat(lines.slice(ins - 1, ds - 1), srcFill);
+    const newStart = ins + lead.length;
+    return { startLine: ins, endLine: de, after: after,
+      newRange: { startLine: newStart, endLine: newStart + blockLines.length - 1 } };
+  }
+
+  // The commit half. `op === null` with `noop` set means the block was
+  // released where it already was — a BYTE no-op, not a failure, and
+  // deliberately distinct from commitRangeEdit()'s own unchanged-text
+  // `op: null` so a caller can tell "nothing to do" from "somebody handed me
+  // a range that produced the same text".
+  function commitBlockMove(state, src, dest) {
+    const plan = planBlockMove(state.lines, state.blocks, src, dest);
+    if (!plan) {
+      return { lines: state.lines, blocks: state.blocks, op: null, noop: 'same-position' };
+    }
+    const r = commitRangeEdit(state, plan.startLine, plan.endLine, plan.after.join('\n'));
+    r.newRange = plan.newRange;
+    return r;
+  }
+
+  // ── S4 Task 4: the pure half of a LIST ITEM's move (spec §4.5) ─────────
+  //
+  // A li's lines CANNOT be relocated the way planBlockMove() relocates every
+  // other block's — verbatim. Markers and ordinals are RUN-GLOBAL: '3. charlie'
+  // moved to the head of its run has to come back as '1. charlie' with
+  // everything behind it renumbered, and its indent prefix is a column count
+  // measured against the marker widths standing above it. So a li's move is
+  // expressed the way duplicateListItems() expresses a duplicate — as a
+  // REORDERED SPAN ARRAY handed to serializeBlocks(), committed over the run's
+  // own line range as ONE commitRangeEdit (§3.4: one gesture, one undo op).
+  // These two functions are the parts of that reasoning with no DOM in them.
+
+  // The span order after "the `count` members starting at `from` go
+  // immediately before the member at `insertAt`". `insertAt` names a slot in
+  // the array BEFORE the removal — it comes straight from the drop target's
+  // `before-block N` — so a DOWNWARD move is decremented by the WHOLE count
+  // and an upward one is not decremented at all: the same `insertAt` means two
+  // different slots depending on the direction, which is the whole reason this
+  // is a named function with its own test rather than a splice pair at the
+  // call site.
+  //
+  // S4 Task 6 widened it from one member to `count`, in place rather than
+  // beside: §4.5's 「grip 在選取集合內 → 整批搬」 is the SAME arithmetic and a
+  // second copy of an off-by-one is the 「不得另寫一條」 shape §3.6 has already
+  // ruled against twice. The single-item case is `count === 1` and its whole
+  // test table was migrated onto this signature unchanged.
+  //
+  // `null` means the order would be UNCHANGED, which is a byte no-op and not a
+  // failure: every `insertAt` from `from` to `from + count` inclusive is the
+  // SET'S OWN FOOTPRINT — `from` is "released on my own top edge",
+  // `from + count` is "released on the seam immediately below me", and the
+  // slots in between name a position INSIDE the set, which is not a reorder of
+  // the span but a shuffle of members that are travelling together. Visually
+  // they are all the same place, and they are the case the drag's own
+  // release-where-you-started gesture depends on. An out-of-range index, an
+  // empty set and a set that runs off the end answer `null` too; there is no
+  // order any of them could name.
+  function reorderSpanRange(length, from, count, insertAt) {
+    if (!(length > 0) || !(count > 0)) return null;
+    if (!(from >= 0) || from + count > length) return null;
+    if (!(insertAt >= 0) || insertAt > length) return null;
+    if (insertAt >= from && insertAt <= from + count) return null;
+    const rest = [];
+    const moved = [];
+    for (let i = 0; i < length; i++) {
+      if (i >= from && i < from + count) moved.push(i); else rest.push(i);
+    }
+    const at = insertAt > from ? insertAt - count : insertAt;
+    return rest.slice(0, at).concat(moved, rest.slice(at));
+  }
+
+  // ── S4 Task 6: the LINE RANGE a batch move relocates (spec §3.3, §4.5) ──
+  //
+  // §3.3's operand set is CONTIGUOUS in block order — resolveGutterOperands()
+  // refuses a gap before anything reaches here — so its members' lines plus
+  // the separators standing between them are ONE contiguous run, which is
+  // exactly what planBlockMove() relocates verbatim. That is the whole reason
+  // a batch move is the SAME single commitRangeEdit a one-block move is, and
+  // therefore the same single Ctrl+Z (§3.4).
+  //
+  // Named rather than written as an object literal at the call site because
+  // the set reaches the bytes through this one expression and nothing else: an
+  // endLine taken from any member but the LAST leaves the rest of the set
+  // standing where it was while its head travels, and the blank-line rules
+  // then re-emit separators around both halves — a document the user never
+  // asked for, from a one-token typo. A pure function is a mutation a test can
+  // kill in a millisecond instead of a browser round trip.
+  function spanMoveRange(recs) {
+    if (!recs || !recs.length) return null;
+    return { startLine: recs[0].startLine, endLine: recs[recs.length - 1].endLine };
+  }
+
+  // §4.5's INDENT SEAM, asked of the span AS IT WOULD BE COMMITTED.
+  //
+  // Markdown indent is only ever RELATIVE (indent-clamp.js's own opening
+  // sentence): an item's depth exists solely because a shallower item stands
+  // above it. serializeBlocks() rebuilds its marker-width stack as it walks the
+  // array, from empty — so a span whose FIRST block claims `data-indent="1"`
+  // emits that block at column 0, and the DOM and the file then disagree about
+  // the nesting. A move creates exactly that by lifting an item out from above
+  // its own child.
+  //
+  // The bound is deliberately the one indent-clamp.js's `boundAt()` computes
+  // — the previous li's indent + 1, and 0 when there is no previous li or the
+  // previous block is not one — so the predicate and the clamp cannot drift.
+  //
+  // S4 Task 7 KEPT it and moved it to AFTER the clamp. Asked of the raw
+  // reordered span it refused 1425 of the 4067 legal drops; the clamp now
+  // answers 1411 of those, and what this still refuses is the 14 no
+  // removal-clamp can reach — a batch whose last member is shallower than the
+  // block it lands before, i.e. the INSERTION half of the move. See
+  // performListItemDrop() for the single site and BLOCK_MOVE_ORPHAN_MESSAGE
+  // for the family and the sweep behind those numbers.
+  function spanIndentsAreAnchored(items) {
+    let prevLi = null;
+    for (let i = 0; i < (items || []).length; i++) {
+      const it = items[i] || {};
+      if (it.type !== 'li') { prevLi = null; continue; }
+      const indent = typeof it.indent === 'number' ? it.indent : 0;
+      if (indent > (prevLi === null ? 0 : prevLi + 1)) return false;
+      prevLi = indent;
+    }
+    return true;
+  }
+
+  // ── S4 Task 5: the CROSS-BOUNDARY seam predicate (spec §4.5) ──────────
+  //
+  // §4.5's ruling, made by the user on 2026-09-01 and implemented rather than
+  // re-opened: a cross-boundary move is REFUSED with a banner in 3.0.0 and the
+  // capability deferred to 3.1.0, whose first step is amending the spec with
+  // the blank-line rule for a run/non-run seam. This function is the whole of
+  // "which moves cross a boundary" for a block that is NOT a list item; a li
+  // source has its own, narrower question (its destination must be a slot in
+  // its own §3.8 run) and answers it in performListItemDrop().
+  //
+  // A move touches TWO seams and they need DIFFERENT rules. That asymmetry is
+  // the task's finding, and every row below is a marked.lexer measurement:
+  //
+  //   DESTINATION — where the block LANDS. An insertion can only ever SPLIT;
+  //   it has no way to merge two lists. So the only thing it can break is a
+  //   run it lands INSIDE, and the question is exactly "are these two
+  //   neighbours members of ONE run":
+  //     '# Doc\n\npara\n\n- a\n- b\n\ntail\n' with `para` spliced
+  //       between the items -> list(1) | paragraph | list(1): one two-item run
+  //       became two one-item runs, and the blanks rule 3 emits either side
+  //       are §4.3's looseness trap. REFUSED.
+  //     '# Doc\n\n- a\n\n1. b\n\ntail\n' with `para` spliced at the
+  //       same-looking seam -> heading | ul(1,tight) | paragraph |
+  //       ol(1,tight) | paragraph. Nothing merged, nothing loosened, because
+  //       these were already two lists. ACCEPTED — this is Task 3's
+  //       deliberate over-refusal, and narrowing it is what Task 5 owed.
+  //
+  //   SOURCE — where the block LEAVES. A removal MERGES, and it CANNOT be
+  //   narrowed with anything the block model carries. Every one of these
+  //   leaves ONE list with `loose === true`, i.e. every item renders as a <p>,
+  //   serializeBlocks() reports 'P' for each, and the whole run degrades
+  //   read-only with no banner:
+  //     '- a'      | para | '- b'        ->  '- a\n\n- b\n'
+  //     '1. a'     | para | '2. b'       ->  '1. a\n\n2. b\n'
+  //     '- [ ] a'  | para | '- [x] b'    ->  '- [ ] a\n\n- [x] b\n'
+  //     '- a'      | para | '  1. a1'    ->  '- a\n\n  1. a1\n'
+  //   The last one is why the obvious narrowings are all wrong. blockmap
+  //   reports those two items as (indent 0, listType 'ul') and (indent 0,
+  //   listType 'ol') — DIFFERENT runs AND different list types, so every fact
+  //   the model exposes says "two lists, safe", while the file says loose.
+  //   What decides it is the two-space prefix on a raw line, which no block
+  //   attribute carries and which the client cannot lex (render is a server
+  //   round trip; there is no lexer in the browser). The mirror over-refusal
+  //   is '- a' | para | '* b' -> '- a\n\n* b\n', measurably TWO tight
+  //   lists and still refused, because the discriminator there is the bullet
+  //   CHARACTER — another raw byte the model does not carry. Recorded in §4.5
+  //   as a deliberate over-refusal for 3.1.0, not as a correctness claim.
+  //
+  // `srcSeam` / `destSeam` are `{prev, next}`; each side is null when there is
+  // no such block or it is not a li, and otherwise `{runKey}` — the
+  // `data-block-id` of the FIRST member of listRunOf(), which is §3.4 rule 2's
+  // scope, so a nested child and its parent answer the SAME key. A null
+  // runKey (a run the DOM could not answer) counts as "same": an unknown seam
+  // refuses rather than guesses, because the guess that goes wrong corrupts a
+  // list and corrupting a list is not undoable.
+  //
+  // Returns 'source' | 'destination' | null. When both seams object the
+  // SOURCE one is reported: it is the objection that holds wherever the user
+  // aims next, so it is the one worth telling them about.
+  //
+  // Pure, and exported, because the enumeration it encodes is a table of
+  // measurements — a gesture-level test can only reach a handful of its rows.
+  function blockMoveSeamRefusal(srcSeam, destSeam) {
+    const s = srcSeam || {};
+    const d = destSeam || {};
+    if (s.prev && s.next) return 'source';
+    if (d.prev && d.next &&
+        (d.prev.runKey === null || d.next.runKey === null ||
+         d.prev.runKey === d.next.runKey)) return 'destination';
+    return null;
+  }
+
   // ── 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
@@ -222,7 +507,7 @@
   }
 
   if (typeof module === 'object' && module.exports) {
-    module.exports = { extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, rollbackFailedRender, headingDepthOf, withHeadingDepth };
+    module.exports = { extractBlockSource, commitEdit, commitRangeEdit, commitRangeRemoval, commitListBlockRemoval, commitBlockInsertion, planBlockMove, commitBlockMove, reorderSpanRange, spanMoveRange, spanIndentsAreAnchored, blockMoveSeamRefusal, rollbackFailedRender, headingDepthOf, withHeadingDepth };
     return; // node: pure core only
   }
 
@@ -233,6 +518,7 @@
   const listMd = window.md2docListMd;
   const indentClamp = window.md2docIndentClamp;
   const convertMd = window.md2docConvertMd;
+  const selectionLib = window.md2docSelection;
   const historyLib = window.md2docHistory;
   let lines = ED.lines, blocks = ED.blocks, mtimeMs = ED.mtimeMs;
   // 檔案原本的換行符。lines 內部永遠是不含 \r 的純內容行；只有 save()
@@ -440,8 +726,19 @@
   // extra button ahead of the always-present ✕ dismiss button (e.g. the
   // conflict banner's "Reload"); omit them for a plain dismiss-only notice.
   let activeBanner = null;
+  // Review recommendation 5 (2026-08-31): whether the banner on screen is a
+  // structural REFUSAL — 「無法整批操作」 and its siblings — as opposed to a
+  // conflict / render-failed / save-failed notice. Only a refusal is cleared
+  // by a later gesture that succeeds (see dismissRefusalBanner()); the other
+  // three describe the state of the FILE or the connection and must stay until
+  // the user dismisses them.
+  let activeBannerIsRefusal = false;
   function showBanner(message, actionLabel, onAction) {
     if (activeBanner) { activeBanner.remove(); activeBanner = null; }
+    // Reset unconditionally: refuseStructuralListEdit() sets it back to true
+    // straight after its own call, so every OTHER caller gets false without
+    // having to know this flag exists.
+    activeBannerIsRefusal = false;
     const el = document.createElement('div');
     el.className = 'ed-conflict';
     const msg = document.createElement('span');
@@ -460,7 +757,7 @@
     dismissBtn.setAttribute('aria-label', 'Dismiss');
     dismissBtn.addEventListener('click', () => {
       el.remove();
-      if (activeBanner === el) activeBanner = null;
+      if (activeBanner === el) { activeBanner = null; activeBannerIsRefusal = false; }
     });
     el.appendChild(dismissBtn);
     document.body.appendChild(el);
@@ -468,6 +765,24 @@
     return el;
   }
 
+  // Review recommendation 5: a refusal banner must not outlive the gesture that
+  // raised it. refuseStructuralListEdit() has been dismiss-only since S1, and
+  // S3 made it far more reachable (7 of the T8 sweep's 13 selection shapes
+  // refuse), so 「選取範圍同時含有清單項目與其他區塊，無法整批操作」 could stand
+  // over a document the user had since successfully edited — a plain lie about
+  // the state of the document. Called from rerenderAll()'s success path, which
+  // is the one point every structural operation reaches only by having WORKED:
+  // every failure exit above it returns before this. Deliberately NOT called
+  // from the Escape / clear-selection paths — dismissing a selection is not the
+  // same event as a later gesture succeeding, and the refusal is still the true
+  // answer to the gesture the user last attempted.
+  function dismissRefusalBanner() {
+    if (!activeBanner || !activeBannerIsRefusal) return;
+    activeBanner.remove();
+    activeBanner = null;
+    activeBannerIsRefusal = false;
+  }
+
   function showConflictBanner() {
     showBanner(
       'File changed on disk — reload to pick up external edits ' +
@@ -503,6 +818,14 @@
   // await is inside its own try/catch, so callers never see a rejection.
   async function rerenderAll() {
     const scrollY = window.scrollY;
+    // S3 Task 5 (§4.4 step 2): the line range this render's operation declared
+    // for the rebuilt selection. Consumed HERE, before the first failure exit,
+    // rather than down at the rebuild itself: every `return false` below
+    // leaves `blockSelection` untouched — which is what makes a line-range
+    // selection survive a failed render for free — and a declaration left
+    // standing would then land on some LATER, unrelated render instead.
+    const declaredRange = pendingSelectionRange;
+    pendingSelectionRange = undefined;
     let res;
     try {
       res = await fetch('/api/render', {
@@ -530,6 +853,10 @@
       showBanner('Render failed — malformed server response. Your edit was not applied.', null, null);
       return false;
     }
+    // Past every failure exit: this render is going to happen, so whatever
+    // gesture asked for it has succeeded. Review recommendation 5 — a stale
+    // structural refusal is cleared HERE and nowhere else.
+    dismissRefusalBanner();
     blocks = j.blocks;
     contentEl.innerHTML = j.bodyHtml;
     // Task 2 (Phase 3): re-arm every WYSIWYG-eligible paragraph/heading (and
@@ -593,6 +920,11 @@
     // ago was just destroyed by the innerHTML replacement above.
     hideTableEdgeMenu();
     cancelTeDrag();
+    // S4 Task 2: same belt-and-braces reasoning for an in-flight ⠿ block drag —
+    // the innerHTML replacement above just detached every block the gesture's
+    // ordinal refers to. Nothing was mutated by the drag, so there is nothing
+    // to revert; the state simply must not survive the render.
+    cancelBlockDrag();
     // Final-review Finding 5b (Important): same belt-and-braces reasoning
     // again for the ⠿ gutter menu — `toggleGutterMenu()` appends the ONE
     // shared `gutterMenu` node as a CHILD of whichever block it's open for
@@ -611,6 +943,17 @@
     // it's the same "singleton node appended as a child of whichever block
     // it's open for" idiom as gutterMenu just above.
     closeInsertMenu();
+    // S3 Task 5 (§4.4's ordered three steps): armEditables() above was step
+    // 1; this is steps 2 and 3 — rebuild the member set from the declared (or
+    // still-standing) LINE RANGE against the freshly built `blocks`, clear it
+    // if that range no longer resolves, and give the focus endpoint a real
+    // roving-tabindex holder. It sits AFTER the unconditional teardown above
+    // so nothing there can null what it just set, and BEFORE the two
+    // `try`-swallowed rebind blocks below so a diagram-init throw can never
+    // skip it. It is also deliberately ABOVE window.scrollTo(): the .focus()
+    // it ends in scrolls the holder into view, and the scroll restore below
+    // is what puts the reader back where they were.
+    rebuildBlockSelection(declaredRange);
     window.scrollTo(0, scrollY);
     if (window.__md2docInitDiagrams) {
       try {
@@ -1294,23 +1637,66 @@
   // 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;
+  //
+  // S3 Task 6: `opBlockEl` may also be an ARRAY — spec §3.4 rule 3's multi-block
+  // operation, which clampIndents() has accepted since S1 (`opIndex` may be an
+  // array of indices). `opOldIndent` is then the SMALLEST old indent in the set,
+  // never the first member's: §3.4 rule 3 records both ways the first member
+  // goes wrong (a delete drives a later member to indent −1; a batch Tab whose
+  // first member is already at its ceiling no-ops the whole set). The caller
+  // computes it with spanMinIndent(). A member that is not in `spanEls` aborts
+  // the whole clamp rather than clamping a subset — a partial op set makes rule
+  // 2's scope start in the wrong place, which is a silent wrong answer.
+  // S4 Task 7 split this in two WITHOUT changing what any existing caller does:
+  // computeIndentClamp() answers the clamp, applyIndentClamp() writes it, and
+  // the four callers that existed before this task still call the latter and
+  // still see exactly the answer they saw. The reason for the split is the ⠿
+  // DROP, and it is not a stylistic one: every other caller clamps a span it
+  // has already decided to commit, while the drop still has ONE refusal left
+  // after the clamp (see performListItemDrop()). Writing `data-indent` on a
+  // gesture that then refuses leaves a half-clamped DOM behind — the same
+  // "the screen and the model disagree" failure the clamp exists to prevent,
+  // produced by the clamp itself. So the drop asks first and writes only once
+  // it knows it is committing.
+  //
+  // `null` is "no answer at all": no clamp module, an empty span, or an
+  // operated element that is not IN the span. That last one abandons the whole
+  // clamp rather than clamping a subset — a partial op set makes rule 2's scope
+  // start in the wrong place, which is a silent wrong answer. Every caller
+  // treats `null` as "leave every indent alone", which is what the pre-split
+  // function did by returning early.
+  function computeIndentClamp(spanEls, opBlockEl, opOldIndent, opts) {
+    if (!indentClamp || !spanEls || !spanEls.length) return null;
+    const opEls = Array.isArray(opBlockEl) ? opBlockEl : [opBlockEl];
+    const opIndex = [];
+    for (let k = 0; k < opEls.length; k++) {
+      const at = spanEls.indexOf(opEls[k]);
+      if (at < 0) return null;
+      opIndex.push(at);
+    }
+    if (!opIndex.length) return null;
     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);
+    return indentClamp.clampIndents(model, opIndex, opOldIndent, opts || {})
+      .map((r) => ({ el: spanEls[r.blockId], indent: r.indent }))
+      .filter((r) => !!r.el);
+  }
+
+  function writeIndentClamp(answer) {
+    (answer || []).forEach((r) => {
+      if ((Number(r.el.getAttribute('data-indent')) || 0) !== r.indent) {
+        setBlockIndent(r.el, r.indent);
       }
     });
   }
 
+  function applyIndentClamp(spanEls, opBlockEl, opOldIndent, opts) {
+    writeIndentClamp(computeIndentClamp(spanEls, opBlockEl, opOldIndent, opts));
+  }
+
   function placeCaretAtEnd(el) {
     const range = document.createRange();
     range.selectNodeContents(el);
@@ -1596,35 +1982,175 @@
   // without a second selector.
   let convertSubmenu = null;
 
+  // ── v2.12.0 Task 4b, half 1: an icon at the head of every item ──────────
+  // User request: 「選單每個功能開頭給一個圖示，完全照抄 notion」. Notion's
+  // visual LANGUAGE, drawn here rather than their assets copied: 16x16 on a
+  // 0 0 16 16 viewBox, 1.5px stroke, fill:none, round caps and joins, and
+  // stroke="currentColor" so an icon is simply the colour of the row it sits
+  // in — retheme .ed-handle-menu and the icons follow for free, which a hex
+  // literal here would break silently.
+  //
+  // The menu is a SINGLETON built once at module scope and moved between
+  // blocks, so this markup is parsed exactly once for the life of the page.
+  // Nothing here may run per open.
+  const MENU_ICON_PATHS = {
+    // 轉換成 — a turn/redirect arrow: out to the right, then down. "this block
+    // becomes that one".
+    convert: '<path d="M2.5 4.5h6a3 3 0 0 1 3 3v4.6"/><path d="M9 9.6l2.5 2.5 2.5-2.5"/>',
+    // 建立副本 — two offset rounded cards, the standard duplicate glyph. The
+    // back card is an L-shaped outline rather than a second full rect so the
+    // two do not draw a line through each other.
+    duplicate: '<rect x="5.5" y="5.5" width="8" height="8" rx="2"/>' +
+      '<path d="M10.5 5.5V4.5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h1"/>',
+    // 刪除 — a trash can: lid, handle, tapered body, two ribs.
+    trash: '<path d="M2.5 4.5h11"/>' +
+      '<path d="M6.4 4.5V3.2a1.2 1.2 0 0 1 1.2-1.2h.8a1.2 1.2 0 0 1 1.2 1.2v1.3"/>' +
+      '<path d="M4.2 4.5l.6 8.1a1.4 1.4 0 0 0 1.4 1.3h3.6a1.4 1.4 0 0 0 1.4-1.3l.6-8.1"/>' +
+      '<path d="M6.6 7.2v4.2"/><path d="M9.4 7.2v4.2"/>',
+    // MD 原始碼 — angle brackets: source, not prose.
+    code: '<path d="M6 3.6L2 8l4 4.4"/><path d="M10 3.6L14 8l-4 4.4"/>',
+  };
+  function menuIconMarkup(name) {
+    return '<svg class="ed-menu-icon" viewBox="0 0 16 16" width="16" height="16" ' +
+      'aria-hidden="true" focusable="false" fill="none" stroke="currentColor" ' +
+      'stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">' +
+      MENU_ICON_PATHS[name] + '</svg>';
+  }
+
+  // ── v2.12.0 Task 4b, half 2: the submenu opens on HOVER ─────────────────
+  // User request: 「"轉換成" hover 沒有自動顯示子選單」.
+  //
+  // The naive "open on mouseenter, close on mouseleave" reproduces the gutter
+  // corridor defect v2.11.1 had just finished fixing, and MEASURED on this
+  // branch at 1400x900 it is worse than the plan predicted:
+  //
+  //   * `.ed-handle-submenu { left: 100%; margin-left: 4px }` over a menu with
+  //     4px of padding leaves x in [item.right + 4, sub.left) — exactly 4
+  //     device px on the item's own row — hit-testing to the BLOCK underneath.
+  //     A mouseleave-closes rule shuts the panel while the pointer is inside
+  //     that band, on its way in.
+  //   * The far worse one: the submenu is 342px tall against the menu's 118px,
+  //     so a straight line from 轉換成 to the panel's LAST row is 344px long
+  //     and leaves the item/panel pair for 334ms at 1200px/s, 367ms at 600,
+  //     535ms at 300 and 1068ms at 150 — first across 建立副本 / 刪除 /
+  //     MD 原始碼, then across bare page BELOW the menu. No close delay covers
+  //     that AND still shuts the panel promptly when the user really has
+  //     settled on 刪除; the plan's suggested 150-250ms covers neither end.
+  //
+  // So the rule is the classic menu-aim one, and it is a DIRECTION test rather
+  // than a distance or a timer: while the pointer is moving INTO the panel —
+  // inside the triangle whose apex is where it was one sample ago and whose
+  // base is the panel's near (left) edge, top to bottom — nothing closes the
+  // submenu, whatever it happens to be passing over on the way. Every other
+  // sample (a different parent item, bare page, off the menu entirely)
+  // SCHEDULES the close, and the grace period below is only what covers a
+  // single sample the triangle misses. Escape / outside click /
+  // closeGutterMenu() are unchanged and still immediate.
+  const SUBMENU_CLOSE_MS = 300;
+  let submenuCloseTimer = null;
+  let submenuAimPrev = null;
+  // Whether the standing panel was opened by the pointer rather than by a
+  // click — see the 轉換成 item's own handler for what it is for.
+  let convertSubmenuViaHover = false;
+
+  function cancelSubmenuClose() {
+    if (submenuCloseTimer !== null) { clearTimeout(submenuCloseTimer); submenuCloseTimer = null; }
+  }
+  function scheduleSubmenuClose() {
+    // Deliberately NOT restarted while one is already counting down: the
+    // countdown starts at the first sample that says "not on the way in", and
+    // any sample that says otherwise cancels it outright. Restarting per
+    // mousemove would make the close time depend on how much the user jiggles.
+    if (submenuCloseTimer !== null) return;
+    submenuCloseTimer = setTimeout(() => {
+      submenuCloseTimer = null;
+      closeConvertSubmenu();
+    }, SUBMENU_CLOSE_MS);
+  }
+  function pointInTriangle(px, py, ax, ay, bx, by, cx, cy) {
+    const cross = (x1, y1, x2, y2, x3, y3) => (x1 - x3) * (y2 - y3) - (x2 - x3) * (y1 - y3);
+    const d1 = cross(px, py, ax, ay, bx, by);
+    const d2 = cross(px, py, bx, by, cx, cy);
+    const d3 = cross(px, py, cx, cy, ax, ay);
+    return !(((d1 < 0) || (d2 < 0) || (d3 < 0)) && ((d1 > 0) || (d2 > 0) || (d3 > 0)));
+  }
+  function onSubmenuPointerMove(e) {
+    if (!convertSubmenu) return;
+    const prev = submenuAimPrev;
+    submenuAimPrev = { x: e.clientX, y: e.clientY };
+    const t = e.target;
+    const inSub = !!(t && t.closest && t.closest('.ed-handle-submenu'));
+    const btn = t && t.closest ? t.closest('.ed-handle-menu-btn') : null;
+    if (inSub || (btn && btn === gutterMenuConvert)) { cancelSubmenuClose(); return; }
+    if (prev) {
+      const r = convertSubmenu.getBoundingClientRect();
+      if (pointInTriangle(e.clientX, e.clientY, prev.x, prev.y, r.left, r.top, r.left, r.bottom)) {
+        cancelSubmenuClose();
+        return;
+      }
+    }
+    scheduleSubmenuClose();
+  }
+
   function buildGutterMenu() {
     const el = document.createElement('div');
     el.className = 'ed-handle-menu';
 
-    function item(label, aria, onClick) {
+    function item(label, aria, onClick, icon) {
       const b = document.createElement('button');
       b.type = 'button';
       b.className = 'ed-handle-menu-btn';
-      b.textContent = label;
+      // The icon first, then the label as a bare TEXT NODE. Never
+      // `b.textContent = label` after this (it would wipe the icon), and
+      // deliberately no wrapper element around the label: every menu helper in
+      // this repo and in test/editor-client-runtime.test.js finds an item by
+      // EXACT `b.textContent`, and an <svg> contributes none of its own, so the
+      // label reads back byte-identical with the icon in front of it.
+      b.innerHTML = menuIconMarkup(icon);
+      b.appendChild(document.createTextNode(label));
       b.setAttribute('aria-label', aria);
       b.addEventListener('click', onClick);
       el.appendChild(b);
       return b;
     }
 
+    // Hover-open. One delegated listener on the singleton menu, for the life of
+    // the page. The submenu is a CHILD of the menu so its own mouseovers bubble
+    // through here too, which is why this is an IDENTITY check against
+    // gutterMenuConvert rather than a label match.
+    el.addEventListener('mouseover', (e) => {
+      const btn = e.target && e.target.closest ? e.target.closest('.ed-handle-menu-btn') : null;
+      if (!gutterMenuConvert || btn !== gutterMenuConvert || gutterMenuConvert.hidden) return;
+      cancelSubmenuClose();
+      if (!convertSubmenu) openConvertSubmenu(gutterMenuConvert, true);
+    });
+
     // 轉換成 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();
-      if (convertSubmenu) { closeConvertSubmenu(); return; }
-      openConvertSubmenu(gutterMenuConvert);
-    });
+      if (convertSubmenu) {
+        // A click folds a CLICK-opened panel back up — the S2 toggle, which is
+        // the path clickGutterMenuItem() / convertVia() drive throughout the
+        // test suite and which must not regress. It must NOT fold up a panel
+        // the pointer's own hover just opened: the pointer is on the item, so
+        // no further mouseover would ever fire, and the panel would become
+        // unreachable by mouse — the exact opposite of what was asked for.
+        // The click does consume the hover flag, so a second one still folds.
+        if (!convertSubmenuViaHover) { closeConvertSubmenu(); return; }
+        convertSubmenuViaHover = false;
+        cancelSubmenuClose();
+        return;
+      }
+      openConvertSubmenu(gutterMenuConvert, false);
+    }, 'convert');
 
     gutterMenuDuplicate = item('建立副本', 'Duplicate this block', (e) => {
       e.stopPropagation();
       const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
       duplicateBlockViaMenu(blockEl);
-    });
+    }, 'duplicate');
 
     // §10-gap fix: block-level DELETE. Reuses commitListBlockRemoval()
     // unchanged (that function was already fully block-type-agnostic —
@@ -1638,14 +2164,14 @@
       const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
       deleteBlockViaGutter(blockEl);
-    });
+    }, 'trash');
 
     gutterMenuMd = item('MD 原始碼', 'Switch to raw markdown edit', (e) => {
       e.stopPropagation();
       const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
       openRawViaGutter(blockEl);
-    });
+    }, 'code');
 
     return el;
   }
@@ -1657,7 +2183,7 @@
   // `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) {
+  function openConvertSubmenu(anchorBtn, viaHover) {
     closeConvertSubmenu();
     const sub = document.createElement('div');
     sub.className = 'ed-handle-menu ed-handle-submenu';
@@ -1678,9 +2204,22 @@
     sub.style.top = anchorBtn.offsetTop + 'px';
     anchorBtn.parentNode.appendChild(sub);
     convertSubmenu = sub;
+    convertSubmenuViaHover = !!viaHover;
+    // The aim triangle needs a previous sample to have an apex; the first
+    // mousemove after the open only records one. Cleared here so a panel
+    // re-opened on another block cannot aim from the old block's geometry.
+    submenuAimPrev = null;
+    // Attached only while a panel is standing, and removed again below — a
+    // document-level mousemove listener that outlived the panel would be a
+    // per-move cost on every page for nothing.
+    document.addEventListener('mousemove', onSubmenuPointerMove);
   }
 
   function closeConvertSubmenu() {
+    cancelSubmenuClose();
+    submenuAimPrev = null;
+    convertSubmenuViaHover = false;
+    document.removeEventListener('mousemove', onSubmenuPointerMove);
     if (convertSubmenu) { convertSubmenu.remove(); convertSubmenu = null; }
   }
 
@@ -1696,6 +2235,46 @@
     gutterMenuBlockEl = null;
   }
 
+  // ── The one rule about 轉換成 and block type ────────────────────────────
+  // The block types 轉換成 is WITHHELD from, and the banner the BATCH path
+  // shows when a span holds one. ONE table, TWO call sites — toggleGutterMenu()
+  // just below hides the item on a single block's ⠿; convertBlockViaMenu()
+  // refuses a span that holds one — and that is the point of it being a shared
+  // predicate rather than a type test written out twice. MEASURED 2026-08-31,
+  // with the batch path gating only 'table': a selection over a paragraph, an
+  // hr and a paragraph, converted from a grip on a paragraph, wrote
+  // '# Doc\n\n- alpha\n- ---\n- bravo\n' with NO banner — '- ---' being the
+  // exact byte sequence the 'hr' reason below names as why the item is not
+  // offered. A type withheld in one place and silently allowed in the other IS
+  // the defect; deriving both from here is what makes a fourth type impossible
+  // to add to one affordance and forget in the other.
+  //
+  // Why these three:
+  //   'table' — §7: there is no target that could carry a table's cells, and
+  //     every one of the twelve would destroy them.
+  //   'hr' / 'html' — 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 nothing is said; 'hr' → 文字 is a byte no-op, also
+  //     silent. An 'html' block is raw passthrough for the same reason — no
+  //     marker to strip and nothing 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.
+  //
+  // Each type names ITSELF in the banner: a user whose selection holds an hr
+  // must not be told it holds a table. One template, three labels — the
+  // wording is per type, the RULE is not.
+  const BATCH_CONVERT_WITHHELD_MESSAGES = {
+    table: '選取範圍含有表格，無法整批轉換',
+    hr: '選取範圍含有分隔線，無法整批轉換',
+    html: '選取範圍含有 HTML 區塊，無法整批轉換',
+  };
+  function convertWithheldFor(blockType) {
+    return Object.prototype.hasOwnProperty.call(
+      BATCH_CONVERT_WITHHELD_MESSAGES, blockType);
+  }
+
   function toggleGutterMenu(blockEl) {
     if (!blockEl) return;
     if (gutterMenuBlockEl === blockEl) { closeGutterMenu(); return; }
@@ -1712,21 +2291,10 @@
     closeConvertSubmenu();
     gutterMenuBlockEl = blockEl;
     const blockType = blockEl.getAttribute('data-block-type');
-    // 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');
+    // Spec §7 / §3.7. Which types, and why, is stated ONCE just above — this
+    // is one of that predicate's two call sites, and convertBlockViaMenu()'s
+    // batch refusal is the other.
+    gutterMenuConvert.hidden = convertWithheldFor(blockType);
     gutterMenuDuplicate.hidden = false;
     gutterMenuDelete.hidden = false;
     // RULING F-O: 'MD 原始碼' is hidden for a list item PERMANENTLY, not as a
@@ -1738,7 +2306,28 @@
     // 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');
+    //
+    // §3.7's other sentence about this item — 「多選時不顯示 `MD 原始碼`」 —
+    // is the half S3 shipped without. openRawViaGutter() rewrites ONE block's
+    // source lines, so over a set of N it silently answers for the grip's
+    // block and ignores the rest: an item that appears to act on the selection
+    // and does not.
+    //
+    // The question is §3.3's MEMBERSHIP question, asked exactly the way every
+    // set operation asks it (resolveGutterOperands() → resolveMembership(),
+    // identifying the grip block by REFERENCE into `blocks` — Task 1 carry 4),
+    // and not "is anything selected". Two states answer differently and both
+    // keep the item: a set of exactly the grip block is a set of ONE, which
+    // raw-edits fine; and a set standing elsewhere in the document is not this
+    // grip's set at all — §3.3 turns that gesture into a single-block operation
+    // before it acts, so the item is right there too.
+    const mdRec = blockRecOf(blockEl);
+    const mdMembership = (selectionLib && mdRec)
+      ? selectionLib.resolveMembership(blockSelection, blocks, mdRec)
+      : { mode: 'single', members: mdRec ? [mdRec] : [] };
+    const mdMultiSelected =
+      mdMembership.mode === 'batch' && mdMembership.members.length > 1;
+    gutterMenuMd.hidden = (blockType === 'li') || mdMultiSelected;
     blockEl.appendChild(gutterMenu);
   }
 
@@ -2165,97 +2754,365 @@
   // 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;
+  // ── S3 Task 6: the ⠿ gesture's OPERAND SET (spec §3.3) ──────────────────
+  //
+  // Up to S2 every gutter operation worked on exactly one block and the three
+  // entry points below carried a byte-identical preamble: capture identity,
+  // resolve whatever session is open, re-find the block if that commit
+  // re-rendered, refuse a block that owns no source line. §3.3 turns that ONE
+  // element into a SPAN — 「grip 在選取集合內 → 作用整個集合；grip 在集合外 →
+  // 先把集合換成該單一 block 再作用」— so the preamble moved here and grew a
+  // membership step.
+  //
+  // ORDERING IS LOAD-BEARING. Membership is resolved AFTER switchAwayFrom(),
+  // never before: that call can commit an open burst, and its rerenderAll()
+  // renumbers every block id and hands back a fresh `blocks` array. A record
+  // captured ahead of it is a dangling reference — and resolveMembership()
+  // compares by REFERENCE (Task 1 carry 4: ids are forbidden architecturally
+  // and line tuples are genuinely ambiguous, since `- - - a` yields two
+  // structurally identical phantoms {startLine:1, endLine:0}), so a stale
+  // record silently answers 'single' and the batch degrades to one block. The
+  // selection itself survives that render for free — its identity is a LINE
+  // RANGE, which is exactly what no render can invalidate.
+  //
+  // Returns `null` when the gesture is refused or dropped — the banner has
+  // already been raised — otherwise `{ els, recs, batch }`: the LIVE block
+  // elements in document order, their records out of `blocks` (by reference),
+  // and whether more than one block is being operated on.
+  async function resolveGutterOperands(blockEl) {
+    if (!blockEl) return null;
+    // 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 the gesture
+    // names — 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 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;
+    if (!ok) return null;
     let liveBlockEl = blockEl;
     if (!document.body.contains(blockEl)) {
       liveBlockEl = reresolveBlockEl(identity) ||
         (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
-      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null; }
+    }
+    // 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 null; }
+    const rec = blockRecOf(liveBlockEl);
+    if (!rec) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null; }
+
+    const res = selectionLib
+      ? selectionLib.resolveMembership(blockSelection, blocks, rec)
+      : { mode: 'single', members: [rec] };
+    if (res.mode !== 'batch') {
+      // §3.3's second half: 「grip 在集合外 → 先把集合換成該單一 block 再作用」.
+      // Done here rather than left to the post-operation collapse so a REFUSAL
+      // also leaves the documented state behind, instead of a set somewhere
+      // else in the document that the user's next keystroke would batch over.
+      // No selection standing at all stays exactly as it was pre-S3.
+      if (blockSelection) {
+        setBlockSelection({ anchorLine: rec.startLine, focusLine: rec.startLine });
+      }
+      return { els: [liveBlockEl], recs: [rec], batch: false };
+    }
+    const members = res.members;
+    // Task 1 carry 6: `spanIsContiguous([])` is TRUE — no members, no gaps — so
+    // emptiness is checked separately and gets its own wording. Unreachable
+    // through the menu today (resolveMembership() only answers 'batch' when the
+    // grip block is itself a member), but the two states are genuinely
+    // different and a single gate would report the wrong one if it ever is.
+    if (!members.length) { refuseStructuralListEdit(BATCH_EMPTY_MESSAGE); return null; }
+    // Task 1 carry 2: a gap is NOT only what a disjoint selection produces. A
+    // no-line phantom can sit BETWEEN two real members — `- a\n- - b\n- c\n`
+    // yields li{1,1} | phantom{2,1} | li{2,2} | li{3,3}, so selecting lines 1–2
+    // (an entirely natural gesture) lands on indices 0 and 2. The batch cannot
+    // be expressed as one contiguous index range, so it refuses rather than
+    // writing a range it cannot honour.
+    if (!selectionLib.spanIsContiguous(members, blocks)) {
+      refuseStructuralListEdit(BATCH_GAP_MESSAGE);
+      return null;
+    }
+    const els = [];
+    for (let i = 0; i < members.length; i++) {
+      const el = blockElById(members[i].id);
+      if (!el) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null; }
+      // Belt to membersOf()'s own braces: selection.js excludes a block that
+      // owns no line from every member set it builds, so this is unreachable —
+      // but "another module filters it" is an argument about another file's
+      // output, and this is the guard that stands between an inverted range and
+      // a commit helper.
+      if (blockOwnsNoLine(el)) { refuseStructuralListEdit(NO_SOURCE_LINE_MESSAGE); return null; }
+      els.push(el);
+    }
+    return { els: els, recs: members, batch: members.length > 1 };
+  }
+
+  // §3.3's collapse: 「操作後集合塌縮為「操作結果所涵蓋的行區間」」. Declared
+  // IMMEDIATELY before the render and never earlier — rerenderAll() consumes the
+  // declaration at its very top, before its first failure exit, so one left
+  // standing lands on some LATER, unrelated render (Task 5 carry 5).
+  //
+  // ONLY when a set was actually standing, and that guard is load-bearing:
+  // without it an ordinary single-block ⠿ 建立副本 or 轉換成 on a document with
+  // NO selection would CREATE one — collapseTo() resolves the declared range,
+  // membersOf() finds the block, and setBlockSelection() tints it and pulls the
+  // roving focus onto it. That is a selection the user never made, and it would
+  // change the resting state of every pre-S3 gutter gesture. resolveGutterOperands()
+  // has already applied §3.3's 「grip 在集合外 → 先把集合換成該單一 block」, so
+  // `blockSelection` is non-null here exactly when the gesture was a set
+  // operation. Leaving the declaration UNSET is the correct answer otherwise:
+  // `undefined` means "keep whatever is standing", and nothing is.
+  function declareCollapse(range) {
+    if (blockSelection) declareSelectionRange(range);
+  }
+
+  const BATCH_EMPTY_MESSAGE = '沒有選取任何區塊';
+  const BATCH_GAP_MESSAGE = '選取範圍不連續，無法整批操作';
+  const BATCH_MIXED_MESSAGE = '選取範圍同時含有清單項目與其他區塊，無法整批操作';
+  const BATCH_MULTIRUN_MESSAGE = '選取範圍跨越兩個清單，無法整批操作';
+  // S4 Task 5: the ⠿ drag's cross-boundary refusals, one per CAUSE.
+  //
+  // Task 3 raised all of these with a single provisional constant
+  // (BLOCK_MOVE_LIST_SEAM_MESSAGE, '區塊搬移不能跨越清單邊界') and said THIS task
+  // owned the final wording. They are three different problems with three
+  // OPPOSITE remedies, so one sentence for all of them sends two thirds of
+  // the users to fix the wrong end of their own gesture:
+  //   * the SOURCE seam — the block cannot leave where it is, because the two
+  //     lists it stands between would join into one loose run. No destination
+  //     helps; the remedy is not to move it (or to move something else).
+  //   * the DESTINATION seam — the block cannot go INSIDE a list. The remedy
+  //     is to aim somewhere else, which is the exact opposite advice.
+  //   * OUT OF RUN — a list item may only move among its own §3.8 siblings.
+  //     The remedy is to stay inside its own list.
+  // Naming follows the BATCH_*_MESSAGE convention above. None of the three is
+  // a substring of another, of §4.3's own gate message, or of
+  // BLOCK_MOVE_ORPHAN_MESSAGE below — which is what lets a test assert WHICH
+  // refusal fired rather than that some banner mentioning 清單 appeared.
+  const BLOCK_MOVE_SOURCE_SEAM_MESSAGE = '移走這個區塊會讓上下兩串清單接在一起，無法搬移';
+  const BLOCK_MOVE_DEST_SEAM_MESSAGE = '無法把區塊放進清單項目之間';
+  const BLOCK_MOVE_OUT_OF_RUN_MESSAGE = '清單項目只能在所屬清單內搬移';
+  // S4 Task 7: what is LEFT of Task 4's indent refusal, and it is 14 drops out
+  // of 4067. §4.5's clamp is now performed (performListItemDrop() runs the
+  // removal half of the move through clampIndents()'s `{ removed: true }`),
+  // which answers every SOURCE-side orphan. What no removal-clamp can reach is
+  // the INSERTION half: a BATCH whose last member is SHALLOWER than the block
+  // it lands before leaves that block with no parent chain above it, at the
+  // NEW index, and §3.4 has no rule for that seam. MEASURED over every legal
+  // indent array of length 2..6 and depth 0..3, every operand-set size and
+  // every destination the run gate admits: 4067 drops, 1425 refused by Task
+  // 4's predicate, 14 still unanchored after the clamp — every one of them a
+  // multi-block set breaking at the block immediately after the landed set.
+  // (test/editor-client.test.js re-runs that sweep and pins all three numbers.)
+  //
+  // RE-WORDED with the narrowing, and the wording is the point: Task 4's
+  // 「搬移後子項目會失去上層項目，暫時無法搬移到這裡」 said "temporarily", which
+  // was true while the capability was missing and is a lie now that it is not.
+  // What is left is a DESTINATION objection with the same remedy
+  // BLOCK_MOVE_DEST_SEAM_MESSAGE has — aim somewhere else — so it says which
+  // end of the gesture is at fault. Still not a substring of any other refusal
+  // in this file, which is what lets a test assert WHICH one fired.
+  const BLOCK_MOVE_ORPHAN_MESSAGE = '落點的子項目會失去上層項目，無法搬移到這裡';
+  // 轉換成's own refusals are NOT declared here. They are per block TYPE, and
+  // they are the same ruling §3.7 applies to a single block's ⠿ — so they live
+  // with that predicate, in BATCH_CONVERT_WITHHELD_MESSAGES above
+  // toggleGutterMenu(), where the menu-hiding call site can share them. The
+  // four constants above are shape-level and belong to every batch operation.
+
+  function blockElById(id) {
+    return document.querySelector('.ed-block[data-block-id="' + id + '"]');
+  }
+
+  // §3.4 rule 3's batch anchor: 「多 block 操作的錨點 = 選取集合中最小的舊
+  // indent」, not the first member. Deleting `{a(0), b(1)}` anchored on a(0) is
+  // right, but anchored on the FIRST member of `{b(1), …}` the following
+  // segment head's bound is computed against 1 instead of 0 and a same-segment
+  // sibling lands at −1 (undefined in columns).
+  //
+  // ⚠ This value is the anchor for the blocks BELOW the operated set — the
+  // bound applyIndentClamp() re-measures them against — and NOTHING else.
+  // §3.4 rule 3 also cites a batch TAB whose first member is at its ceiling as
+  // a failure of first-member anchoring, but that half was superseded by the
+  // 2026-08-31 D1 review: how far the set itself may move is batchIndentDelta()
+  // and is the minimum head-room across ALL members, so a set holding a member
+  // at its ceiling is a whole-batch no-op regardless of what its shallowest
+  // member could have done alone. Do not re-derive Tab's delta from here.
+  function spanMinIndent(els) {
+    let min = null;
+    (els || []).forEach((el) => {
+      const v = Number(el.getAttribute('data-indent')) || 0;
+      if (min === null || v < min) min = v;
+    });
+    return min === null ? 0 : min;
+  }
+
+  // The kinds a span holds, and the one shape no batch path can express.
+  // A contiguous span of list items is rewritten through its RUN's
+  // re-serialization; a contiguous span of non-list blocks is a plain line
+  // splice. A span holding BOTH is neither: the run's survivors have to be
+  // re-emitted at the same time as a line range outside the run is removed, and
+  // the blank-line policy at the seam between them has no ruling in the spec.
+  // Refused with its own banner rather than guessed at.
+  function spanListKinds(els) {
+    const kinds = els.map((el) => el.getAttribute('data-block-type'));
+    return {
+      kinds: kinds,
+      allLi: kinds.length > 0 && kinds.every((k) => k === 'li'),
+      anyLi: kinds.indexOf('li') !== -1,
+    };
+  }
+
+  // Every list batch is one run's problem: listRunOf() is the span the commit
+  // re-serializes, and a member outside it would be rewritten by a range that
+  // does not cover it. Contiguity in `blocks` does not imply one run — two
+  // adjacent runs separated by a delimiter change (`- a` / `* b`) are adjacent
+  // blocks with no phantom between them.
+  function batchRunOf(liEls) {
+    const run = listRunOf(liEls[0]);
+    if (!run.length) return null;
+    for (let i = 0; i < liEls.length; i++) if (run.indexOf(liEls[i]) === -1) return null;
+    return run;
+  }
+
+  async function convertBlockViaMenu(blockEl, target) {
+    if (!blockEl || !target) return;
+    // §3.3's membership rules and the whole shared preamble — see
+    // resolveGutterOperands() above. `els` is ONE contiguous span; the plan's
+    // central constraint is that every path below takes that span whole rather
+    // than looping, because a loop re-renders between items and invalidates
+    // every id in between (the defect class recorded in this file twice: a
+    // fenced block raw-edited into two paragraphs changes the BLOCK count
+    // without changing the LINE count, so an id-indexed delete hit the wrong
+    // block, and the same shape silently rewrote a neighbouring table).
+    const operands = await resolveGutterOperands(blockEl);
+    if (!operands) return;
+    const els = operands.els;
+    const recs = operands.recs;
+    const shape = spanListKinds(els);
+    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+    // §3.7 / §7 withhold 轉換成 from some block types ENTIRELY —
+    // toggleGutterMenu() hides the item outright, and the list plus every
+    // reason is in BATCH_CONVERT_WITHHELD_MESSAGES above it. This is the SAME
+    // predicate, asked of a SET: none of those reasons stops applying because
+    // the block happens to be one member of a span, and a batch whose grip is a
+    // paragraph reaches the withheld member anyway. MEASURED, before this gate
+    // existed: a table span wrote '> | A | B |' … / '- | A | B |' with its other
+    // rows as continuations, an hr span wrote '- ---', an html span wrote
+    // '> <div>x</div>'. Nothing is LOST in any of them (they all still lex as
+    // what they were) — which is exactly why it is so quiet: the single-block ⠿
+    // and the batch ⠿ give OPPOSITE answers to the same question with nothing
+    // on screen saying so, the shape §3.6's 2026-08-31 「不得另寫一條」 ruling
+    // exists to prevent. ⇒ REFUSE, with a banner (§3.6: 靜默不動作是缺陷), file
+    // byte-identical.
+    //
+    // The banner names the type that is ACTUALLY in the span, not one of the
+    // four shape-level messages above: BATCH_MIXED names list items vs other
+    // blocks (a paragraph+table span holds no list item at all) and BATCH_GAP
+    // names non-contiguity — either would name something the user's selection
+    // has not done. So would telling a user with an hr in the selection that it
+    // contains a table.
+    //
+    // SCOPED TO 轉換成. 建立副本 / 刪除 / the Delete key / Tab over a span
+    // holding any of these types are measured correct and have no equivalent
+    // objection — they do not need a target that can carry cells, or a marker
+    // to strip — so the predicate deliberately does NOT reach
+    // resolveGutterOperands(), and the T8 sweep's three withheld-type rows keep
+    // those five cells as APPLYING so a widening shows up as a failure too.
+    // Placed BELOW the mixed gate so no span that already refuses changes which
+    // banner it gets.
+    const withheld = shape.kinds.filter(convertWithheldFor)[0];
+    if (withheld) {
+      refuseStructuralListEdit(BATCH_CONVERT_WITHHELD_MESSAGES[withheld]);
+      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.
+    // descendant of its members) — see deleteListItemsViaGutter()'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
+    // 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 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.
+    // 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. S3 Task 6 passes the WHOLE operand
+    // set as the target list — every member is being rewritten, so every member
+    // has to clear the gate, not just the one the ⠿ was pressed on.
     let liRun = null;
-    if (kind === 'li') {
-      liRun = listRunOf(liveBlockEl);
-      if (!liRun.length) return;
-      if (!listRunSupportsStructuralEdit(liRun, liveBlockEl)) { refuseStructuralListEdit(); return; }
+    if (shape.allLi) {
+      liRun = batchRunOf(els);
+      if (!liRun) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); return; }
+      if (!listRunSupportsStructuralEdit(liRun, els)) { 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);
+    // S2 Task 3 / S3 Task 6: li → a LIST target. The blocks stay list items, so
+    // the run stays a run and the existing re-serialization machinery applies
+    // unchanged.
+    if (shape.allLi && convertMd.targetIsList(target)) {
+      await convertListItemsType(els, liRun, recs, 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);
+    // S2 Task 4 / S3 Task 6: li → a NON-list target. The items LEAVE 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
+    // lines mid-list with no separator and lazy continuation would swallow them
+    // into the item above (measured, §4.3 rule 1).
+    if (shape.allLi) {
+      await convertListItemsAway(els, liRun, recs, 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.
+    // S2 Task 5 / S3 Task 6: non-list blocks BECOME list items, 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);
+      await convertBlocksIntoList(els, recs, shape.kinds, 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, {});
+    // The plain path: N non-list blocks to a non-list target. One commit over
+    // the span's whole line range, each member converted from its OWN source
+    // lines (never re-serialized, which is what keeps a `~5px` a `~5px`) and
+    // the pieces separated by a blank line so they re-lex as N blocks.
+    const first = recs[0];
+    const last = recs[recs.length - 1];
+    const pieces = [];
+    for (let i = 0; i < recs.length; i++) {
+      const src = lines.slice(recs[i].startLine - 1, recs[i].endLine);
+      const stripped = convertMd.stripMarker(src, shape.kinds[i]);
+      if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+      pieces.push(convertMd.emitAs(stripped.content, target, {}).join('\n'));
+    }
+    const md = pieces.join('\n\n');
 
     const result = commitRangeEdit({ lines, blocks, stack },
-      rec.startLine, rec.endLine, newLines.join('\n'));
+      first.startLine, last.endLine, md);
     // 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.
+    // onto the undo stack either, so there is nothing to render or roll back,
+    // and no selection range to declare.
     if (result.op === null) return;
     const prevLines = lines;
     lines = result.lines;
+    // §3.3: 「操作後集合塌縮為操作結果所涵蓋的行區間」. Declared IMMEDIATELY
+    // before the render, never earlier (Task 5 carry 5): rerenderAll() consumes
+    // the declaration at its very top, so one left standing lands on some
+    // later, unrelated render.
+    declareCollapse({
+      startLine: first.startLine,
+      endLine: first.startLine + md.split('\n').length - 1,
+    });
     const okRender = await safeRerenderAll();
     if (!okRender) {
       lines = rollbackFailedRender({ lines, stack }, result, prevLines);
@@ -2310,7 +3167,7 @@
   //    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
+  //    re-serialization (duplicateListItems() 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
@@ -2318,43 +3175,39 @@
   // 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);
+    // §3.3's membership rules plus the shared preamble — see
+    // resolveGutterOperands(). The whole span is duplicated by ONE commit; a
+    // per-member loop would re-render between items and invalidate every id in
+    // between.
+    const operands = await resolveGutterOperands(blockEl);
+    if (!operands) return;
+    const els = operands.els;
+    const recs = operands.recs;
+    const shape = spanListKinds(els);
+    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+
+    if (shape.allLi) {
+      await duplicateListItems(els, recs);
       return;
     }
 
-    const result = commitBlockInsertion({ lines, blocks, stack }, liveBlockId,
-      lines.slice(rec.startLine - 1, rec.endLine));
+    // The non-li span duplicates as ONE slice of `lines` — separators between
+    // its members included, which is what makes the copies re-lex as the same N
+    // blocks rather than one merged one. commitBlockInsertion() anchors on the
+    // LAST member (it inserts BELOW its anchor), and its own leading blank is
+    // the separator between the original span and the copy.
+    const first = recs[0];
+    const last = recs[recs.length - 1];
+    const result = commitBlockInsertion({ lines, blocks, stack }, last.id,
+      lines.slice(first.startLine - 1, last.endLine));
     if (result.op === null) return;
     const prevLines = lines;
     lines = result.lines;
+    // §3.3's collapse. A duplicate inserts BELOW everything it copied, so the
+    // originals keep the exact line range they had — declaring it is the same
+    // answer as "keep what is standing" and says so explicitly, which is what
+    // keeps this correct if the insertion point ever moves.
+    declareCollapse({ startLine: first.startLine, endLine: last.endLine });
     if (!(await safeRerenderAll())) {
       lines = rollbackFailedRender({ lines, stack }, result, prevLines);
     }
@@ -2366,16 +3219,18 @@
   // §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;
+  async function duplicateListItems(liEls, recs) {
+    // Every list batch is one run's problem — see batchRunOf().
+    const run = batchRunOf(liEls);
+    if (!run) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); 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; }
+    // TARGET while remaining a perfectly good bystander — and in a batch EVERY
+    // member is a target.
+    if (!listRunSupportsStructuralEdit(run, liEls)) { 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
@@ -2388,22 +3243,29 @@
     // 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;
+    // For a BATCH the anchor is the LAST member's subtree, which is the direct
+    // generalization: the copies land after everything the set owns, in the
+    // set's own document order.
+    const anchorLi = liEls[liEls.length - 1];
+    const subtree = subtreeBlocksAfter(anchorLi, Number(anchorLi.getAttribute('data-indent')) || 0);
+    const lastEl = subtree.length ? subtree[subtree.length - 1] : anchorLi;
     const at = run.indexOf(lastEl);
     if (at < 0) return;
 
-    const copy = liEl.cloneNode(true);
+    const copies = liEls.map((liEl) => 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));
+    copies.forEach((copy) => copy.removeAttribute('data-list-start'));
+    const span = run.slice(0, at + 1).concat(copies, run.slice(at + 1));
     mutateListRun(() => {
-      lastEl.parentNode.insertBefore(copy, lastEl.nextSibling);
+      // One fixed reference node, so the copies land in their own order:
+      // insertBefore(c1, ref) then insertBefore(c2, ref) gives lastEl, c1, c2.
+      const ref = lastEl.nextSibling;
+      copies.forEach((copy) => { lastEl.parentNode.insertBefore(copy, ref); });
     });
     // 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
@@ -2422,6 +3284,15 @@
     // 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 型態 / 縮排 / 勾選狀態.
+    // §3.3's collapse, declared immediately before the render inside
+    // commitListStructure(). The copies land AFTER everything the set owns and
+    // no member's line COUNT can change (a multi-line target is refused above,
+    // and §3.8's renumbering only ever changes marker WIDTH), so the originals
+    // still occupy exactly the range they occupied before the commit.
+    declareCollapse({
+      startLine: recs[0].startLine,
+      endLine: recs[recs.length - 1].endLine,
+    });
     await commitListStructure(span, null, false,
       { presetRange: range, carryOver: bystanderCarryOver(span) });
   }
@@ -2430,64 +3301,45 @@
   // emptied-out list). Same resolve-first / re-query-live-block-by-id
   // precondition as insertBlockBelow() above.
   async function deleteBlockViaGutter(blockEl) {
-    if (!blockEl) return;
-    // 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 = 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; }
+    // §3.3's membership rules plus the shared preamble (identity capture,
+    // switchAwayFrom(), the re-resolve after a commit that re-rendered, and the
+    // no-source-line refusal) — see resolveGutterOperands(). The stake on the
+    // re-resolve is highest here: 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 operands = await resolveGutterOperands(blockEl);
+    if (!operands) return;
+    const els = operands.els;
+    const recs = operands.recs;
+    const shape = spanListKinds(els);
+    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_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);
+    // deleteListItemsViaGutter() for the measurements and the routing.
+    if (shape.allLi) {
+      await deleteListItemsViaGutter(els);
       return;
     }
-    const result = commitListBlockRemoval({ lines, blocks, stack }, liveBlockId);
+    // A contiguous span of non-list blocks is one line range: the separators
+    // between its members are inside it by construction (members are adjacent
+    // in `blocks`, so nothing else lives between them), and commitRangeRemoval()
+    // absorbs exactly one adjacent blank on the outside — the same blank-line
+    // contract commitListBlockRemoval() documents, which is literally this call
+    // for a single block. The one-block case keeps going through that wrapper so
+    // the shipped single-block path is byte-for-byte the S2 one.
+    const first = recs[0];
+    const last = recs[recs.length - 1];
+    const result = els.length === 1
+      ? commitListBlockRemoval({ lines, blocks, stack }, first.id)
+      : commitRangeRemoval({ lines, blocks, stack }, first.startLine, last.endLine);
     const prevLines = lines;
     lines = result.lines;
+    // §3.3's collapse: a delete's result covers NO lines, so the set is cleared
+    // rather than collapsed (Task 1 carry 5 — collapseTo() answers null for an
+    // inverted range, and §4.4 says a range that no longer resolves clears).
+    // Declared immediately before the render, never earlier (Task 5 carry 5).
+    declareCollapse(null);
     const okRender = await safeRerenderAll();
     if (!okRender) {
       lines = rollbackFailedRender({ lines, stack }, result, prevLines);
@@ -2522,31 +3374,44 @@
   // 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;
+  async function deleteListItemsViaGutter(liEls) {
+    // Every list batch is one run's problem — see batchRunOf().
+    const run = batchRunOf(liEls);
+    if (!run) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); 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; }
+    // target refuses per §4.1 — and in a batch every member is a target.
+    if (!listRunSupportsStructuralEdit(run, liEls)) { 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);
+    // §3.4 rule 3's batch anchor: the SMALLEST old indent in the set, never the
+    // first member's — see spanMinIndent().
+    const oldIndent = spanMinIndent(liEls);
+    const survivors = run.filter((el) => liEls.indexOf(el) === -1);
     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);
+      // Clamp FIRST, while every member is still in the span: `{ removed: true }`
+      // is what tells the pure function that these blocks can no longer anchor
+      // anything, and rule 2's scope is measured from the LAST of their
+      // positions. ONE call for the whole set, not one per member: clampIndents()
+      // takes an array of operated indices precisely so a batch computes one
+      // segment delta per §3.4 rule 3 instead of N independent clamps, which is
+      // what splits the user's siblings apart.
+      applyIndentClamp(run, liEls, oldIndent, { removed: true });
+      liEls.forEach((el) => removeListItem(el));
     });
     // 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.
+    //
+    // §3.3's collapse: a delete's result covers no lines, so the set is cleared.
+    // Declared immediately before commitListStructure(), whose only render on
+    // this path is the one it makes after the commit — the `!range` bail above
+    // it cannot fire, `presetRange` is non-null by construction here.
+    declareCollapse(null);
     await commitListStructure(survivors, null, false,
       { presetRange: range, carryOver: bystanderCarryOver(survivors) });
   }
@@ -2604,7 +3469,7 @@
   //    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.
+  //    §4.3 rule 1's edge blanks in convertListItemsAway() 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
@@ -2684,18 +3549,18 @@
     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) {
+  // The {listType, indent} a span member will carry once the operand set
+  // `liEls` has become `attrs`. Everything outside the set keeps what it has.
+  function postConvertLiAttrs(el, liEls, attrs) {
     return {
-      listType: el === liEl
+      listType: liEls.indexOf(el) !== -1
         ? attrs.listType
         : (el.getAttribute('data-list-type') === 'ol' ? 'ol' : 'ul'),
       indent: Number(el.getAttribute('data-indent')) || 0,
     };
   }
 
-  async function convertListItemType(liEl, run, target) {
+  async function convertListItemsType(liEls, run, recs, target) {
     const range = runRangeOfBlocks({ lines, blocks, stack }, run);
     if (!range) return;
     const attrs = convertMd.listAttrsFor(target);
@@ -2719,22 +3584,30 @@
       if ((Number(el.getAttribute('data-indent')) || 0) === headIndent) tailEl = el;
     });
     const merged = widenRangeForListMerge(range, run,
-      postConvertLiAttrs(headEl, liEl, attrs), postConvertLiAttrs(tailEl, liEl, attrs));
+      postConvertLiAttrs(headEl, liEls, attrs), postConvertLiAttrs(tailEl, liEls, attrs));
     if (!merged.ok) { refuseStructuralListEdit(); return; }
+    // How far the run's own first line MOVES. widenRangeForListMerge() only ever
+    // widens the range BACKWARDS over blank separators (§4.3 rule 2's tight
+    // merge), and the markdown written over the widened range is the run's own
+    // serialization with no leading blank — so every line of the run shifts up
+    // by exactly this much, and the collapse range below has to shift with it.
+    const shift = merged.startLine - range.startLine;
     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();
-      }
+      liEls.forEach((liEl) => {
+        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)
@@ -2750,6 +3623,15 @@
     // 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.
+    //
+    // §3.3's collapse: the operand set stays exactly where it is — the members
+    // are still list items in the same run and only their MARKERS are re-stated,
+    // so no line count inside the run can change. Only the merge widening moves
+    // them, by `shift`.
+    declareCollapse({
+      startLine: recs[0].startLine + shift,
+      endLine: recs[recs.length - 1].endLine + shift,
+    });
     await commitListStructure(run, null, false,
       { presetRange: range, carryOver: bystanderCarryOver(run) });
   }
@@ -2788,17 +3670,39 @@
   // 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) {
+  async function convertListItemsAway(liEls, run, recs, 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);
+    // Each member's own bytes, read from `lines` and never re-serialized — that
+    // is what keeps a `~5px` a `~5px`. Joined by a blank line so N converted
+    // items re-lex as N blocks and not one lazy continuation of the first.
+    const convertedPieces = [];
+    for (let i = 0; i < liEls.length; i++) {
+      const rec = recs[i];
+      const stripped = convertMd.stripMarker(lines.slice(rec.startLine - 1, rec.endLine), 'li');
+      if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+      convertedPieces.push(convertMd.emitAs(stripped.content, target, {}).join('\n'));
+    }
+    const convertedMd = convertedPieces.join('\n\n');
+
+    // §3.4 rule 3's batch anchor — the SMALLEST old indent in the set.
+    const oldIndent = spanMinIndent(liEls);
+    // ONE contiguous index range, never a loop over `run.indexOf(member)`
+    // per item: the run is split ONCE into the survivors before the set and the
+    // survivors after it. The operand set is contiguous in `blocks` (checked by
+    // spanIsContiguous() before any of this) and the run is a contiguous slice
+    // of the same list, so the two indices below bracket exactly `liEls.length`
+    // members — asserted rather than assumed, because this arithmetic is what
+    // writes the bytes and an off-by-one here silently re-serializes a
+    // bystander into the converted half.
+    const idx = run.indexOf(liEls[0]);
+    const lastIdx = run.indexOf(liEls[liEls.length - 1]);
+    if (idx < 0 || lastIdx < idx || lastIdx - idx + 1 !== liEls.length) {
+      refuseStructuralListEdit(BATCH_GAP_MESSAGE);
+      return;
+    }
     const before = run.slice(0, idx);
-    const after = run.slice(idx + 1);
+    const after = run.slice(lastIdx + 1);
 
     // §3.4, and the FIRST production caller of the pure clamp's
     // `operatedBecomes` branch (RULING T6-B). `liEl` stays in the span — the
@@ -2824,17 +3728,21 @@
     // 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) } });
+      applyIndentClamp(run, liEls, 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.
+    // back through escapeText() — see convertListItemsType()'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'));
+    // Which piece the converted blocks are — the collapse range below counts
+    // emitted LINES up to it, and "0 or 1" is only true while `before` is the
+    // one optional piece ahead of it.
+    const convertedPieceIdx = pieces.length;
+    pieces.push(convertedMd);
     if (after.length) pieces.push(listMd.serializeBlocks(after, { carryOver: carry }).md);
     let md = pieces.join('\n\n');
 
@@ -2845,15 +3753,27 @@
     // 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.
+    let lead = 0;
     if (!before.length && range.startLine > 1 &&
-        String(lines[range.startLine - 2]).trim() !== '') md = '\n' + md;
+        String(lines[range.startLine - 2]).trim() !== '') { md = '\n' + md; lead = 1; }
     if (!after.length && range.endLine < lines.length &&
         String(lines[range.endLine]).trim() !== '') md = md + '\n';
 
+    // §3.3's collapse: 「操作後集合塌縮為操作結果所涵蓋的行區間」— the CONVERTED
+    // blocks' own lines, not the whole commit range (which is the entire run,
+    // bystanders included). Counted in emitted lines: every '\n\n' join
+    // between two pieces adds one blank line on top of the piece's own lines,
+    // and `lead` is the one §4.3 rule 1 puts at the very front.
+    let offset = lead;
+    for (let k = 0; k < convertedPieceIdx; k++) offset += pieces[k].split('\n').length + 1;
+    const outStart = range.startLine + offset;
+    const outEnd = outStart + convertedMd.split('\n').length - 1;
+
     const result = commitRangeEdit({ lines, blocks, stack }, range.startLine, range.endLine, md);
     if (result.op === null) return;
     const prevLines = lines;
     lines = result.lines;
+    declareCollapse({ startLine: outStart, endLine: outEnd });
     if (!(await safeRerenderAll())) {
       lines = rollbackFailedRender({ lines, stack }, result, prevLines);
     }
@@ -2873,26 +3793,44 @@
   // 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) {
+  async function convertBlocksIntoList(blockEls, recs, kinds, 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, {});
+    // One item per member, joined by a bare newline: the members' own
+    // separators are INSIDE the commit range and are replaced, which is what
+    // makes N paragraphs one TIGHT list. A blank between them would make the
+    // list loose and degrade every item read-only (§4.3 rule 2).
+    const pieces = [];
+    for (let i = 0; i < recs.length; i++) {
+      const stripped = convertMd.stripMarker(
+        lines.slice(recs[i].startLine - 1, recs[i].endLine), kinds[i]);
+      if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+      pieces.push(convertMd.emitAs(stripped.content, target, {}).join('\n'));
+    }
+    const md = pieces.join('\n');
+    const first = recs[0];
+    const last = recs[recs.length - 1];
 
     // 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.
+    // span's post-conversion identity is (target list type, indent 0) on both
+    // edges — it emits one item per member, however many physical lines each
+    // item spans.
     const self = { listType: attrs.listType, indent: 0 };
     const merged = widenRangeForListMerge(
-      { startLine: rec.startLine, endLine: rec.endLine }, [blockEl], self, self);
+      { startLine: first.startLine, endLine: last.endLine }, blockEls, self, self);
     if (!merged.ok) { refuseStructuralListEdit(); return; }
 
     const result = commitRangeEdit({ lines, blocks, stack },
-      merged.startLine, merged.endLine, newLines.join('\n'));
+      merged.startLine, merged.endLine, md);
     if (result.op === null) return;
     const prevLines = lines;
     lines = result.lines;
+    // §3.3's collapse: the emitted items occupy the whole (possibly widened)
+    // commit range — nothing else is written here.
+    declareCollapse({
+      startLine: merged.startLine,
+      endLine: merged.startLine + md.split('\n').length - 1,
+    });
     if (!(await safeRerenderAll())) {
       lines = rollbackFailedRender({ lines, stack }, result, prevLines);
     }
@@ -3062,6 +4000,10 @@
     hideTableGrips();
     hideTableEdgeMenu();
     cancelTeDrag();
+    // S4 Task 2: and an in-flight ⠿ block drag, for the same reason — this
+    // resolution is about to commit and re-render whichever block it holds an
+    // ordinal into.
+    cancelBlockDrag();
     if (!burst) return true;
     // §10-gap fix (review): this burst's block's "pristine" window (see
     // `pristineInsert`'s own comment) closes right here, the moment its
@@ -3308,6 +4250,408 @@
     return document.querySelector('.ed-block[data-block-id="' + target.id + '"]');
   }
 
+  // ── S3 Task 2: block multi-select state ────────────────────────────────
+  // The selection's identity is a LINE RANGE, never ids and never nodes.
+  // buildBlockMap renumbers every id from 0 on every render (blockmap.js's
+  // `nextId = {v:0}`) and every batch operation triggers a full
+  // rerenderAll(), so an id or an element held across a commit is a dangling
+  // reference into a document that no longer exists — the same reasoning
+  // blockElAtLine() above is written down for. All the range arithmetic and
+  // §3.3's membership rules live in the pure, node-tested
+  // lib/editor/selection.js (window.md2docSelection); this file only paints.
+  let blockSelection = null; // { anchorLine, focusLine } | null
+
+  // §4.4: the focus endpoint's block element. Null when the selection's focus
+  // line is not (or is no longer) some block's startLine — the caller then
+  // simply holds no focus rather than guessing at a neighbour.
+  function selectionFocusBlockEl() {
+    if (!blockSelection) return null;
+    return blockElAtLine(blockSelection.focusLine);
+  }
+
+  // Repaints `.ed-selected` and the roving tabindex from `blockSelection`.
+  // Idempotent and total: it clears both attributes off EVERY block first, so
+  // it is equally the "apply" and the "clear" path and no stale tint can
+  // survive a state change.
+  function applySelectionClasses() {
+    const members = blockSelection && selectionLib
+      ? selectionLib.membersOf(blockSelection, blocks) : [];
+    const ids = new Set(members.map((b) => String(b.id)));
+    for (const el of allBlockEls()) {
+      el.classList.toggle('ed-selected', ids.has(el.getAttribute('data-block-id')));
+      el.removeAttribute('tabindex');
+    }
+    // §4.4 wants a REAL focus holder: with focus left on <body> the keydown
+    // dispatch has nothing to anchor on and the browser's own Tab order walks
+    // straight past the selection. A ROVING tabindex="-1" (exactly one block
+    // focusable at a time, moved as the focus endpoint moves) is the standard
+    // answer, and -1 rather than 0 keeps every block out of the sequential Tab
+    // order — Tab inside the editor is already a structural key. There is no
+    // other tabindex anywhere in lib/; this is greenfield.
+    //
+    // Focusing a .ed-block is inert for the burst machinery: the delegated
+    // focusin handler bails unless the target closes onto .ed-wys-cell or
+    // .ed-wys-armed, and the block WRAPPER is neither (armEditables() arms
+    // blockContentEl(), a child).
+    const focusEl = selectionFocusBlockEl();
+    if (focusEl) { focusEl.setAttribute('tabindex', '-1'); focusEl.focus(); }
+  }
+
+  // S3 Task 4: the keyboard's anchor for §4.4 entry (c) once the set is gone.
+  // MEASURED on 2026-08-30, contradicting Task 2 carry 7 / Task 3 carry 7:
+  // removing the roving `tabindex` from the block that currently has DOM
+  // focus BLURS it in Chromium (`document.activeElement` becomes <body>), so
+  // applySelectionClasses()'s "clear both attributes off EVERY block first"
+  // means a cleared selection leaves NO focused block behind. Without this
+  // memory there is nothing for Shift+↑↓ to resume from after an Escape: the
+  // caret's own surface owns those keys (they are the browser's
+  // extend-the-text-selection gesture, and the burst short-circuit keeps them
+  // that way), and <body> has no block to anchor on.
+  let lastSelectionFocusLine = null;
+
+  function setBlockSelection(sel) {
+    if (sel && Number.isFinite(Number(sel.focusLine))) lastSelectionFocusLine = Number(sel.focusLine);
+    blockSelection = sel;
+    applySelectionClasses();
+  }
+  function clearBlockSelection() { blockSelection = null; applySelectionClasses(); }
+
+  // ── S3 Task 5: surviving rerenderAll() (§4.4's ordered three steps) ────
+  // `contentEl.innerHTML` is replaced wholesale on every commit, so the
+  // painted tint and the roving focus holder are destroyed by definition —
+  // MEASURED on this branch: with a selection over lines 3–4 standing, a
+  // rerenderAll() leaves `blockSelection` intact (its identity is a line
+  // range, which no render can invalidate) but the fresh server HTML carries
+  // no `.ed-selected` and no `tabindex`, so `document.activeElement` is
+  // `<body>` and the keyboard is dead while the model still says two blocks
+  // are selected. The model and the paint drift apart, and every batch
+  // operation in Tasks 6/7 ends in exactly this swap.
+  //
+  // NOTE for the plan's own wording: it says "without the rebuild the tint
+  // survives (it is re-derived from lines) but focus falls back to <body>".
+  // Only the second half is true. Nothing re-derives the tint — the swap
+  // simply throws the classes away with the nodes that carried them.
+  //
+  // §4.4 also says each structural operation DECLARES the line range it
+  // produced, and that a range which no longer resolves clears the selection
+  // rather than leaving it dangling. `pendingSelectionRange` is that
+  // declaration: `undefined` means "nothing declared, keep whatever is
+  // standing" (a burst commit must not destroy a selection it never touched),
+  // `null` means "clear" (undo/redo), and a `{startLine, endLine}` means
+  // "collapse to this" (Tasks 6/7's batch operations).
+  let pendingSelectionRange;
+  function declareSelectionRange(range) { pendingSelectionRange = range; }
+
+  // §4.4 step 3: the rebuilt set must have a REAL focus holder, not <body>.
+  // A declared range's focus endpoint is a LINE, and after a render that line
+  // is often the INSIDE of a block rather than its startLine — collapseTo()
+  // hands back the range's endLine, and a table or a fence owns four lines
+  // for one block. selectionFocusBlockEl() answers null for such a line
+  // (Task 2 carry 5), i.e. a selection with no focus holder and a dead
+  // keyboard, which is the whole failure this task exists to prevent. So the
+  // focus endpoint is snapped onto the startLine of the member it lands in,
+  // on the side it was already on so the gesture stays reversible.
+  //
+  // The snap is REFUSED if it would change the member set: Tasks 6/7 compute
+  // the batch anchor from these members and that anchor writes bytes, so a
+  // focus holder is not worth a silently different set. That branch is
+  // defensive — snapping only ever shrinks the range towards the anchor, and
+  // a member that would drop out would have to start after the block the
+  // focus line lands in — but "buildBlockMap never emits that" is an argument
+  // about another file's output, not an invariant this one can enforce.
+  function selectionWithFocusHolder(sel, members) {
+    if (blockElAtLine(sel.focusLine)) return sel;
+    const snapTo = Number(sel.focusLine) < Number(sel.anchorLine)
+      ? members[0] : members[members.length - 1];
+    if (!snapTo) return sel;
+    const candidate = { anchorLine: sel.anchorLine, focusLine: snapTo.startLine };
+    const after = selectionLib.membersOf(candidate, blocks);
+    if (after.length !== members.length) return sel;
+    for (let i = 0; i < after.length; i++) if (after[i] !== members[i]) return sel;
+    return blockElAtLine(candidate.focusLine) ? candidate : sel;
+  }
+
+  // §4.4 step 2, called from rerenderAll() AFTER its unconditional teardown
+  // (so nothing below can null what this just set) and BEFORE the two
+  // `try`-swallowed rebind blocks (so a diagram-init throw cannot skip it).
+  // `armEditables()` still runs first, per its own comment.
+  function rebuildBlockSelection(declaredRange) {
+    // Nothing standing and nothing declared: the fresh DOM already carries no
+    // tint and no tabindex, so there is nothing to repaint and no reason to
+    // walk every block on a render that has no selection anywhere near it.
+    if (declaredRange === undefined && !blockSelection) return;
+    const sel = declaredRange === undefined
+      ? blockSelection
+      : (selectionLib ? selectionLib.collapseTo(declaredRange) : null);
+    if (!sel || !selectionLib) { clearBlockSelection(); return; }
+    const members = selectionLib.membersOf(sel, blocks);
+    if (!members.length) { clearBlockSelection(); return; }
+    setBlockSelection(selectionWithFocusHolder(sel, members));
+  }
+
+  // The block record behind a rendered `.ed-block`, or null. Every gesture
+  // below turns an element (or a point) into a LINE this way — the line is
+  // the selection's identity, the id is only how the DOM addresses it in
+  // between two renders.
+  function blockRecOf(blockEl) {
+    if (!blockEl || !blockEl.getAttribute) return null;
+    const raw = blockEl.getAttribute('data-block-id');
+    if (raw === null) return null; // provisional block: no record yet
+    return blocks.find((b) => b.id === Number(raw)) || null;
+  }
+
+  // Test-only hooks. Task 2 shipped the two WRITE hooks (no gesture created a
+  // selection yet); Task 4 adds the READ one so a gesture scenario can assert
+  // the resulting member set BY LINE RANGE rather than by counting tinted
+  // nodes — a test that counts `.ed-selected` silently passes or fails on
+  // Task 2's CSS instead of on the gesture under test. `memberLines` is the
+  // model's own answer (selection.js against `blocks`); `domSelectedLines` is
+  // the same question asked of the DOM, so a scenario can pin both and catch
+  // the two drifting apart. They are the browser-side counterpart of the
+  // node-side `module.exports` guard at the top of this file — the same
+  // "expose the seam the tests need, in the one environment that has it"
+  // split — and nothing in the product calls them.
+  window.__edTestSetSelection = function (anchorLine, focusLine) {
+    setBlockSelection({ anchorLine: anchorLine, focusLine: focusLine });
+  };
+  window.__edTestClearSelection = function () { clearBlockSelection(); };
+  window.__edTestGetSelection = function () {
+    if (!blockSelection) return null;
+    const members = selectionLib ? selectionLib.membersOf(blockSelection, blocks) : [];
+    return {
+      anchorLine: blockSelection.anchorLine,
+      focusLine: blockSelection.focusLine,
+      memberLines: members.map((b) => [b.startLine, b.endLine]),
+      domSelectedLines: allBlockEls()
+        .filter((el) => el.classList.contains('ed-selected'))
+        .map((el) => { const r = blockRecOf(el); return r ? [r.startLine, r.endLine] : null; }),
+      focusHolderId: (function () {
+        const el = selectionFocusBlockEl();
+        return el ? el.getAttribute('data-block-id') : null;
+      })(),
+    };
+  };
+  // Task 5 seams. `__edTestForceRerender` runs the REAL rerenderAll() (not
+  // safeRerenderAll(), so a scenario sees a throw rather than a banner) —
+  // every batch operation in Tasks 6/7 ends in one, and this is how a
+  // scenario exercises the swap without also exercising a batch operation
+  // that does not exist yet. `__edTestTruncateTo` drops `lines` to its first
+  // n, which is how a scenario reaches the "the selection's lines no longer
+  // parse" state without an operation that deletes blocks.
+  // Task 6 seam: the raw `blocks` records. A scenario needs them to prove the
+  // shape of its OWN fixture — specifically that a no-line PHANTOM really does
+  // sit BETWEEN two members, which is an INVERTED {startLine, endLine} at a
+  // known index. Nothing in the DOM carries that fact: the phantom's element is
+  // there, its (missing) line range is not, so a gap scenario that asserted the
+  // gap from the DOM alone would be asserting something it merely believes.
+  window.__edTestBlocks = function () {
+    return blocks.map((b) => ({
+      id: b.id, type: b.type, startLine: b.startLine, endLine: b.endLine,
+    }));
+  };
+  window.__edTestForceRerender = function () { return rerenderAll(); };
+  window.__edTestTruncateTo = function (n) { lines = lines.slice(0, n); };
+
+  // ── S3 Task 4: the entry and exit GESTURES ─────────────────────────────
+  // §4.4 entries: (a) press inside a block and drag across its boundary;
+  // (b) Shift+Click; (c) Shift+↑↓. Exits: Escape (Task 3's keydown prologue)
+  // and a click inside any block without Shift. Scrolling and window blur
+  // deliberately do NOT clear — the drag they abort is torn down, the
+  // selection it built stands.
+  //
+  // Everything below turns a POINT or an ELEMENT into a LINE and hands it to
+  // selection.js; no gesture ever holds an id or a node across a repaint.
+
+  // Chrome that owns its own press/click semantics. A gesture must never be
+  // armed on one of these, or Shift+Clicking the ⠿ handle would build a
+  // selection instead of opening the menu, and a drag inside the raw
+  // textarea would fight its own text selection.
+  const ED_SEL_GESTURE_CHROME = '.ed-handle, .ed-handle-menu, .ed-insert, .ed-insert-menu, ' +
+    '.ed-te-menu, .ed-te-grip, .ed-tb-insert, .ed-seltb, .ed-conflict, .ed-raw';
+  function isSelGestureChrome(target) {
+    return !!(target && target.closest && target.closest(ED_SEL_GESTURE_CHROME));
+  }
+
+  // The line a gesture landing on `target` selects, or null when there is
+  // none. Task 1 carry 3 / Task 2 carry 5: the focus endpoint must always be
+  // the `startLine` of a block that OWNS a line — selectionFocusBlockEl()
+  // returns null for anything else, which would leave a selection with no
+  // focus holder and a dead keyboard. A phantom (the outer item of a
+  // same-line nest, `endLine < startLine`) is therefore never the answer; its
+  // own first line-owning descendant is, since that descendant is what the
+  // user sees inside the phantom's box.
+  function selectableLineOf(target) {
+    let el = target && target.closest ? target.closest('.ed-block') : null;
+    while (el) {
+      const rec = blockRecOf(el);
+      if (rec && rec.endLine >= rec.startLine) return rec.startLine;
+      const inner = el.querySelector('.ed-block');
+      const innerRec = inner ? blockRecOf(inner) : null;
+      if (innerRec && innerRec.endLine >= innerRec.startLine) return innerRec.startLine;
+      el = el.parentElement && el.parentElement.closest ? el.parentElement.closest('.ed-block') : null;
+    }
+    return null;
+  }
+
+  function selectableLineAtPoint(clientX, clientY) {
+    // Coordinates, not `e.target`: once a drag is under pointer capture every
+    // pointer event retargets to the capture element, so the target says
+    // nothing about what is under the cursor. elementFromPoint always does.
+    const el = document.elementFromPoint(clientX, clientY);
+    if (!el || !contentEl.contains(el)) return null;
+    return selectableLineOf(el);
+  }
+
+  function focusedSelectableLine() {
+    const el = document.activeElement;
+    return el && el.closest ? selectableLineOf(el) : null;
+  }
+
+  function clearNativeTextSelection() {
+    const s = window.getSelection();
+    if (s && typeof s.removeAllRanges === 'function') s.removeAllRanges();
+  }
+
+  // The in-flight press. `dragging` flips only once the pointer has crossed
+  // into a DIFFERENT block — §4.4's entry threshold is that boundary, not a
+  // pixel distance, so a press-and-wiggle inside one block stays ordinary
+  // text selection.
+  let blockSelDrag = null;
+  // A gesture's own trailing `click`. A press in one block released in
+  // another still fires one (on their common ancestor), and
+  // wireBlockSelection()'s click handler would answer it with either
+  // switchAwayFrom() (released outside any block) or the §4.4 exit rule
+  // (released inside one) — the second of which would clear the very
+  // selection the drag just built. Consumed exactly once, and re-armed to
+  // false by the next pointerdown so a gesture whose click never arrives
+  // (an abort, a release outside the window) cannot swallow a later one.
+  let blockSelClickSuppressed = false;
+
+  function armBlockSelDrag(e) {
+    if (isSelGestureChrome(e.target)) return;
+    const line = selectableLineOf(e.target);
+    if (line === null) return;
+    blockSelDrag = {
+      pointerId: e.pointerId,
+      originLine: line,
+      // §4.4's table exception: a drag whose origin is a cell and which never
+      // leaves that table keeps native text selection. Measured: a table is
+      // exactly ONE .ed-block, so the block-boundary rule already says the
+      // same thing — this is kept explicit because it is the spec's own
+      // wording and because it stays correct if a cell ever comes to contain
+      // blocks of its own.
+      originTableEl: e.target.closest ? e.target.closest('table') : null,
+      focusLine: line,
+      dragging: false,
+      captureEl: null,
+    };
+  }
+
+  // Mirrors the table drag's capture skeleton (setPointerCapture at the top
+  // of the te pointerdown, releaseTeCapture() on every exit): capture is what
+  // keeps pointermove/up arriving once the cursor leaves the window. Taken at
+  // ENGAGE time rather than at press time, so a press that turns out to be
+  // plain text selection is never interfered with, and on documentElement
+  // rather than the pressed node, which a mid-gesture commit can detach.
+  function captureBlockSelDrag(e) {
+    const el = document.documentElement;
+    if (el && typeof el.setPointerCapture === 'function') {
+      try { el.setPointerCapture(e.pointerId); blockSelDrag.captureEl = el; }
+      catch (err) { /* not capturable here — the buttons/blur/cancel guards still apply */ }
+    }
+  }
+
+  // Unconditional teardown of the in-flight press, called from pointerup,
+  // pointercancel, the window blur listener, the next pointerdown, and the
+  // "no buttons are down any more" guard in pointermove. The SELECTION is
+  // never touched here: §4.4 says blur does not clear, and an aborted drag
+  // must leave a complete set rather than a half-built one.
+  function endBlockSelDrag() {
+    if (!blockSelDrag) return;
+    const st = blockSelDrag;
+    blockSelDrag = null;
+    if (st.captureEl && typeof st.captureEl.releasePointerCapture === 'function') {
+      try { st.captureEl.releasePointerCapture(st.pointerId); } catch (err) { /* already released */ }
+    }
+    if (st.dragging) blockSelClickSuppressed = true;
+  }
+
+  function updateBlockSelDrag(e) {
+    if (!blockSelDrag || e.pointerId !== blockSelDrag.pointerId) return;
+    if (tePointer) return; // a grip gesture owns this pointer
+    // The browser can simply never deliver a pointerup (released over browser
+    // chrome, over another window). The next move with no button held is the
+    // only signal left that the gesture is over.
+    if (typeof e.buttons === 'number' && e.buttons === 0) { endBlockSelDrag(); return; }
+    const overEl = document.elementFromPoint(e.clientX, e.clientY);
+    if (!blockSelDrag.dragging) {
+      if (blockSelDrag.originTableEl && overEl && blockSelDrag.originTableEl.contains(overEl)) return;
+      const line = selectableLineAtPoint(e.clientX, e.clientY);
+      if (line === null || line === blockSelDrag.originLine) return;
+      blockSelDrag.dragging = true;
+      blockSelDrag.focusLine = line;
+      captureBlockSelDrag(e);
+    } else {
+      const line = selectableLineAtPoint(e.clientX, e.clientY);
+      // Off every block (the page margin, an overlay): keep the last block the
+      // drag actually reached rather than collapsing the set mid-gesture.
+      if (line !== null) blockSelDrag.focusLine = line;
+    }
+    e.preventDefault();
+    // The press started a native text selection that keeps extending with the
+    // pointer; once the gesture is a BLOCK selection the two must not both be
+    // painted. preventDefault() on pointermove does not stop it, so it is
+    // dropped explicitly on every frame of the drag.
+    clearNativeTextSelection();
+    setBlockSelection({ anchorLine: blockSelDrag.originLine, focusLine: blockSelDrag.focusLine });
+  }
+
+  // §4.4 entry (b). The anchor is the standing selection's own anchor, or —
+  // entering fresh — the block that holds the caret, so Shift+Click reads as
+  // "from where I am to here". With neither, it collapses onto the clicked
+  // block, which is extendTo()'s own answer for a null selection.
+  function beginShiftClickSelection(e) {
+    if (isSelGestureChrome(e.target)) return;
+    const line = selectableLineOf(e.target);
+    if (line === null) return;
+    const seed = focusedSelectableLine();
+    // Shift+Click INSIDE the block that already holds the caret is the one
+    // Shift+Click that must stay native: it is how a user extends a text
+    // selection to a point, and there is no second block to take.
+    if (!blockSelection && seed !== null && seed === line) return;
+    // Cancels the caret placement (and the focus move that would start a
+    // burst on the clicked block) before it happens; the trailing click is
+    // consumed by the flag.
+    e.preventDefault();
+    blockSelClickSuppressed = true;
+    clearNativeTextSelection();
+    const base = blockSelection || (seed === null ? null : { anchorLine: seed, focusLine: seed });
+    setBlockSelection(selectionLib.extendTo(base, line));
+  }
+
+  // §4.4 entry (c) / its extension. Returns true when it owned the key.
+  // stepFocus() skips blocks that own no source line, so every press MOVES —
+  // Task 1 carry 3's "the first Shift+↓ does nothing, the second one moves".
+  function stepSelectionFocus(dir) {
+    if (!selectionLib) return false;
+    if (blockSelection) {
+      setBlockSelection(selectionLib.stepFocus(blockSelection, blocks, dir));
+      return true;
+    }
+    // Entering fresh: the block that holds the roving focus, or — once a
+    // clear has blurred it (see lastSelectionFocusLine) — the line the last
+    // selection ended on, provided it still names a block that owns a line.
+    let seed = focusedSelectableLine();
+    if (seed === null && lastSelectionFocusLine !== null) {
+      const rec = blocks.find((b) => b.startLine === lastSelectionFocusLine &&
+        b.endLine >= b.startLine);
+      if (rec) seed = rec.startLine;
+    }
+    if (seed === null) return false;
+    setBlockSelection(selectionLib.stepFocus({ anchorLine: seed, focusLine: seed }, blocks, dir));
+    return true;
+  }
+
   // ── 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,
@@ -3662,7 +5006,13 @@
       if (res.unsupported[i] !== 'MULTILINE') return false;
     }
     if (opts && opts.columnOnly) return true;
-    if (!targetEl) return multi.length === 0;
+    // S3 Task 6: `targetEl` may be an ARRAY — a batch operation has N targets in
+    // one run and every one of them has to clear §4.1's multi-line gate, not
+    // just the one the ⠿ was pressed on. An empty array is the same question as
+    // no target at all (nobody is being rewritten).
+    const targetEls = targetEl === null || targetEl === undefined
+      ? [] : (Array.isArray(targetEl) ? targetEl : [targetEl]);
+    if (!targetEls.length) 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
@@ -3675,12 +5025,15 @@
     // 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;
+    for (let t = 0; t < targetEls.length; t++) {
+      const targetRaw = targetEls[t].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.
+      if (multi.indexOf(targetRaw) !== -1) return false;
+    }
+    return true;
   }
 
   // Esc inside a burst: revert to snapshot 0 (the pre-focus baseline) and
@@ -4157,6 +5510,222 @@
     return true;
   }
 
+  // ── S3 Task 7: §3.5's batch Tab / Shift+Tab over a standing selection ──
+  //
+  // The whole task in one sentence: compute the delta ONCE, from the member
+  // with the MINIMUM old indent, apply it to the whole set, and only THEN
+  // clamp per item. Running the single-item arithmetic per member instead
+  // breaks the sibling relationships the user selected — §3.5's own worked
+  // example is `- a / (2sp)- b / (2sp)- c` with b+c selected: per item, c's
+  // ceiling is 2 (because b sits at 1) so c moves there and is ADOPTED as b's
+  // child, when the correct answer is that nothing moves at all.
+  //
+  // And the one number is the MINIMUM AVAILABLE HEAD-ROOM across the members,
+  // not the head-room of the shallowest one. This is review defect D1
+  // (2026-08-31), MEASURED on 8486ecd: `- a / (2sp)- b / (2sp)- c / - d` with
+  // b, c and d selected took its delta from d (the minimum INDENT, +1) and
+  // applied it to all three; applyIndentClamp() then walked the operated
+  // blocks in document order, pulled b back to its own ceiling of 1 — and
+  // recomputed c's ceiling against the JUST-SETTLED b, so c was allowed to
+  // stay at 2 and became b's CHILD. Only the constrained member came back.
+  // That is the 「半移動」 §3.4 rule 4 forbids: 「段內相對關係必須保持」.
+  //
+  // So a member with no head-room floors the WHOLE set at zero. Three reasons
+  // this is the branch and not "move what can move":
+  //   * it is what Shift+Tab has always done — its delta is floored by a
+  //     member already at indent 0, and T7 carry 5 records that as a
+  //     deliberate no-op for exactly this reason;
+  //   * §3.4 rule 4 requires the members' relative relationships to survive
+  //     the operation, and a partial move is precisely what breaks them;
+  //   * CHANGELOG v2.12.0 already promises it — "a set that cannot move as a
+  //     whole does not move at all rather than half-moving".
+  //
+  // ⚠ §3.4 rule 3's SECOND worked example is written the other way round
+  // (「批次 Tab 選 b(1)..d(0) 時第一成員 b 已在上界 ⇒ delta 0 ⇒ 整批 no-op」 is
+  // listed there as a FAILURE of first-member anchoring). It cannot be
+  // satisfied at the same time as rule 4 on the D1 fixture — d moving while b
+  // and c are clamped IS the half-move — and the review ruled for rule 4. The
+  // b(1)..d(0) set is therefore a whole-batch no-op now, and T7's scenario for
+  // it was migrated with that reason in its assertion message.
+  //
+  // spanMinIndent() is still §3.4 rule 3's anchor VALUE for applyIndentClamp()
+  // — the bound the blocks BELOW the set are re-measured against — and that
+  // use is unchanged. Only the set's own movement is computed here.
+
+  // How far ONE member may move, as a magnitude (0 or 1), never a signed
+  // delta. `dir` is +1 (Tab) or -1 (Shift+Tab). The ceiling restates
+  // indentListItem()'s own single-item rule — the list-start clause included,
+  // so a set that opens a list cannot nest itself under the previous list's
+  // last item — and the floor is outdentListItem()'s (indent 0 cannot rise).
+  // Both read PRE-move indents, which is §3.4's global convention ("the
+  // operated block's indent" always means the value before the operation), and
+  // it is what makes the minimum below well-defined: every member is measured
+  // against the document as it stands, not against members already moved.
+  function memberIndentHeadroom(el, dir) {
+    const self = liAttrs(el);
+    if (!self) return 0;
+    if (dir < 0) return self.indent > 0 ? 1 : 0;
+    if (self.listStart) return 0;
+    const all = allBlockEls();
+    const i = all.indexOf(el);
+    if (i < 0) return 0;
+    const prev = liAttrs(all[i - 1]);
+    const max = prev ? prev.indent + 1 : 0;
+    return Math.max(0, Math.min(1, max - self.indent));
+  }
+
+  // How far the WHOLE set may move, as one SIGNED number: the smallest
+  // head-room any member has, in `dir`'s direction. Zero for an empty set and
+  // zero the moment one member cannot move, which is the D1 ruling.
+  function batchIndentDelta(liEls, dir) {
+    const els = liEls || [];
+    if (!els.length) return 0;
+    let room = 1;
+    for (let i = 0; i < els.length; i++) {
+      const r = memberIndentHeadroom(els[i], dir);
+      if (r < room) room = r;
+      if (room === 0) return 0;
+    }
+    return dir < 0 ? -room : room;
+  }
+
+  // The li half. One mutation, one clamp, one commit — never a loop over the
+  // members, for the reason the whole batch layer exists: a loop re-renders
+  // between items and invalidates every id in between.
+  async function indentListItemsBySelection(liEls, recs, dir) {
+    // Every list batch is one run's problem — see batchRunOf().
+    const run = batchRunOf(liEls);
+    if (!run) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); return; }
+    // `columnOnly`: an indent change rewrites nothing but leading columns, so a
+    // hard-wrapped member is a legal TARGET here — the same deviation the caret
+    // Tab's own gate documents, and in a batch every member is a target.
+    if (!listRunSupportsStructuralEdit(run, liEls, { columnOnly: true })) {
+      refuseStructuralListEdit(); return;
+    }
+    const oldIndent = spanMinIndent(liEls);
+    const delta = batchIndentDelta(liEls, dir);
+    // A zero delta is a COMPLETE no-op — nothing mutated, nothing committed,
+    // file byte-identical, the set left standing — exactly what the single-item
+    // Tab does at its own boundary, and NOT a refusal (no banner: the spec's
+    // 「靜默不動作是缺陷」 is about refusals, and this is the documented
+    // boundary answer §3.5 gives for a set at its ceiling). On §3.5's b+c
+    // example this IS the right answer, and it is the answer per-item maths
+    // cannot give; after D1 it is also the answer whenever ANY member is at
+    // its ceiling, which is what keeps the members' relative order intact.
+    if (delta === 0) return;
+    const first = recs[0];
+    const last = recs[recs.length - 1];
+    mutateListRun(() => {
+      liEls.forEach((el) => setBlockIndent(el,
+        Math.max(0, (Number(el.getAttribute('data-indent')) || 0) + delta)));
+      // ONE call for the whole set, never one per member: clampIndents() takes
+      // an ARRAY of operated indices precisely so §3.4 rule 3 computes one
+      // segment delta for the blocks below instead of N independent clamps, and
+      // its rule 1 then walks the operated blocks in document order so each is
+      // measured against the member above it that the same pass just settled.
+      applyIndentClamp(run, liEls, oldIndent);
+    });
+    // Re-derived AFTER the mutation, like the caret Tab's: an indent change can
+    // move a block between runs.
+    const liveRun = listRunOf(liEls[0]);
+    if (!liveRun.length) return;
+    // Column-only: nothing's CONTENT moved, so every block in the span — the
+    // members included — is a bystander whose source bytes must come back
+    // untouched.
+    const carry = bystanderCarryOver(liveRun, null);
+    // §3.3's collapse, declared immediately before the commit's render (Task 5
+    // carry 5) and only when a set was standing (Task 6 carry 6). A
+    // column-only edit changes no line COUNT and moves no line, so the members
+    // keep exactly the range they had.
+    declareCollapse({ startLine: first.startLine, endLine: last.endLine });
+    await commitListStructure(liveRun, null, false, { carryOver: carry });
+  }
+
+  // The non-li half — §3.5's heading row, batched: Tab lowers a heading one
+  // level (clamped to H6), Shift+Tab raises it (clamped to H1), and a
+  // paragraph / quote / code member is a true no-op.
+  //
+  // The span is rewritten IN PLACE inside its own line range: each heading
+  // member's line is re-emitted at the new depth and every other line —
+  // separators and non-heading members alike — comes back verbatim. That is
+  // what makes 「段落 no-op」 a real no-op instead of a re-serialization that
+  // could move bytes nobody asked it to, and it is why this is ONE
+  // commitRangeEdit and therefore one undo op.
+  async function changeHeadingDepthsInSpan(els, recs, dir) {
+    const first = recs[0];
+    const last = recs[recs.length - 1];
+    const span = lines.slice(first.startLine - 1, last.endLine);
+    let changed = false;
+    for (let i = 0; i < recs.length; i++) {
+      if (recs[i].type !== 'heading') continue;
+      const at = recs[i].startLine - first.startLine;
+      const cur = span[at];
+      // headingDepthOf() answers 1 for ANY line, matched or not, so a SETEXT
+      // heading ('Title' over '====') would be handed a '#' it never asked for
+      // and its underline left behind. Only a real ATX line is rewritten.
+      if (typeof cur !== 'string' || !/^#{1,6}(\s|$)/.test(cur)) continue;
+      const depth = headingDepthOf(cur);
+      const next = Math.max(1, Math.min(6, depth + dir));
+      if (next === depth) continue;
+      span[at] = withHeadingDepth(cur, next);
+      changed = true;
+    }
+    // Every member was a paragraph, or every heading already sat at its clamp:
+    // §3.5 rules that a no-op, so nothing is committed and nothing re-renders.
+    if (!changed) return;
+    const result = commitRangeEdit({ lines, blocks, stack },
+      first.startLine, last.endLine, span.join('\n'));
+    if (result.op === null) return;
+    const prevLines = lines;
+    lines = result.lines;
+    // §3.3's collapse: a depth change rewrites no line COUNT, so the set
+    // collapses onto the lines it already held.
+    declareCollapse({ startLine: first.startLine, endLine: last.endLine });
+    const okRender = await safeRerenderAll();
+    if (!okRender) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
+  // The keydown entry point. The "grip" is the roving focus holder, which is a
+  // member of the set by construction, so resolveGutterOperands() answers
+  // 'batch' and hands back the whole span — together with the shared preamble
+  // every ⠿ operation already goes through (switchAwayFrom(), the re-resolve
+  // after a commit that re-rendered, the no-source-line refusal, the emptiness
+  // and contiguity gates). Membership resolves by REFERENCE against the live
+  // `blocks`, which is exactly why the record must come from there and not from
+  // a fresh find() (Task 1 carry 4).
+  async function tabSelection(dir) {
+    const focusEl = selectionFocusBlockEl();
+    if (!focusEl) return;
+    const operands = await resolveGutterOperands(focusEl);
+    if (!operands) return;
+    const els = operands.els;
+    const recs = operands.recs;
+    const shape = spanListKinds(els);
+    // §3.6's 2026-08-31 ruling, inherited rather than re-invented. NOTE: this
+    // CONTRADICTS the S3 plan's Task 7 text ("a batch containing both kinds
+    // applies each rule to its own kind") — see the Task 7 carry. A mixed span
+    // would need the run's survivors re-serialized at the same time as lines
+    // outside the run are rewritten, i.e. two commits and therefore two undo
+    // ops, which §3.4's 「一次使用者手勢 = 恰好一個 undo op」 forbids.
+    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+    if (shape.allLi) { await indentListItemsBySelection(els, recs, dir); return; }
+    await changeHeadingDepthsInSpan(els, recs, dir);
+  }
+
+  // §3.6's 「Delete 整批刪」, whose 2026-08-31 ruling is that it goes through
+  // the SAME batch path as the ⠿ menu's 刪除 and that no second deletion path
+  // is written. deleteBlockViaGutter() already resolves §3.3's membership for
+  // itself and routes an all-li span to deleteListItemsViaGutter(), so the key
+  // is one call — every refusal, every collapse and the one-undo-op guarantee
+  // come with it for free rather than being restated here.
+  async function deleteSelection() {
+    const focusEl = selectionFocusBlockEl();
+    if (!focusEl) return;
+    await deleteBlockViaGutter(focusEl);
+  }
+
   // ── 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()
@@ -4183,6 +5752,10 @@
   // no-source-line callers pass their own text instead of a second function.
   function refuseStructuralListEdit(message) {
     showBanner(message || '此清單含不支援的格式，無法調整結構', null, null);
+    // Review recommendation 5: mark it, so the next SUCCESSFUL render clears
+    // it (dismissRefusalBanner(), called from rerenderAll()). Set after the
+    // showBanner() call, which resets the flag for every other caller.
+    activeBannerIsRefusal = true;
   }
 
   // Row 3, top-level press: spec §4 — "at top level the next press converts
@@ -5019,8 +6592,9 @@
   // 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's inner half visually
-  // overlaps one (it straddles the table's left border; see the geometry
+  // contenteditable cell, even though the row grip visually overlaps one
+  // (since §4.2 conflict 2 landed in S4 T1 it sits ENTIRELY inside the first
+  // column, within that cell's own widened left padding; 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
@@ -5333,20 +6907,46 @@
   // 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) + 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.
+  // Geometry, per axis (they are NOT mirror images — see below):
+  //   COLUMN grip: its CENTRELINE coincides with the table's TOP border, so
+  //     its hit rect straddles that border by half its own height on each
+  //     side (P0-a).
+  //   ROW grip: its LEFT EDGE coincides with the table's LEFT border, so the
+  //     whole grip is INSIDE the table. This is spec §4.2 hit-test
+  //     conflict 2's ruling, landed in S4 T1.
+  //
+  // Why the row axis had to break the symmetry. The block's own gutter ⠿
+  // hangs outside the content box at [blockLeft-22, blockLeft-4], and a
+  // table block's own table starts AT blockLeft, so a row grip centred on
+  // the table's left border occupied [blockLeft-10, blockLeft+10] and
+  // overlapped the ⠿'s right 6px. Both are position: fixed / absolutely
+  // positioned overlays and the grip is a document.body child at z-index 7,
+  // so the grip won that hit test whenever it was showing — which is
+  // whenever the pointer had recently been over a table cell. MEASURED on
+  // v2.12.0 at 1400x900 with the row grip parked on the HEADER row (the only
+  // row whose 28px-tall grip reaches the ⠿'s own top-20px band):
+  // elementFromPoint() walked across the table block's ⠿ at its vertical
+  // centre answered .ed-handle for x 390..401 and the ROW GRIP for x
+  // 402..407. S4 makes the ⠿ a drag handle, so those 6px would have started
+  // a table ROW drag instead of a block move.
+  //
+  // An earlier revision (v2.10.1) already tried the inset and was reverted,
+  // because a 20px grip inside a cell whose left padding is 14px sits on
+  // that cell's TEXT. That is fixed on the CSS side this time rather than by
+  // giving the grip back its outside half: lib/md2doc.js pads the first
+  // column to --ed-te-cell-pad-left (the grip's own width plus the gutter
+  // pair's breathing gap) in EDIT MODE ONLY. The ⠿ ↔ grip clearance that
+  // remains is exactly that same breathing-gap token — see the edit-mode
+  // :root block in lib/md2doc.js, which spells both tokens out; this file
+  // deliberately does not name them, because test/editor-client.test.js
+  // forbids the retired hover-gutter class name as a bare substring and the
+  // token names contain it. Neither edge is written down twice, so the two
+  // cannot drift apart again — drift is what produced this defect (the CSS
+  // comment claiming "an 8px gap" was describing v2.11.0's pair position,
+  // which v2.11.1 replaced).
+  // test/editor-client-runtime.test.js asserts BOTH directions: every pixel
+  // of a block's ⠿ answers that ⠿ (row grip hidden and showing), and the row
+  // grip's own centre answers the row grip.
   // 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
@@ -5425,12 +7025,16 @@
   // gripCenter(), which jump straight to the grip's own coordinates) could
   // ever land on it; a real mouse gesture could not.
   //
-  // 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.
+  // Current geometry (the two axes DIVERGED in S4 T1, §4.2 conflict 2): the
+  // COLUMN grip still straddles the table's TOP border, half above / half
+  // below, so the corridor-crossing bug described above still applies to it
+  // exactly as originally described and pointInColGripZone() still covers
+  // the outside-the-border corridor. The ROW grip is now entirely INSIDE the
+  // table (its left edge on the table's left border), so a pointer
+  // travelling from a cell to it never leaves the table and there is no
+  // corridor to cross — pointInRowGripZone() is the padded grip rect alone.
+  // See its own comment for why the old formula was deleted rather than
+  // left in place to evaluate to the empty set.
   //
   // Review fix (Important, first pass over-permissive): the first version of
   // this fix kept a grip visible while the pointer was ANYWHERE within the
@@ -5443,14 +7047,30 @@
   // SPECIFIC shown grip's own anchor (pointInRowGripZone()/
   // pointInColGripZone() below) instead of the whole table.
   //
-  // 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.
+  // What each keep-zone covers TODAY — and the two axes diverged when §4.2
+  // conflict 2 moved the row grip inside the table (S4 T1):
+  //   pointInColGripZone() still keeps the ORIGINAL corridor shape: the
+  //     union of (the column grip's own padded rect) and (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). The column
+  //     grip still straddles the top border, so that corridor is still real.
+  //   pointInRowGripZone() is now the padded grip rect ALONE. Its corridor
+  //     was the strip between the grip's own LEFT edge and the table's LEFT
+  //     border; with the grip's left edge ON that border the strip is empty,
+  //     and §4.6 explicitly warns that leaving the formula in place would
+  //     make it (and the two scenarios downstream of it) silently vacuous
+  //     rather than red. It is deleted rather than left to read as if it did
+  //     something. Nothing is lost: the corridor existed because a pointer
+  //     travelling from a cell to a border-straddling grip had to leave the
+  //     table on the way, and a grip that is entirely inside the table has no
+  //     such approach — the pointer goes cell -> grip, and the
+  //     `target.closest('.ed-te-grip-row')` early return at the top of
+  //     updateTableEdgeGrips() covers the moment it arrives. The observable
+  //     change is that leaving the table on the left now hides the row grip
+  //     immediately, at the anchor row's own height as well as at any other
+  //     row's; the scenario named below asserts both halves, because "hidden
+  //     at another row's height" alone is true of any geometry once the
+  //     corridor is gone.
   // 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
@@ -5470,15 +7090,17 @@
   function pointInRowGripZone(x, y) {
     if (rowGrip.hidden || !gripRowTableEl || !gripRowEl ||
       !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」必定經過邊界外側的
-    // 那半個 grip 寬度。走廊＝從 grip 自己的左緣到表格左緣，垂直方向夾在
-    // 所錨定那一列的上下緣（加 TE_GRIP_ZONE_PAD_PX 的次像素寬容）。
-    const rowRect = gripRowEl.getBoundingClientRect();
-    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;
+    // §4.2 衝突 2（S4 T1）之後 row grip 整個落在表格內側，左緣就壓在表格
+    // 左邊界上，所以舊的走廊公式 `x >= gr.left && x <= tableRect.left` 塌成
+    // 空集合。§4.6 已經預告過這件事：留著它不會變紅，只會變成空測。這裡
+    // 直接刪掉，keep-zone 只剩 grip 自己的 padded rect。
+    // 走廊本來只為了一件事存在——指標從儲存格走向一個跨在邊界上的 grip
+    // 時必定會先離開表格；grip 內移之後那條路徑整段都在表格內（先是
+    // 儲存格，接著是 grip 自己，由 updateTableEdgeGrips() 開頭那個
+    // `target.closest('.ed-te-grip-row')` 早退接手），所以沒有走廊可走。
+    // 對使用者可見的差別是：從左側離開表格會立刻收掉 row grip，錨定那一
+    // 列的高度也不例外。
+    return pointInPaddedRect(x, y, rowGrip.getBoundingClientRect(), TE_GRIP_ZONE_PAD_PX);
   }
 
   function pointInColGripZone(x, y) {
@@ -5507,9 +7129,10 @@
   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 — 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
+    // table — the column grip PAINTS half outside it (straddling the top
+    // border) and the row grip paints inside the first column (§4.2
+    // conflict 2). Either way neither is a table descendant, 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"
@@ -5544,8 +7167,11 @@
     // 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. 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
+    // 「grip 位置都一樣」) — its LEFT EDGE on the table's left border, i.e.
+    // entirely inside the table (spec §4.2 hit-test conflict 2, landed
+    // S4 T1 — see the geometry note above buildTableGrip() for the
+    // measurement that forced it), 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
@@ -5554,13 +7180,19 @@
       gripRowTableEl = tableEl;
       gripRowEl = rowEl;
       const r = rowEl.getBoundingClientRect();
-      // Fallback dims match .ed-te-grip-row's own CSS width/height exactly
-      // (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;
+      // Fallback height matches .ed-te-grip-row's own CSS height exactly
+      // (28) — offsetHeight reads 0 while `hidden` (display: none) is still
+      // true on the FIRST show of a hover session, before the
+      // `hidden = false` assignment below takes effect. There is no width
+      // fallback any more, and that is the point: the left edge is the
+      // table's own border, so the grip's WIDTH is not an input to its
+      // position at all. It used to be (`tableRect.left - gw / 2`), which
+      // meant the CSS width and this literal `20` had to agree for the
+      // gutter clearance to hold — exactly the drift §4.2 conflict 2 is
+      // about. The width now lives in one place only, the
+      // --ed-te-grip-row-w token in lib/md2doc.js.
       const gh = rowGrip.offsetHeight || 28;
-      rowGrip.style.left = (tableRect.left - gw / 2) + 'px';
+      rowGrip.style.left = tableRect.left + 'px';
       rowGrip.style.top = (r.top + r.height / 2 - gh / 2) + 'px';
       rowGrip.hidden = false;
     } else {
@@ -5914,6 +7546,820 @@
     currentBurst.history.snap('drag-col');
   }
 
+  // ── S4 Task 2: dragging a BLOCK by its ⠿ handle (spec §4.5) ─────────────
+  // The gesture SKELETON only — threshold, capture, drop-target computation,
+  // the indicator, and every cancellation path. THE DROP IS A NO-OP; Tasks
+  // 3-7 add the commits. §4.5 says to reuse the table row drag's skeleton
+  // above, and this does, including its central invariant:
+  //
+  //     NOTHING IN THE DOM IS MUTATED DURING A DRAG. Only the indicator moves.
+  //
+  // That is the whole reason cancelBlockDrag() can be called unconditionally
+  // from Escape / pointercancel / window blur / the next pointerdown /
+  // rerenderAll() / resolveBurst() with nothing to revert — see
+  // cancelTeDrag()'s own comment for the same argument on the row axis. It
+  // also means no `class=""` residue can reach a burst's zero-edit guard (the
+  // row path had to strip one by hand, because it DIMS the dragged <tr>; this
+  // gesture deliberately dims nothing, so the question never arises). Even the
+  // ⠿ menu, which lives as a CHILD of its block and would therefore be a
+  // content mutation to close, is left alone until the gesture is over.
+  // S4 Task 2b: the drag-cursor class, on `document.documentElement`. Named
+  // once so the add, the remove and lib/md2doc.js's rule cannot drift apart.
+  const BLOCK_DRAGGING_CLASS = 'ed-block-dragging';
+  const blockDropIndicator = document.createElement('div');
+  blockDropIndicator.className = 'ed-block-drop-indicator';
+  blockDropIndicator.hidden = true;
+  document.body.appendChild(blockDropIndicator);
+
+  // The drop-target candidates: the document's block sequence, in document
+  // order. MEASURED on this branch (1400x900, a doc mixing paragraphs, a
+  // heading, a list run with a nested item, a same-line-nest PHANTOM, a
+  // fenced code block and a table): every single `.ed-block` is a DIRECT
+  // child of `contentEl` — S1 flattened the <ul>/<ol> containers away — so
+  // allBlockEls() already IS that sequence, with no nesting to flatten and no
+  // second, overlapping y-range sitting inside another candidate's box.
+  // Named rather than inlined because Tasks 3-7 re-resolve against it.
+  function blockDropCandidates() {
+    return allBlockEls();
+  }
+
+  // Nearest block-drop target for `clientY` — a discriminated union:
+  //   {mode: 'before-block', blockIndex, y} | {mode: 'append', y}
+  // `blockIndex` is an ORDINAL into blockDropCandidates(); never a
+  // `data-block-id` (blockmap.js renumbers 0..n-1 on every render, so a
+  // captured id names the target's NEIGHBOUR after any commit that changes
+  // the block count) and never a node (a mid-gesture commit detaches them).
+  //
+  // spec §4.6 replaced the table's `{beforeRow, y}` with exactly this shape,
+  // because a null `beforeRow` had been overloaded to mean "append". That
+  // ruling is followed here rather than nearestColDropTarget()'s flat
+  // `{index, x}`, which is the one place it was never applied.
+  //
+  // There is no 'above-header' counterpart: a table's first row IS its
+  // header, so promoting a row to first place needed its own mode; the
+  // document has no such distinguished first block, and `before-block 0`
+  // already says "become the new first block".
+  function nearestBlockDropTarget(clientY) {
+    const els = blockDropCandidates();
+    for (let i = 0; i < els.length; i++) {
+      const r = els[i].getBoundingClientRect();
+      if (clientY < r.top + r.height / 2) {
+        return { mode: 'before-block', blockIndex: i, y: r.top };
+      }
+    }
+    const last = els[els.length - 1];
+    const rect = last ? last.getBoundingClientRect() : contentEl.getBoundingClientRect();
+    return { mode: 'append', y: rect.bottom };
+  }
+
+  // The in-flight ⠿ gesture, or null between gestures — the block-axis
+  // counterpart of `tePointer`. `sourceIndex` is the ORDINAL of the pressed
+  // block AT PRESS TIME, which is the table drop's own rule ("convert the
+  // pressed node to an ordinal first, re-resolve in the live DOM at drop
+  // time"): between the press and the release, resolveGutterOperands()'s
+  // switchAwayFrom() may commit some other dirty burst, re-render, and detach
+  // every node in the document. `dragging` flips true once
+  // TE_DRAG_THRESHOLD_PX is crossed; `dropTarget` is the union above, filled
+  // in by updateBlockDropIndicator() as the pointer moves.
+  let blockDragState = null;
+
+  // Arms the gesture for a press on a ⠿. Returns TRUE when it owns this
+  // pointer, so the `pointerdown` listener below can stop before it reaches
+  // beginShiftClickSelection()/armBlockSelDrag().
+  //
+  // Running FIRST is required and is also free: `.ed-handle` is a member of
+  // ED_SEL_GESTURE_CHROME, so armBlockSelDrag()'s very first line already
+  // returned for exactly this target (and beginShiftClickSelection()'s does
+  // too) — which is why a press on the ⠿ recorded NO pointer state at all
+  // before this task. Nothing about a press anywhere else changes.
+  //
+  // No preventDefault() here, deliberately. wireBlockSelection()'s delegated
+  // `mousedown` preventDefault() on `.ed-handle` is what keeps a dirty
+  // burst's focus intact across a ⠿ press — without it the press blurs the
+  // burst, the blur commits, the commit re-renders, the button is detached
+  // between mousedown and mouseup and the `click` never fires at all (the
+  // swallowed-first-click defect that fix exists for). Cancelling
+  // `pointerdown` additionally suppresses the compatibility `mousedown` in
+  // some engines, i.e. the very event that fix lives on. updateBlockDrag()
+  // does the preventDefault() instead, once the gesture is definitely a drag.
+  function armBlockDrag(e) {
+    const handleEl = e.target && e.target.closest ? e.target.closest('.ed-handle') : null;
+    if (!handleEl) return false;
+    const blockEl = handleEl.closest('.ed-block');
+    if (!blockEl) return false;
+    const index = blockDropCandidates().indexOf(blockEl);
+    if (index < 0) return false;
+    blockDragState = {
+      pointerId: e.pointerId,
+      sourceIndex: index,
+      // Carried for Tasks 3-7's own re-resolution cross-check only; the
+      // ORDINAL above is the identity, for the renumbering reason spelt out
+      // on `blockDragState`.
+      sourceBlockId: blockEl.getAttribute('data-block-id'),
+      startX: e.clientX, startY: e.clientY,
+      dragging: false,
+      dropTarget: null,
+      captureEl: null,
+    };
+    return true;
+  }
+
+  // Repositions the singleton line onto the current drop target. All four
+  // dimensions are written on every move — the node is this gesture's alone
+  // (see the class comment in lib/md2doc.js for why it is not the table's),
+  // but the content column can be resized by a sidebar drag or a window
+  // resize between two frames, so a partially-written box would leave a stale
+  // width behind.
+  function updateBlockDropIndicator(clientY) {
+    const target = nearestBlockDropTarget(clientY);
+    blockDragState.dropTarget = target;
+    const els = blockDropCandidates();
+    const spanEl = target.mode === 'append' ? els[els.length - 1] : els[target.blockIndex];
+    const r = spanEl ? spanEl.getBoundingClientRect() : contentEl.getBoundingClientRect();
+    blockDropIndicator.style.left = r.left + 'px';
+    blockDropIndicator.style.width = r.width + 'px';
+    blockDropIndicator.style.top = (target.y - 1) + 'px';
+    blockDropIndicator.style.height = '3px';
+  }
+
+  // Capture on documentElement at ENGAGE time, not at press time — the S3
+  // selection drag's reasoning (captureBlockSelDrag()) applies verbatim here
+  // and the table's does not. A press on a ⠿ that turns out to be a plain
+  // click must not be interfered with AT ALL: it has to reach `click` and open
+  // the menu. And the pressed node is a per-block button that rerenderAll()
+  // and openRawEditor()'s restore() both re-create, so capturing on it would
+  // pin a node the gesture can outlive.
+  function captureBlockDrag(e) {
+    const el = document.documentElement;
+    if (el && typeof el.setPointerCapture === 'function') {
+      try { el.setPointerCapture(e.pointerId); blockDragState.captureEl = el; }
+      catch (err) { /* not capturable here — the buttons/blur/cancel guards still apply */ }
+    }
+  }
+
+  function releaseBlockDragCapture(st) {
+    if (st && st.captureEl && typeof st.captureEl.releasePointerCapture === 'function') {
+      try { st.captureEl.releasePointerCapture(st.pointerId); } catch (err) { /* already released */ }
+    }
+  }
+
+  function updateBlockDrag(e) {
+    if (!blockDragState || e.pointerId !== blockDragState.pointerId) return;
+    if (tePointer) return; // a grip gesture owns this pointer
+    // The browser can simply never deliver a pointerup (released over browser
+    // chrome, over another window). The next move with no button held is the
+    // only signal left that the gesture is over — the same guard
+    // updateBlockSelDrag() carries, for the same reason.
+    // S4 Task 3: endBlockDrag() is async now. Deliberately not awaited here —
+    // `updateBlockDrag` is called from a `pointermove` listener that cannot
+    // await, and this branch is the last-resort recovery for a pointerup the
+    // browser never delivered. The teardown inside it is synchronous either
+    // way; only the drop's own commit trails.
+    if (typeof e.buttons === 'number' && e.buttons === 0) { endBlockDrag(); return; }
+    if (!blockDragState.dragging) {
+      const dx = e.clientX - blockDragState.startX, dy = e.clientY - blockDragState.startY;
+      if (Math.hypot(dx, dy) < TE_DRAG_THRESHOLD_PX) return;
+      blockDragState.dragging = true;
+      captureBlockDrag(e);
+      blockDropIndicator.hidden = false;
+      // S4 Task 2b (user request, 2026-09-01): the ONLY feedback the source
+      // block gets. `.ed-handle` is `opacity: 0` off-hover, so from the moment
+      // the pointer leaves the block there is nothing under the cursor but the
+      // indicator line. The ruling is a `cursor: grabbing` class on
+      // `document.documentElement` — OUTSIDE `contentEl`, so the "mutate
+      // nothing in the content DOM during a drag" invariant this whole gesture
+      // rests on still holds, and every cancellation path stays unconditional.
+      // The table drag's `ed-te-row-dragging` dim is deliberately NOT the
+      // model: it dims a node INSIDE the content, and the burst's zero-edit
+      // guard compares `contentEl`'s innerHTML, so the residue it leaves had
+      // to be stripped by hand.
+      //
+      // ⚠ CORRECTED (S4 review round, 2026-09-01). The earlier wording here
+      // and in §4.5 said documentElement AVOIDS that `class=""` residue. It
+      // does not. classList.add() on an element with no `class` attribute
+      // CREATES one and remove() only empties its value — measured in the same
+      // Chromium: `<html class="">` after every engaged drag, every time. The
+      // residue is not avoided, it is RELOCATED: `<html>` is a node nothing in
+      // this file compares, `contentEl.innerHTML` is a string the zero-edit
+      // guard reads on every commit. The ruling is unchanged (the cost really
+      // is zero); only its stated reason was wrong.
+      document.documentElement.classList.add(BLOCK_DRAGGING_CLASS);
+      // Nothing else is touched here. The table's hover chrome (insert
+      // bubbles, grips) is hidden by the rAF `mousemove` gate below, which is
+      // where the row drag and the S3 selection drag both do it too; and the
+      // ⠿ / ＋ menus are left alone until endBlockDrag(), because closing one
+      // detaches a node from INSIDE a block and would break the
+      // "nothing is mutated during a drag" invariant this whole gesture rests
+      // on.
+    }
+    e.preventDefault();
+    updateBlockDropIndicator(e.clientY);
+  }
+
+  // Shared teardown. Both exits below go through it, so a future drop added
+  // to endBlockDrag() can never be reached from a cancellation path.
+  function teardownBlockDrag() {
+    if (!blockDragState) return null;
+    const st = blockDragState;
+    blockDragState = null;
+    releaseBlockDragCapture(st);
+    blockDropIndicator.hidden = true;
+    // S4 Task 2b: removed HERE and nowhere else. T2 routed endBlockDrag() and
+    // cancelBlockDrag() through this one function precisely so a later
+    // addition inherits all five abort paths (pointerup, Escape,
+    // pointercancel, window blur, the next pointerdown / every re-render) for
+    // free. Unconditional on `.dragging`: classList.remove() of a class that
+    // was never added is a no-op, and a gesture that ended before the
+    // threshold never added it.
+    document.documentElement.classList.remove(BLOCK_DRAGGING_CLASS);
+    // A gesture that became a drag owns its own trailing `click`: released
+    // outside every block it would reach wireBlockSelection()'s
+    // switchAwayFrom(); released back over the ⠿ it started on it would OPEN
+    // THE MENU the user was not asking for. Same one-shot flag the S3
+    // selection drag sets, re-armed to false by the next pointerdown so a
+    // gesture whose click never arrives cannot swallow a later one.
+    if (st.dragging) blockSelClickSuppressed = true;
+    return st;
+  }
+
+  // The `pointerup` half. S4 Task 3 makes the drop REAL for a single block
+  // that is not a list item; Tasks 4-7 widen it. The teardown above is
+  // synchronous and happens FIRST, so the gesture is already over (indicator
+  // down, capture released, `ed-block-dragging` off <html>) before a single
+  // byte is considered — nothing the commit does can leave drag state behind.
+  //
+  // ASYNC, and the `pointerup` listener awaits it: the drop resolves an open
+  // burst and re-renders, and a fire-and-forget promise would let a test (or
+  // the next gesture) observe the document between the release and the
+  // commit's own /api/render.
+  async function endBlockDrag() {
+    const st = teardownBlockDrag();
+    if (!st || !st.dragging) return;
+    // The menus are closed AFTER the gesture rather than at engage: closing
+    // one detaches a node from inside a block, and mutating nothing during a
+    // drag is what makes every cancellation path above unconditional.
+    closeGutterMenu();
+    closeInsertMenu();
+    await performBlockDrop(st);
+  }
+
+  // ── S4 Task 3: the drop (spec §4.5) ───────────────────────────────────
+  // Everything up to here has been chrome. This is where the ⠿ drag writes
+  // bytes, through the pure commitBlockMove() above: ONE commitRangeEdit over
+  // the min..max span, hence exactly one Ctrl+Z.
+  //
+  // The pressed block is named by ORDINAL, never by node and never by id —
+  // the table drop's own rule. `blockmap.js` renumbers ids 0..n-1 on every
+  // render, so a captured id names the target's NEIGHBOUR after any commit
+  // that changes the block count, and every node in the document is detached
+  // by a re-render. The ordinal is resolved in the LIVE DOM here, before
+  // resolveGutterOperands() is allowed to commit anything.
+  //
+  // The DESTINATION needs the same protection and gets it one step earlier:
+  // its identity is captured BEFORE resolveGutterOperands(), whose
+  // switchAwayFrom() may commit some other block's dirty burst and re-render.
+  // reresolveBlockEl() then proves the block sitting at that start line
+  // afterwards really is the same one, exactly as the source's own re-resolve
+  // does; when it cannot, the gesture is DROPPED with a banner rather than
+  // completed against a block the user did not point at.
+  async function performBlockDrop(st) {
+    const target = st.dropTarget;
+    // ⚠ S4 Task 6 audited this for §3.6 (「靜默不動作是缺陷」) and it is the one
+    // silent exit in this function that NO GESTURE CAN REACH: performBlockDrop()
+    // is called only from endBlockDrag()'s `st.dragging` branch, engaging sets
+    // `dragging` and then calls updateBlockDropIndicator(), which assigns
+    // `dropTarget` UNCONDITIONALLY from nearestBlockDropTarget() — and that
+    // function has no null answer at all, falling through to
+    // `{mode:'append'}` when no block's mid-line is below the pointer. Kept as
+    // a defensive guard, not as a behaviour.
+    if (!target) return; // engaged but never moved onto a target — nothing to do
+    const els = blockDropCandidates();
+    const sourceEl = els[st.sourceIndex];
+    const destEl = target.mode === 'append' ? null : (els[target.blockIndex] || null);
+    if (!sourceEl || (target.mode !== 'append' && !destEl)) {
+      showBanner(DROPPED_GESTURE_MESSAGE, null, null);
+      return;
+    }
+    const destIdentity = destEl ? captureBlockIdentity(destEl) : null;
+    // ...and the SAME question resolveGutterOperands() asks about the source,
+    // asked about the destination, BEFORE the commit that answers it.
+    //
+    // S4 review round (2026-09-01), MEDIUM: a drop onto a block with an open
+    // DIRTY burst was ALWAYS refused. Measured on
+    // '# Doc\n\nalpha\n\nbravo\n\ncharlie\n' — type ' EDITED' into
+    // `charlie`, drag `alpha` onto charlie's top edge — and the answer was
+    // '文件已更新，請重試這個操作' with the edit committed and the move not.
+    //
+    // It is an ASYMMETRY, not a race, and it could not be anything else:
+    // reresolveBlockEl()'s fingerprint is the block's SOURCE, and the commit
+    // that changed that source is this drop's OWN resolveGutterOperands() →
+    // switchAwayFrom(). The fingerprint is therefore GUARANTEED to miss. The
+    // source side has had reresolveBlockElAfterSelfCommit() for exactly this
+    // since S2; this is its destination-side counterpart, gated the same way
+    // — on ownsOpenSession() read BEFORE the commit, because `currentBurst` is
+    // gone afterwards — so reresolveBlockEl() keeps its fingerprint for
+    // everybody else. Deliberately NOT a widening of that function: S2's own
+    // note says the narrowed variant exists precisely so no other caller loses
+    // the fingerprint.
+    const destSelfSession = destEl ? ownsOpenSession(destEl) : false;
+    // The shared gutter preamble — identity capture, switchAwayFrom(), the
+    // re-resolve after a commit that re-rendered, the no-source-line refusal
+    // and §3.3's membership. Not re-implemented here: 「不得另寫一條」.
+    const operands = await resolveGutterOperands(sourceEl);
+    if (!operands) return;
+    let liveDestEl = destEl;
+    if (destEl && !document.body.contains(destEl)) {
+      liveDestEl = reresolveBlockEl(destIdentity) ||
+        (destSelfSession ? reresolveBlockElAfterSelfCommit(destIdentity) : null);
+      if (!liveDestEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    }
+    // ── S4 Task 6: THE OPERAND SET (spec §4.5, §3.3, §3.6) ────────────────
+    // §4.5: 「grip 在選取集合內 → 整批搬（3.3 的成員資格規則）」. Up to Task 5
+    // this read `if (operands.batch) return;` — the last two SILENT shapes in
+    // the drag path, which §3.6 calls a defect in so many words
+    // (「靜默不動作是缺陷」). From here down `opEls` is a span of one OR MORE
+    // blocks and every path takes it whole; nothing loops over it, for the
+    // reason convertBlockViaMenu() states — a commit between two members
+    // re-renders and invalidates every id in between.
+    const opEls = operands.els;
+    const opRecs = operands.recs;
+    // ── the FIRST home position, and it is shared by every kind and size ──
+    // A drop that lands where the block already is is a silent byte no-op —
+    // NOT a refusal and NOT a dropped gesture. It has to be answered before
+    // every gate, and MEASURED, because the gates get it wrong on their own:
+    // `before-block <sourceIndex>` — released on the block's own top edge,
+    // which is exactly what the drag's "released where it started" scenario
+    // drives — makes the destination the SOURCE, and the destination's index
+    // in the source-less array below is then -1, i.e. the
+    // '文件已更新，請重試這個操作' banner, for a gesture in which nothing
+    // whatsoever went wrong. Caught by driving a real gesture and reading the
+    // banner back; the byte assertions could not see it, because the file is
+    // untouched either way. For a SET the same question is membership: any
+    // member's top edge is the set's own footprint. The li path below has a
+    // SECOND home position of its own — see performListItemDrop().
+    if (liveDestEl && opEls.indexOf(liveDestEl) !== -1) return;
+    const shape = spanListKinds(opEls);
+    // §3.6's 2026-08-31 ruling, and the EXISTING banner: 「混合 span 一律拒絕」.
+    // A mixed span would need a blank-line rule at the run/non-run seam — the
+    // li half has to stay tight while the non-li half has to keep its
+    // separators, and inside ONE commit range those two demands conflict. §3.6
+    // records that the spec does not have that rule and that inventing it in
+    // the last stage repeats the §3.4 marker-width error, so this refuses with
+    // 建立副本 / 刪除 / 轉換's own message rather than a fifth move message.
+    //
+    // DELIBERATELY ABOVE the second home position, which is the one place this
+    // function departs from Task 3's "answer a home position before every
+    // gate" rule, and the departure is the point: a seam objection depends on
+    // where the user AIMED, so refusing a put-it-back gesture with one would
+    // be a banner for a gesture in which nothing went wrong. MIXED is a
+    // property of the SET — it gives the same answer at every destination, so
+    // there is no aim that would have worked and saying so is the honest
+    // outcome. (The drop-on-a-member case is already out, above.)
+    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+    // S4 Task 4 / Task 6: a li source has its own path. Its lines cannot be
+    // relocated verbatim (markers and ordinals are run-global), so the whole
+    // run is re-serialized in the new span order instead — still ONE
+    // commitRangeEdit, still one Ctrl+Z. `shape.allLi` rather than the first
+    // member's type: a set is all-li or it is mixed, and mixed is already out.
+    // Everything below this line is the non-li move.
+    if (shape.allLi) {
+      await performListItemDrop(opEls, liveDestEl);
+      return;
+    }
+    // ── the SECOND home position, still before every gate ──────────────
+    // `before-block <sourceIndex + 1>` — the seam immediately below, the same
+    // position on screen — is a no-op planBlockMove() answers null for, but
+    // the list-seam gate below would have refused it OUT LOUD first whenever
+    // the block sits between two list items. (The first home position is
+    // answered above, before the li branch, because both kinds share it.)
+    const live = blockDropCandidates();
+    // The set's own two edges. `si` is its FIRST member and `sj` its LAST —
+    // the source seam is what stands OUTSIDE those, and asking `si + 1` for it
+    // would name the set's second member on any set of more than one.
+    const si = live.indexOf(opEls[0]);
+    const sj = live.indexOf(opEls[opEls.length - 1]);
+    const rest = live.filter((el) => opEls.indexOf(el) === -1);
+    const di = liveDestEl ? rest.indexOf(liveDestEl) : rest.length;
+    if (si < 0 || sj < 0 || di < 0) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    // §3.3's set is contiguous in block order — resolveGutterOperands()'s own
+    // gate — so its members' lines plus the separators between them are ONE
+    // range, which is what makes a batch move the same single commitRangeEdit
+    // (and the same single Ctrl+Z) a one-block move is. See spanMoveRange().
+    const srcRec = spanMoveRange(opRecs);
+    const destRec = liveDestEl ? blockRecOf(liveDestEl) : null;
+    if (!srcRec || (liveDestEl && !destRec)) {
+      showBanner(DROPPED_GESTURE_MESSAGE, null, null);
+      return;
+    }
+    // A destination that owns no source line has an INVERTED range, and its
+    // startLine names the line its OWNER occupies — inserting there would put
+    // the block inside somebody else's territory.
+    //
+    // ⚠ S4 Task 6 MEASURED that this is REACHABLE, and that Task 3's comment
+    // here ("unreachable while the seam gate below holds") was wrong. It said
+    // so on the grounds that every no-line phantom this model produces is a
+    // li — true, and beside the point: the seam gate refuses a destination
+    // whose BOTH neighbours are li of one run, and a phantom's upper
+    // neighbour is very often not a li at all. Driven as a real gesture on
+    // '# Doc\n\npara\n\n- - b\n- c\n\ntail\n' (blockmap:
+    // heading{1,1} | para{3,3} | li{5,4} PHANTOM | li{5,5} | li{6,6} |
+    // para{8,8}): the phantom has a box of its own (measured top 190,
+    // bottom 215 at 1400x900), so nearestBlockDropTarget() names it like any
+    // other block; `rest[di - 1]` is the PARAGRAPH, so blockMoveSeamRefusal()
+    // answers null; and planBlockMove() answers a REAL plan for it
+    // ('# Doc\n\npara\n\ntail\n\n- - b\n- c\n'), so it is not a home
+    // position either. Dragging `tail` onto that phantom therefore did
+    // nothing, wrote nothing and said nothing — §3.6's 「靜默不動作是缺陷」,
+    // and the third silent shape this task owed on top of the two the plan
+    // named.
+    //
+    // The banner is the DESTINATION seam's, not a fifth constant: the line
+    // this drop names belongs to the phantom's own nested item, so the block
+    // really would land between an item and its sublist, which is exactly
+    // what 無法把區塊放進清單項目之間 says. The remedy it gives (aim
+    // somewhere else) is the correct one.
+    if (destRec && destRec.endLine < destRec.startLine) {
+      refuseStructuralListEdit(BLOCK_MOVE_DEST_SEAM_MESSAGE);
+      return;
+    }
+    // The second home position (see above): `null` means "already there".
+    // Asked BEFORE the seam gate so a put-it-back gesture is silent rather
+    // than refused. planBlockMove() is pure, so asking twice costs nothing.
+    if (!planBlockMove(lines, blocks, srcRec, destRec)) return;
+    // Both seams MEASURED with marked.lexer, not reasoned about:
+    //   destination — '# Doc\n\npara\n\n- a\n- b\n\ntail\n' with `para`
+    //     spliced between the two items lexes as list(1 item) | paragraph |
+    //     list(1 item): ONE two-item run became TWO one-item runs, and the
+    //     blank lines rule 3 emits are §4.3's looseness trap;
+    //   source — '# Doc\n\n- a\n\npara\n\n- b\n' with `para` lifted out
+    //     leaves '- a\n\n- b\n', which lexes as ONE list, loose === TRUE.
+    //     Every item then renders as <p>, serializeBlocks() reports 'P' for
+    //     each, and the whole run degrades read-only WITH NO BANNER.
+    // S4 Task 5 NARROWED the destination half of this and deliberately left
+    // the source half wide; blockMoveSeamRefusal()'s own header carries the
+    // full enumeration and the measurement behind every row of it. The short
+    // version: an insertion can only SPLIT, so the destination only has to
+    // refuse a seam INSIDE one run; a removal MERGES, and the model does not
+    // carry the raw bytes (the bullet character, the leading two spaces) that
+    // decide whether two runs about to become adjacent stay two lists.
+    //
+    // The descriptor is built from listRunOf() — §3.4 rule 2's scope — so a
+    // nested child and its parent answer the same run key, which is what
+    // stops "a paragraph dropped between an item and its own sublist" from
+    // reading as a boundary between two separate lists.
+    const seamDesc = (el) => {
+      if (!el || !el.getAttribute || el.getAttribute('data-block-type') !== 'li') return null;
+      const r = listRunOf(el);
+      return { runKey: r.length ? r[0].getAttribute('data-block-id') : null };
+    };
+    const seamRefusal = blockMoveSeamRefusal(
+      { prev: seamDesc(live[si - 1]), next: seamDesc(live[sj + 1]) },
+      { prev: seamDesc(rest[di - 1]), next: seamDesc(rest[di]) });
+    if (seamRefusal === 'source') {
+      refuseStructuralListEdit(BLOCK_MOVE_SOURCE_SEAM_MESSAGE);
+      return;
+    }
+    if (seamRefusal === 'destination') {
+      refuseStructuralListEdit(BLOCK_MOVE_DEST_SEAM_MESSAGE);
+      return;
+    }
+    const result = commitBlockMove({ lines, blocks, stack }, srcRec, destRec);
+    // commitRangeEdit()'s own unchanged-text answer, or a refused inverted
+    // range. Neither pushed an op, so there is nothing to render or roll back.
+    //
+    // ⚠ S4 Task 6 audited this too, and corrected Task 3's claim that neither
+    // is reachable. The inverted-range half is not (planBlockMove() has
+    // already answered a real plan). The UNCHANGED-TEXT half is: MEASURED on
+    // 'same\n\nsame\n\ntail\n' with the first paragraph moved past the
+    // second, planBlockMove() answers a genuine plan and the text it produces
+    // is the file byte-for-byte, because the two blocks are identical. That
+    // is a real byte no-op — the document after the gesture IS the document
+    // before it — so it stays silent for Task 3's own reason. A banner here
+    // would tell a user that a move they can SEE succeeded had failed.
+    if (!result.op) return;
+    const prevLines = lines;
+    lines = result.lines;
+    // §3.3's collapse, declared IMMEDIATELY before the render and never
+    // earlier: the moved block's range in the NEW document, which is where a
+    // standing selection must end up. declareCollapse()'s own `if
+    // (blockSelection)` guard is what stops this single-block gesture from
+    // INVENTING a selection when none was standing.
+    declareCollapse(result.newRange);
+    const okRender = await safeRerenderAll();
+    if (!okRender) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
+  // ── S4 Task 4: the drop of a LIST ITEM, inside its own run (spec §4.5) ──
+  //
+  // Task 3's drop returned SILENTLY for a li. §3.6 is explicit that
+  // 「靜默不動作是缺陷」, so after this function a li drag either MOVES or
+  // refuses WITH A BANNER; the only silent outcome left is a home position,
+  // which is Task 3's own ruling (a drop where the block already is is a byte
+  // no-op, not a refusal) and is answered in two places here.
+  //
+  // THE SHAPE IS duplicateListItems()'s, and the recon named it as the only
+  // existing path that already expresses a reorder as ONE commit:
+  //   * capture `presetRange` BEFORE mutating — runRangeOfBlocks() takes the
+  //     FIRST and LAST members of the array it is handed on the written
+  //     assumption that the array is in DOCUMENT order, which the reordered
+  //     span is not;
+  //   * build the REORDERED SPAN ARRAY (serializeBlocks() emits in array
+  //     order, and rebuilds its width/counter/type stacks as it walks — the
+  //     output is entirely determined by that order);
+  //   * mutateListRun() to move the node, with the focusout suppressed;
+  //   * commitListStructure(span, …, {presetRange, carryOver}), where
+  //     `carryOver` is bystanderCarryOver(span) — built AFTER the reorder and
+  //     BEFORE `blocks` is rebuilt — so every block's ORIGINAL bytes are
+  //     replayed by id and nothing is re-escaped ('~5px' would otherwise come
+  //     back '\~5px'). Only the marker and the leading columns are re-stated,
+  //     which is exactly §3.8's renumbering and §3.4's colDelta.
+  // One commitRangeEdit inside commitListStructure() is one undo op, which is
+  // §3.4's requirement for one gesture.
+  //
+  // `data-list-start` is a POSITION property, not an item property. It is the
+  // only carrier of "marked's lexer opened a list token here" (§3.8 rule (d))
+  // and serializeBlocks() resets its ordinal counter on it, so a reorder that
+  // changes which item stands FIRST has to carry it across — the mirror image
+  // of duplicateListItems() stripping it from a copy. MEASURED, on
+  // '1. alpha / 2. bravo / 3. charlie' with charlie dragged to the head:
+  // without the transfer the attribute stays on `alpha`, which is now the
+  // span's SECOND block, and the run comes back
+  // '1. charlie / 1. alpha / 2. bravo'.
+  //
+  // SCOPE — and it is exactly the task's title, "within its own run". The
+  // destination must be a slot between the item's own §3.8 RUN SIBLINGS, or
+  // the slot immediately past the last of them. Everything else is a
+  // cross-boundary move: out of the list entirely, into a nested sublist, into
+  // a different run. Task 5 owns that enumeration and the ruling it implements
+  // is already made — refused with a banner in 3.0.0 — so they are refused
+  // here with Task 5's own constant rather than half-implemented.
+  //
+  // S4 Task 6 widened `liEl` to `liEls` — §3.3's operand set, one OR MORE list
+  // items in document order. The whole function is the same commit: the set is
+  // contiguous in block order (resolveGutterOperands()'s gate), and `run` is a
+  // contiguous slice of the document (listRunOf()'s own contract), so the
+  // members occupy CONSECUTIVE slots of `run` and "move them" is one call to
+  // reorderSpanRange() with a count instead of two paths.
+  async function performListItemDrop(liEls, destEl) {
+    const liEl = liEls[0];
+    const lastLiEl = liEls[liEls.length - 1];
+    // §3.4 rule 2's scope, and the span commitListStructure() re-serializes:
+    // the OUTERMOST run reachable from this item plus every descendant of its
+    // members. Not the item's own sibling run — a span that STARTS at indent 2
+    // has no width recorded for depths 0 and 1 and would be emitted with no
+    // indent prefix at all, i.e. committing it would de-nest the whole thing.
+    const run = listRunOf(liEl);
+    const srcIdxs = liEls.map((el) => run.indexOf(el));
+    const srcIdx = srcIdxs[0];
+    if (srcIdx < 0) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    // A member outside the grip's own commit span means the set straddles TWO
+    // runs — contiguity in `blocks` does not imply one run, because two
+    // adjacent runs separated by a delimiter change ('- a' / '1. b') are
+    // adjacent blocks with no phantom between them. Same answer
+    // convertBlockViaMenu() gives, through the same message: the commit
+    // re-serializes ONE run's line range and a member outside it would be
+    // rewritten by a range that does not cover it.
+    if (srcIdxs.indexOf(-1) !== -1) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); return; }
+    // ...and they must be CONSECUTIVE slots of it. Guaranteed today by
+    // spanIsContiguous() plus listRunOf() returning a contiguous slice, and
+    // checked anyway rather than asserted in prose: reorderSpanRange() takes a
+    // `from` and a `count`, so a gap here would silently drag a NON-member
+    // along with the set.
+    for (let k = 1; k < srcIdxs.length; k++) {
+      if (srcIdxs[k] !== srcIdxs[k - 1] + 1) { refuseStructuralListEdit(BATCH_GAP_MESSAGE); return; }
+    }
+    const all = blockDropCandidates();
+    // ── the SECOND home position ───────────────────────────────────────
+    // `before-block <sourceIndex + 1>` is the seam immediately below the item,
+    // which is the same place on screen as its own top edge. For an item WITH
+    // CHILDREN that next block is its own first child, and "before my own
+    // first child" is precisely where it already is; for the run's LAST item
+    // it is the block AFTER the run, which must be read as "already there"
+    // and not as a boundary crossing. Answered before every gate, for Task 3's
+    // reason: a refusal here would be a banner for a gesture in which nothing
+    // went wrong.
+    const afterSrcEl = all[all.indexOf(lastLiEl) + 1] || null;
+    if (destEl ? destEl === afterSrcEl : all[all.length - 1] === lastLiEl) return;
+    // ── §4.3's run-wide gate ───────────────────────────────────────────
+    // 「轉換／建立副本／刪除／拖曳一律在 mutation 前走
+    // listRunSupportsStructuralEdit()」. There is no shared helper — the four
+    // existing call sites each make the call themselves — so this one does
+    // too. Its input is §3.4 rule 2's scope, which is exactly what listRunOf()
+    // returns. Ahead of every OTHER refusal, the convention convertBlockViaMenu()
+    // states: a run that cannot be structurally edited at all must say so,
+    // rather than report whichever narrower objection is asked next.
+    //
+    // `columnOnly` is the honest option, and it is the same argument
+    // insertBlockBelow()'s li path and the rule-2 merge already make: a
+    // reorder rewrites NO item's CONTENT and NO item's LINE COUNT. The only
+    // bytes that move in any member are its marker and its leading columns —
+    // §3.8's renumbering, applied to a replayed bystander as §3.4's colDelta —
+    // which is the criterion listRunSupportsStructuralEdit() documents.
+    // Without it a single hard-wrapped item anywhere in the run would veto
+    // every drag, which on this repo's own CHANGELOG.md is every run (80.6% of
+    // its list items are hard-wrapped).
+    if (!listRunSupportsStructuralEdit(run, null, { columnOnly: true })) {
+      refuseStructuralListEdit();
+      return;
+    }
+    // ── the destination must be a slot in the item's OWN §3.8 run ──────
+    // `sibs` is that run: the same-depth members listRunOf() walked out from.
+    // The two legal shapes are "before sibling S" and "past the last
+    // sibling's whole subtree" — the latter being the ONLY way to name the
+    // end of a run that something follows, since the drop target can only ever
+    // name a block, and the block it names there is outside the run.
+    const sibs = runBlocksOf(liEl);
+    const lastSib = sibs[sibs.length - 1];
+    const sibTail = subtreeBlocksAfter(lastSib, Number(lastSib.getAttribute('data-indent')) || 0);
+    const runEndEl = sibTail.length ? sibTail[sibTail.length - 1] : lastSib;
+    const afterRunEl = all[all.indexOf(runEndEl) + 1] || null;
+    let insertAt = -1;
+    if (destEl === null) {
+      // The {mode:'append'} target is "after the document's last block", so it
+      // names the end of this run only when the run ends the document.
+      if (afterRunEl === null) insertAt = run.indexOf(runEndEl) + 1;
+    } else if (sibs.indexOf(destEl) !== -1) {
+      insertAt = run.indexOf(destEl);
+    } else if (destEl === afterRunEl) {
+      insertAt = run.indexOf(runEndEl) + 1;
+    }
+    // All four out-of-run shapes land here: a slot between two non-li, a
+    // DIFFERENT run, the middle of a run of another list type, and the
+    // {mode:'append'} target when a block follows the run. Task 5 gave them
+    // their own message — the remedy is "stay inside your own list", which
+    // neither seam message says.
+    if (insertAt < 0) { refuseStructuralListEdit(BLOCK_MOVE_OUT_OF_RUN_MESSAGE); return; }
+    // `null` is the order-is-unchanged answer — the two home positions above
+    // reach this by another road (an item whose next block is a sibling), and
+    // it stays SILENT for the same reason.
+    const order = reorderSpanRange(run.length, srcIdx, srcIdxs.length, insertAt);
+    if (!order) return;
+    // Captured BEFORE the reorder, and this is the whole reason duplicateListItems()
+    // captures it too: runRangeOfBlocks() reads the first and last members of
+    // the ARRAY, and the reordered span's first member is not the run's first
+    // line.
+    const range = runRangeOfBlocks({ lines, blocks, stack }, run);
+    if (!range) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    const span = order.map((i) => run[i]);
+    // ── THE SEAM TASK 7 OWNS — §4.5's indent clamp ─────────────────────
+    //
+    // §4.5: the moved item keeps its own `data-indent` (nothing here writes
+    // one) and 「子項留在原地（依 3.4 位移夾取）」 — the children it leaves
+    // behind are re-anchored by §3.4.
+    //
+    // THE MEASUREMENT THIS IS BUILT ON, and it is the correction of Task 4's.
+    // Task 4 measured that handing `applyIndentClamp()` the REORDERED span
+    // clamps nothing — true, and for a reason that names its own remedy:
+    // rule 2's scope starts after the operated block's NEW index, while the
+    // orphans are left behind at its OLD one. A move IS a REMOVAL at the old
+    // index plus an INSERTION at the new one, so the orphans are the removal's
+    // business and `{ removed: true }` — the mode the ⠿ delete has used since
+    // S1 — is exactly the right question, asked of `run` in DOCUMENT order
+    // (which it still is: nothing has touched the DOM yet). `clampIndents()`
+    // reports no indent for a removed block, so the travelling members' own
+    // depths are never rewritten by this; the reorder below then re-inserts
+    // them at the destination unchanged. NOTHING in indent-clamp.js changed,
+    // no new mode, no §3.4 amendment.
+    //
+    // Two things the sweep settled that prose could not (every legal indent
+    // array of length 2..6 and depth 0..3 × every operand-set size × every
+    // destination the gate above admits = 4067 drops; the pin is in
+    // test/editor-client.test.js):
+    //
+    //  1. §4.5 also says the moved block is 「落點使其非法時夾到合法值」. That
+    //     has NO reachable case: 0 of the 4067 leave the moved block's own
+    //     indent illegal, because the destination gate above only ever admits
+    //     a slot among its own same-depth siblings and the block standing
+    //     before such a slot can always parent it. If that gate is ever
+    //     widened (3.1.0) this becomes owed — and rule 1 of clampIndents()
+    //     already answers it, on the span, at the new index.
+    //  2. The clamp does not answer everything. 14 of the 4067 stay
+    //     unanchored, all of them BATCH sets whose last member is SHALLOWER
+    //     than the block they land before — the INSERTION half, at the new
+    //     index, for which §3.4 has no rule. Those keep Task 4's refusal,
+    //     narrowed to them and re-worded with it.
+    //
+    // ORDER MATTERS: compute, judge, and only then write. A refusal that has
+    // already written `data-indent` leaves a half-clamped DOM behind on a
+    // gesture that wrote no bytes — the same screen/model disagreement the
+    // clamp exists to prevent, produced by the clamp itself.
+    const clamp = computeIndentClamp(run, liEls, spanMinIndent(liEls), { removed: true });
+    const clamped = new Map();
+    (clamp || []).forEach((r) => { clamped.set(r.el, r.indent); });
+    if (!spanIndentsAreAnchored(span.map((el) => ({
+      type: el.getAttribute('data-block-type') === 'li' ? 'li' : 'other',
+      indent: clamped.has(el) ? clamped.get(el)
+        : (Number(el.getAttribute('data-indent')) || 0),
+    })))) {
+      refuseStructuralListEdit(BLOCK_MOVE_ORPHAN_MESSAGE);
+      return;
+    }
+    // S4 review round (2026-09-01): this WRITE is load-bearing, and it took a
+    // measurement to show it. Deleting the line left all 39 S4 scenarios green
+    // — the four T7 ones named after the clamp included — because every one of
+    // them moves a SINGLE item, and for `count === 1` the write can never
+    // change a byte: serializeBlocks() rebuilds its width stack as it walks
+    // (`widths.length = indent + 1` after every block), so an over-deep
+    // `data-indent` is emitted at its anchor's own column, which is the column
+    // the clamp would have written. Re-run over the whole 4067-drop space with
+    // the real serializeBlocks() on both sides: 0 single-item drops differ, 53
+    // BATCH drops differ on a `ul` and 123 on an `ol`. The smallest is indents
+    // 0,0,1,2,1 with {1,2} moved past the run — without the write the orphan
+    // that kept its departed parent's depth is ADOPTED by a block the user
+    // never touched, which is rule 3's own worked failure. Pinned as bytes by
+    // the RV2 runtime scenario and as counts in test/editor-client.test.js.
+    writeIndentClamp(clamp);
+    const sibsAfter = span.filter((el) => sibs.indexOf(el) !== -1);
+    mutateListRun(() => {
+      // `data-list-start` follows the run's HEAD, not the item — see this
+      // function's own header for the measured '1. charlie / 1. alpha' that
+      // dropping this produces. Only the moved item can change which sibling
+      // stands first, so this is the only pair that can need it; a NESTED
+      // run's own list-start belongs to a member nothing moved and is left
+      // exactly where it is.
+      if (sibsAfter[0] !== sibs[0] && sibs[0].getAttribute('data-list-start') === '1') {
+        sibs[0].removeAttribute('data-list-start');
+        sibsAfter[0].setAttribute('data-list-start', '1');
+      }
+      // `insertAt` indexes `run`, which is still in document order at this
+      // point — the DOM has not been touched yet. `insertAt === run.length`
+      // cannot be the moved item's own slot (that is the home position, out
+      // above), so the reference node is safe to read off the run's last
+      // member.
+      const refEl = insertAt < run.length ? run[insertAt] : run[run.length - 1].nextSibling;
+      // In the set's OWN order, each before the same reference node: that
+      // leaves them consecutive and in document order at the destination,
+      // which is what reorderSpanRange() already said the span would be. A
+      // loop that inserted each before the PREVIOUS one would reverse the set.
+      liEls.forEach((el) => { el.parentNode.insertBefore(el, refEl); });
+    });
+    // AFTER the reorder and BEFORE `blocks` is rebuilt, which is the window
+    // bystanderCarryOver() documents. No `mutatedEl`: nothing in this span had
+    // its CONTENT rewritten — the map is what keeps every member byte-
+    // identical to the file, the moved one included.
+    const carryOver = bystanderCarryOver(span);
+    // §3.3's collapse, declared immediately before the render inside
+    // commitListStructure(). declareCollapse()'s own `if (blockSelection)`
+    // guard is what stops this single-block gesture from INVENTING a
+    // selection when none was standing; when one WAS, resolveGutterOperands()
+    // has already collapsed it onto this item, so it has to follow the item
+    // to its new lines.
+    declareCollapse(movedLiRangeAfterReorder(span, liEls, carryOver, range));
+    await commitListStructure(span, null, false,
+      { presetRange: range, carryOver: carryOver });
+  }
+
+  // The moved item's line range in the run AS IT IS ABOUT TO BE COMMITTED.
+  //
+  // Deliberately NOT runLineOfBlock(), and this is a measurement that
+  // contradicts the obvious reuse: that function derives the run's start line
+  // with runRangeOfBlocks(runEls), which takes the FIRST member of the array —
+  // correct for every existing caller, whose array is in document order, and
+  // wrong here by construction, because the reordered span's first member is
+  // whichever item was just moved to the head. The rest of its arithmetic is
+  // reproduced: `lineMeta` carries one entry per EMITTED line naming the block
+  // that owns it, so a block's range is the run of entries bearing its id —
+  // counted, never assumed to be one, because a hard-wrapped item replays
+  // several.
+  //
+  // S4 Task 6: `liEls` is §3.3's operand set, one or more. The members travel
+  // together and stay consecutive, so their emitted lines are one contiguous
+  // run and the answer is the FIRST line of the first member to the LAST line
+  // of the last — which is exactly §3.3's 「操作結果所涵蓋的行區間」. Taking
+  // the first member's range alone would collapse a three-block drag onto one
+  // tinted block.
+  function movedLiRangeAfterReorder(span, liEls, carryOver, range) {
+    const ids = liEls.map((el) => el.getAttribute('data-block-id'));
+    if (ids.indexOf(null) !== -1) return null;
+    const { lineMeta } = listMd.serializeBlocks(span, { carryOver: carryOver || null });
+    let first = -1;
+    let last = -1;
+    lineMeta.forEach((m, i) => {
+      if (ids.indexOf(m.blockId) === -1) return;
+      if (first < 0) first = i;
+      last = i;
+    });
+    if (first < 0) return null;
+    return { startLine: range.startLine + first, endLine: range.startLine + last };
+  }
+
+  // Unconditional teardown of the in-flight ⠿ gesture — called from FIVE
+  // places, exactly mirroring cancelTeDrag()'s own list: the Escape
+  // prologue's first rungs, `pointercancel`, window `blur`, the defensive
+  // clear at the top of the next `pointerdown`, and every re-render path
+  // (rerenderAll() / resolveBurst()). Nothing was mutated, so there is
+  // nothing to revert and no state this is unsafe to be called from — the
+  // null-out is unconditional on `blockDragState` being set and is NOT gated
+  // on `.dragging`, which is the review fix cancelTeDrag() carries too (a
+  // burst resolution landing during the pressed-but-pre-threshold window used
+  // to leave the table's state pointing at a row rerenderAll() was about to
+  // detach).
+  function cancelBlockDrag() {
+    teardownBlockDrag();
+  }
+
   document.addEventListener('pointerdown', (e) => {
     if (e.button !== 0) return;
     if (e.target.closest && e.target.closest('.ed-te-menu')) return; // the menu's own buttons handle themselves
@@ -5924,6 +8370,16 @@
     // capture) BEFORE starting a new one, so a stuck drag can never survive
     // into the next gesture and a fresh pointerdown always starts clean.
     if (tePointer) cancelTeDrag();
+    // S4 Task 2: same defensive reasoning again for the ⠿ block drag — a prior
+    // gesture whose pointerup/pointercancel never arrived must not survive into
+    // this one. Nothing was mutated, so this is always a clean no-op teardown.
+    if (blockDragState) cancelBlockDrag();
+    // S3 Task 4: same defensive reasoning one line up, for the block-selection
+    // press — and the flag that suppresses a gesture's own trailing click is
+    // re-armed here so a gesture whose click never arrived cannot swallow the
+    // next one.
+    blockSelClickSuppressed = false;
+    if (blockSelDrag) endBlockSelDrag();
     const hit = hitTestGrip(e.target);
     // A click on a DIFFERENT zone (or entirely outside any zone) dismisses
     // whatever menu is already open, same "any other click closes the ⠿
@@ -5939,7 +8395,38 @@
     // teMenuKind alone, or that highlight would survive until
     // resolveBurst() instead of clearing on the next click.
     if ((teMenuKind || teHighlightEls.length) && !isSameSelection) hideTableEdgeMenu();
-    if (!hit) return;
+    if (!hit) {
+      // S3 Task 4 (recon hazard 1): this listener already fires on EVERY left
+      // click and is a no-op whenever hitTestGrip() finds nothing — which is
+      // exactly the branch the block-selection gestures belong on. Arming
+      // them HERE, inside the incumbent handler, is what makes "a grip hit
+      // still wins" true by construction: a second, competing pointerdown
+      // listener would have to re-derive the hit test, and would race this
+      // one's menu dismiss above depending on registration order.
+      // S4 Task 2 (spec §4.5): the ⠿ drag arms HERE, ahead of both selection
+      // entries, and claims the pointer when it owns it. It has to run before
+      // armBlockSelDrag(), whose first line returns for `.ed-handle` (a member
+      // of ED_SEL_GESTURE_CHROME) — which is why a press on the ⠿ recorded no
+      // pointer state at all before this task. beginShiftClickSelection()
+      // returns for the same target, so ordering it above the Shift branch too
+      // changes nothing for any press that is not on a ⠿: armBlockDrag()
+      // returns false for every other target and falls straight through.
+      //
+      // S4 review round (2026-09-01) — RECORDED, because nobody had. It DOES
+      // change one thing for a press that IS on a ⠿: armBlockDrag() reads no
+      // modifier, so Shift / Ctrl / Alt + ⠿ now starts a drag, where before S4
+      // it did nothing at all until release. KEPT, deliberately: the table's
+      // row and column grips take the pointer with no modifier check either
+      // (see the `if (!hit)` branch's else, below), so a ⠿ that behaved
+      // differently would be the surprise; neither §3.3 nor §4.5 gives a
+      // modified ⠿ press a meaning of its own; and a modified press that never
+      // crosses the threshold still opens the menu, so nothing was taken away.
+      // Pinned by the RV5 scenario in test/editor-client-runtime.test.js.
+      if (armBlockDrag(e)) return;
+      if (e.shiftKey) { beginShiftClickSelection(e); return; }
+      armBlockSelDrag(e);
+      return;
+    }
     e.preventDefault();
     tePointer = { hit, startX: e.clientX, startY: e.clientY, dragging: false,
       pointerId: e.pointerId, captureEl: e.target };
@@ -5989,7 +8476,38 @@
     else updateColDropIndicator(e.clientX);
   });
 
+  // S3 Task 4: the block-selection drag's own pointermove. Registered after
+  // the table drag's (above), and bails while `tePointer` is set, so a grip
+  // gesture is never fought over. Not folded into that listener because its
+  // very first line is `if (!tePointer) return;` — the state this one runs in.
+  document.addEventListener('pointermove', (e) => {
+    updateBlockSelDrag(e);
+  });
+
+  // S4 Task 2: the ⠿ block drag's own pointermove. Registered alongside the
+  // other two rather than folded into either: the table drag's listener bails
+  // on `!tePointer` (the state this one runs in) and the selection drag's bails
+  // on `!blockSelDrag` (likewise). updateBlockDrag()'s own first lines are the
+  // symmetric bail.
+  document.addEventListener('pointermove', (e) => {
+    updateBlockDrag(e);
+  });
+
   document.addEventListener('pointerup', async (e) => {
+    // S3 Task 4: recon hazard 2 — there is no `mouseup` listener anywhere in
+    // this file, so the block-selection drag ends on the pointer events, the
+    // same skeleton the table drag uses. Before the `!tePointer` bail: a
+    // selection drag is armed precisely when no grip gesture is in flight.
+    endBlockSelDrag();
+    // S4 Task 2: and the ⠿ block drag's. Same placement reasoning as the line
+    // above — a block drag is armed precisely when no grip gesture is in
+    // flight, so it must be ended before the `!tePointer` bail.
+    // S4 Task 3: AWAITED, now that the drop writes. endBlockDrag()'s own
+    // teardown runs synchronously (an async function body runs to its first
+    // await), so the `tePointer` branch below is not reordered around any
+    // state it reads; what the await buys is that the commit and its
+    // re-render are complete before this handler returns.
+    await endBlockDrag();
     if (!tePointer) return;
     const st = tePointer;
     releaseTeCapture(st);
@@ -6035,6 +8553,14 @@
   // actually moved mid-drag, only the indicator line).
   document.addEventListener('pointercancel', () => {
     cancelTeDrag();
+    // S4 Task 2: the same abort ends a ⠿ block drag. Nothing was mutated (only
+    // the indicator moved), so this is the same unconditional cleanup.
+    cancelBlockDrag();
+    // S3 Task 4: the same abort ends a block-selection drag. The selection it
+    // has built so far STANDS (§4.4: nothing but Escape and a plain click
+    // clears) — what must not survive is the live drag, or the next stray
+    // pointer move would keep extending a gesture the user already ended.
+    endBlockSelDrag();
   });
 
   // Review fix (Critical): the whole BROWSER WINDOW losing focus mid-
@@ -6046,6 +8572,13 @@
   // when no gesture is in flight, so this is safe to fire on every blur.
   window.addEventListener('blur', () => {
     cancelTeDrag();
+    // S4 Task 2: same again for the ⠿ block drag — an undeliverable pointerup
+    // is an undeliverable pointerup whichever gesture is holding it.
+    cancelBlockDrag();
+    // S3 Task 4: §4.4 says window blur does NOT clear the selection — but the
+    // drag in flight when focus left is exactly as undeliverable-pointerup as
+    // a row drag's, so it is torn down here too.
+    endBlockSelDrag();
   });
 
   // ── Phase-2 Task 4: floating selection toolbar (bold/italic/code/link) ──
@@ -6386,6 +8919,12 @@
           (e.target.closest('.ed-handle') || e.target.closest('.ed-insert'))) e.preventDefault();
     });
     document.addEventListener('click', async (e) => {
+      // S3 Task 4: the trailing click of a gesture that already answered this
+      // press itself (a drag across a block boundary, a Shift+Click). A drag
+      // released in another block would otherwise hit the §4.4 exit rule
+      // below and clear the set it just built; one released on the page
+      // margin would hit the outside-a-block switchAwayFrom() instead.
+      if (blockSelClickSuppressed) { blockSelClickSuppressed = false; return; }
       if (!e.target || !e.target.closest) { await switchAwayFrom(); closeGutterMenu(); closeInsertMenu(); return; }
       // showBanner() appends `.ed-conflict` to document.body — OUTSIDE any
       // .ed-block — so without this guard a click on the banner's own
@@ -6489,6 +9028,15 @@
       // Any other click closes an already-open ⠿ menu / ＋ menu.
       if (gutterMenuBlockEl) closeGutterMenu();
       if (insertMenuBlockEl) closeInsertMenu();
+      // S3 Task 4, §4.4 exit: a click INSIDE any block, without Shift, clears
+      // the whole set. Deliberately below the ⠿/＋/menu/checkbox branches
+      // above, which all return early — §3.3 decides batch-vs-single by
+      // whether the GRIP is inside the set, so a grip click must not clear it
+      // first. A click OUTSIDE every block is deliberately not an exit: §4.4
+      // lists exactly Escape and this one. clearBlockSelection() steals no
+      // focus (Task 3 carry 7), so the caret still lands where the user
+      // clicked.
+      if (blockSelection && !e.shiftKey && e.target.closest('.ed-block')) clearBlockSelection();
       if (e.target.closest(ED_LIGHTBOX_TARGETS)) return; // let the lightbox open, unchanged
       let blockEl = e.target.closest('.ed-block');
       // v2.11.1: `.ed-block::before` (lib/md2doc.js's editModeLayoutCss) makes
@@ -6589,6 +9137,14 @@
     const r = stack.undo(lines);
     if (!r) return;
     lines = r.lines;
+    // S3 Task 5 (§4.4): undo/redo ALWAYS clears the block selection.
+    // `UndoStack`'s op is exactly {startLine, endLine, before, after}
+    // (lineops.js) and carries no selection state, so there is nothing to
+    // restore a set to — and Task 5's rebuild would otherwise keep the old
+    // line range standing over a document that just changed underneath it.
+    // DECLARED rather than cleared outright so the rollback below leaves a
+    // standing selection alone when the render fails.
+    declareSelectionRange(null);
     const ok = await safeRerenderAll();
     if (!ok) {
       // Reverse the undo attempt: push the op back and restore `lines` to
@@ -6604,6 +9160,7 @@
     const r = stack.redo(lines);
     if (!r) return;
     lines = r.lines;
+    declareSelectionRange(null); // §4.4, same as undo() above
     const ok = await safeRerenderAll();
     if (!ok) {
       // Reverse the redo attempt: pop the op back off and restore `lines`.
@@ -6614,36 +9171,71 @@
 
   // ── global key handling ─────────────────────────────────────────────────
   document.addEventListener('keydown', (e) => {
-    // Task 6: Esc during an in-flight row drag cancels JUST the drag (no
-    // mutation — the row was never actually moved, only the indicator line
-    // tracked the pointer) — a DISTINCT gesture from Esc-reverts-burst
-    // (handleTableCellKeydown() below), which must never fire for this same
-    // keypress. Checked before EVERY other branch (including Ctrl+S) so a
-    // drag in flight always wins the keystroke.
-    if (tePointer && tePointer.dragging && e.key === 'Escape') {
-      e.preventDefault();
-      cancelTeDrag();
-      return;
-    }
-    // Task 6: Esc with the edge menu open closes JUST the menu — same
-    // "intercept before the wys-cell/wys-armed Escape branches" reasoning,
-    // since the cell that was focused (if any) before the menu opened is
-    // still focused underneath it (the menu's own mousedown preventDefault()
-    // never stole focus).
-    // Final review I1: the condition is `(teMenuKind || teHighlightEls.length)`,
-    // NOT `teMenuKind` alone — the exact same widening the pointerdown dismiss
-    // gate already got, and for the same reason: a header grip's click
-    // deliberately produces a highlight with NO menu (its only menu item,
-    // "delete row", cannot apply to a header), so teMenuKind stays null. Gated
-    // on teMenuKind alone, that Esc fell through to handleTableCellKeydown()'s
-    // own Escape branch -> revertTableBurstAndEnd(), throwing away everything
-    // typed into the burst. With a BODY row's menu open the identical keypress
-    // merely closes the menu, so the header row would have been the one place
-    // where dismissing a selection is destructive.
-    if ((teMenuKind || teHighlightEls.length) && e.key === 'Escape') {
-      e.preventDefault();
-      hideTableEdgeMenu();
-      return;
+    // ── S3 §4.4: Escape priority is drag > menu > selection > burst ─────
+    // A new ordered PROLOGUE, not a reshuffle of what follows (§4.4 is
+    // explicit about that). The two target-based short-circuits further down
+    // (.ed-wys-cell, .ed-wys-armed) `return` for EVERY key, so the gutter /
+    // insert menu's own Escape branch — which sits BELOW them — was
+    // unreachable whenever an armed surface held focus. And it always does
+    // while a ⠿ menu is open: wireBlockSelection()'s mousedown
+    // preventDefault() deliberately keeps focus inside the burst so a dirty
+    // block's own ⠿ click cannot race its blur-commit.
+    //
+    // Measured on 2026-08-30 against v2.11.0: typing " EDITED" into a
+    // paragraph, opening its ⠿ menu and pressing Escape reached
+    // handleBurstKeydown() -> revertBurstAndEnd() — the paragraph went back
+    // to "alpha", the uncommitted edit was destroyed, AND the menu stayed on
+    // screen. Exactly inverted from what the user asked for.
+    //
+    // ⚠ CORRECTED 2026-08-31 (review recommendation 6). Until this date the
+    // comment here read "the two Escape branches immediately below ... are
+    // deliberately kept: they still carry their non-Escape duties". They had
+    // none — both were gated on `&& e.key === 'Escape'` and both conditions
+    // are re-asked verbatim in this prologue, which returns, so neither could
+    // ever run again. They have been DELETED and the reasoning they carried
+    // is folded in here, which is where the live checks are:
+    //
+    //   * the row drag wins the keystroke ahead of everything else, Ctrl+S
+    //     included, so a drag in flight is never resolved by a save;
+    //   * the edge-menu condition is `(teMenuKind || teHighlightEls.length)`,
+    //     NOT `teMenuKind` alone. That widening was made in S0 (final review
+    //     I1) for the HEADER grip, whose click deliberately produces a
+    //     highlight with no menu (its only item, "delete row", cannot apply to
+    //     a header), so teMenuKind stays null. Gated on teMenuKind alone the
+    //     Escape fell through to handleTableCellKeydown()'s own Escape branch
+    //     -> revertTableBurstAndEnd(), throwing away everything typed into the
+    //     burst — so the header row would have been the one place where
+    //     dismissing a selection is destructive. Do not narrow it back.
+    //
+    // The `closeGutterMenu()` source-presence guard in
+    // test/editor-client.test.js is NOT affected: it matches the literal
+    // `e.key === 'Escape') { e.preventDefault(); closeGutterMenu();`, which is
+    // the THIRD Escape branch, much further down in this same listener, and
+    // that one is still live for a keystroke this prologue lets through.
+    //
+    // Placement note: this sits ABOVE the `.ed-raw` textarea bail below, which
+    // is where the two now-deleted Escape branches sat too. Harmless for the raw
+    // editor: its own per-instance keydown listener runs in the TARGET phase,
+    // before this document-level one, so its Escape has already been handled;
+    // and the one menu item that opens a raw editor (MD 原始碼) calls
+    // closeGutterMenu() first, so gutterMenuBlockEl is null by then.
+    if (e.key === 'Escape') {
+      if (tePointer && tePointer.dragging) { e.preventDefault(); cancelTeDrag(); return; }
+      // S4 Task 2: the ⠿ block drag gets the same first rung, and for the same
+      // reason — Escape-during-a-drag is a distinct gesture from
+      // Escape-reverts-the-burst, and the drag must be the one that answers.
+      // Mutually exclusive with the rung above (one pointer, one gesture).
+      if (blockDragState && blockDragState.dragging) { e.preventDefault(); cancelBlockDrag(); return; }
+      if (teMenuKind || teHighlightEls.length) { e.preventDefault(); hideTableEdgeMenu(); return; }
+      if (gutterMenuBlockEl || insertMenuBlockEl) {
+        e.preventDefault();
+        closeGutterMenu();
+        closeInsertMenu();
+        return;
+      }
+      if (blockSelection) { e.preventDefault(); clearBlockSelection(); return; }
+      // Nothing above owns this Escape — fall through to the burst
+      // short-circuits below, where Escape-reverts-the-burst still belongs.
     }
 
     if ((e.ctrlKey || e.metaKey) && !e.shiftKey && e.key === 's') {
@@ -6672,8 +9264,30 @@
     // heading/list (Enter is an UNCONDITIONAL <br>, Tab moves the active
     // cell without ending the burst) — handleTableCellKeydown() owns that
     // entire surface, mirroring handleBurstKeydown() just below.
+    // S3: undo/redo is the one pair of keys the two short-circuits below must
+    // NOT claim when there is no burst to own them. resolveBurst()'s zero-edit
+    // path calls endBurstWithoutResolve() and returns WITHOUT re-rendering, so
+    // after a Ctrl+S on an untouched surface `currentBurst` is null while that
+    // surface still holds native focus and its .ed-wys-armed / .ed-wys-cell
+    // class. The next Ctrl+Z then matched a short-circuit, reached
+    // handleBurstKeydown() / handleTableCellKeydown(), and died on their
+    // identical `!currentBurst` bail on the first line — the global undo()
+    // further down was never reached.
+    //
+    // Measured on 2026-08-30 against v2.11.0, for paragraph, li AND table:
+    // type a character, Ctrl+S, click back in, Ctrl+S again (an ordinary habit
+    // keystroke), Ctrl+Z — the file did not change. Pre-existing on main;
+    // fixed here because this is the same dispatch S3 rewrites.
+    //
+    // Deliberately narrow: only the undo/redo keys, and only with no burst.
+    // Every other key on an armed surface keeps going to its burst handler
+    // exactly as before, burst or no burst.
+    const undoRedoKey = (e.ctrlKey || e.metaKey) &&
+      (e.key === 'z' || e.key === 'y' || (e.shiftKey && e.key === 'Z'));
+    const burstOwnsKey = !!currentBurst || !undoRedoKey;
+
     const cellEl = e.target && e.target.closest && e.target.closest('.ed-wys-cell');
-    if (cellEl) {
+    if (cellEl && burstOwnsKey) {
       handleTableCellKeydown(e, cellEl);
       return;
     }
@@ -6684,11 +9298,55 @@
     // preventDefault() for those keys), so nothing below this must run for
     // it either.
     const wysArmedEl = e.target && e.target.closest && e.target.closest('.ed-wys-armed');
-    if (wysArmedEl) {
+    if (wysArmedEl && burstOwnsKey) {
       handleBurstKeydown(e, wysArmedEl);
       return;
     }
 
+    // S3 Task 4, §4.4 entry (c). Deliberately BELOW the two burst
+    // short-circuits above: inside an armed surface (or a table cell)
+    // Shift+↑↓ is the browser's own extend-the-text-selection gesture and
+    // must stay that way. A standing selection's focus holder is a plain
+    // `.ed-block` — neither `.ed-wys-armed` nor `.ed-wys-cell` — so the keys
+    // reach here exactly when block selection is what they can mean.
+    if (e.shiftKey && !e.ctrlKey && !e.metaKey && !e.altKey &&
+        (e.key === 'ArrowDown' || e.key === 'ArrowUp')) {
+      if (stepSelectionFocus(e.key === 'ArrowUp' ? -1 : 1)) { e.preventDefault(); return; }
+    }
+
+    // ── S3 Task 7: §3.5's 選取集合語意 and §3.6's 「Delete 整批刪」 ─────────
+    // Deliberately BELOW the two burst short-circuits, exactly like the
+    // Shift+↑↓ branch above: inside an armed surface Tab indents the caret's
+    // own item and Delete removes a CHARACTER, and inside a table cell Tab
+    // navigates cells — three contracts this must not touch. A standing
+    // selection puts DOM focus on a plain `.ed-block` wrapper, which is
+    // neither `.ed-wys-armed` nor `.ed-wys-cell`, so these keys arrive here
+    // exactly when block selection is what they can mean.
+    //
+    // `blockSelection` is the gate, and it is the whole guard: with no set
+    // standing there is no focus holder either, and every key below behaves
+    // exactly as it did pre-S3.
+    if (blockSelection && !e.ctrlKey && !e.metaKey && !e.altKey) {
+      if (e.key === 'Tab') {
+        // §3.5, in as many words: 必須 preventDefault()，否則 Tab 在 body 上是
+        // 瀏覽器焦點巡覽.
+        e.preventDefault();
+        tabSelection(e.shiftKey ? -1 : 1);
+        return;
+      }
+      // Backspace is the same gesture as Delete, deliberately: with a set
+      // standing, focus is on a block wrapper and not on any text surface, so
+      // neither key can mean "delete a character" — and a user who selected
+      // blocks and reached for Backspace meant the selection. preventDefault()
+      // matters for its own reason here: an unhandled Backspace outside an
+      // editable is history-navigation in some configurations.
+      if (e.key === 'Delete' || e.key === 'Backspace') {
+        e.preventDefault();
+        deleteSelection();
+        return;
+      }
+    }
+
     // v2.11.1 acceptance, escape class A: Tab with NOTHING focused. Every
     // branch above is keyed on the event target being some edit surface, and
     // after a commit / Escape / Ctrl+Z, or a click on a bullet marker or in
@@ -6931,6 +9589,32 @@
         else rowGrip.hidden = true;
         return;
       }
+      // S3 Task 4 (recon hazard 3): a block-selection drag needs the same
+      // gate, for the same reason — this listener keeps firing every frame
+      // regardless, and would repaint the ＋ bubbles and reposition the grips
+      // onto whatever row the cursor is dragging across, on top of the tint.
+      // Both are HIDDEN rather than merely left un-recomputed, so anything
+      // already showing from the frame before the boundary was crossed does
+      // not linger stale for the rest of the gesture.
+      if (blockSelDrag && blockSelDrag.dragging) {
+        hideTableInsertBubbles();
+        hideTableGrips();
+        return;
+      }
+      // S4 Task 2: and a third, in the same shape, for the ⠿ block drag —
+      // without it this listener would keep repainting the ＋ bubbles and
+      // repositioning the grips onto whatever row the cursor is dragging
+      // across, on top of the drop indicator, every frame of the gesture. Both
+      // are HIDDEN rather than merely left un-recomputed, so anything already
+      // showing from the frame before the threshold was crossed cannot linger
+      // stale. Unlike the table gate above there is no "active grip" to spare:
+      // the drag's own handle is a per-block button that the pointer has
+      // already left, and the indicator is the whole of the feedback.
+      if (blockDragState && blockDragState.dragging) {
+        hideTableInsertBubbles();
+        hideTableGrips();
+        return;
+      }
       updateTableInsertBubbles(tbMoveX, tbMoveY, tbMoveTarget);
       updateTableEdgeGrips(tbMoveX, tbMoveY, tbMoveTarget);
     });