@helping-ai-workflow/md2doc 2.11.1 → 2.12.0

package/lib/editor/client.js

@@ -233,6 +233,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 +441,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 +472,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 +480,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 +533,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 +568,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
@@ -611,6 +653,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,10 +1347,26 @@
   // 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.
+  //
+  // 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.
   function applyIndentClamp(spanEls, opBlockEl, opOldIndent, opts) {
     if (!indentClamp || !spanEls || !spanEls.length) return;
-    const opIndex = spanEls.indexOf(opBlockEl);
-    if (opIndex < 0) return;
+    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;
+      opIndex.push(at);
+    }
+    if (!opIndex.length) return;
     const model = spanEls.map((el, i) => ({
       id: i, // index-as-id: the span IS the universe here
       type: el.getAttribute('data-block-type') === 'li' ? 'li' : 'other',
@@ -1596,35 +1665,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 +1847,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 +1866,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 +1887,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 +1918,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 +1974,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 +1989,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 +2437,323 @@
   // 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 = '選取範圍跨越兩個清單，無法整批操作';
+  // 轉換成'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 +2808,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 +2816,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 +2860,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 +2884,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 +2925,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 +2942,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 +3015,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 +3110,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 +3190,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 +3225,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 +3264,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 +3311,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 +3369,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 +3394,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 +3434,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);
     }
@@ -3308,6 +3887,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 +4643,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 +4662,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 +5147,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 +5389,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
@@ -5924,6 +7134,12 @@
     // 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();
+    // 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 +7155,18 @@
     // 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.
+      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 +7216,20 @@
     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);
+  });
+
   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();
     if (!tePointer) return;
     const st = tePointer;
     releaseTeCapture(st);
@@ -6035,6 +7275,11 @@
   // actually moved mid-drag, only the indicator line).
   document.addEventListener('pointercancel', () => {
     cancelTeDrag();
+    // 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 +7291,10 @@
   // when no gesture is in flight, so this is safe to fire on every blur.
   window.addEventListener('blur', () => {
     cancelTeDrag();
+    // 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 +7635,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 +7744,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 +7853,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 +7876,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 +7887,66 @@
 
   // ── 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; }
+      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 +7975,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 +8009,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 +8300,18 @@
         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;
+      }
       updateTableInsertBubbles(tbMoveX, tbMoveY, tbMoveTarget);
       updateTableEdgeGrips(tbMoveX, tbMoveY, tbMoveTarget);
     });