@helping-ai-workflow/md2doc 3.6.1 → 3.8.0

package/lib/editor/client.js

@@ -720,6 +720,7 @@
   const indentClamp = window.md2docIndentClamp;
   const convertMd = window.md2docConvertMd;
   const selectionLib = window.md2docSelection;
+  const cellRangeLib = window.md2docCellRange;
   const historyLib = window.md2docHistory;
   // v3.1.0 Task E: the four Phase-1 modules, injected by server.js ahead of
   // this file. Read the same way every earlier module is — off `window`, not
@@ -5370,6 +5371,9 @@
   const BATCH_GAP_MESSAGE = '選取範圍不連續，無法整批操作';
   const BATCH_MIXED_MESSAGE = '選取範圍同時含有清單項目與其他區塊，無法整批操作';
   const BATCH_MULTIRUN_MESSAGE = '選取範圍跨越兩個清單，無法整批操作';
+  // 刪除's own answer to a mixed span: it accepts one whose lists are all
+  // covered whole (see listsCoveredWhole()), so its refusal names the fix.
+  const BATCH_PARTIAL_LIST_DELETE_MESSAGE = '刪除時清單只選到一部分：請把整個清單選進來，或只選清單項目';
   // S4 Task 5: the ⠿ drag's cross-boundary refusals, one per CAUSE.
   //
   // Task 3 raised all of these with a single provisional constant
@@ -5451,7 +5455,9 @@
   // 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.
+  // Refused with its own banner rather than guessed at -- except by 刪除 when
+  // every list is covered whole, where no survivor exists and the seam
+  // question never arises (see listsCoveredWhole()).
   function spanListKinds(els) {
     const kinds = els.map((el) => el.getAttribute('data-block-type'));
     return {
@@ -5461,6 +5467,20 @@
     };
   }
 
+  // True when every li in `els` belongs to a run (listRunOf(): the outermost
+  // run plus every descendant) whose whole line range lies inside the span
+  // `recs` covers. A nested child is part of its parent's run, so a span that
+  // stops at the parent is partial.
+  function listsCoveredWhole(els, recs) {
+    const lo = recs[0].startLine;
+    const hi = recs[recs.length - 1].endLine;
+    return els.every((el) => {
+      if (el.getAttribute('data-block-type') !== 'li') return true;
+      const range = runRangeOfBlocks({ lines, blocks, stack }, listRunOf(el));
+      return !!range && range.startLine >= lo && range.endLine <= hi;
+    });
+  }
+
   // 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
@@ -6184,7 +6204,15 @@
     const els = operands.els;
     const recs = operands.recs;
     const shape = spanListKinds(els);
-    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+    // A mixed span is deletable exactly when it covers every list it touches
+    // WHOLE: nothing of those lists survives, so there is no run to renumber
+    // or clamp, and the span is one contiguous line range like any non-list
+    // span -- the commitRangeRemoval() branch below, one undo op. A list
+    // covered only in PART would need its survivors re-serialized in the same
+    // commit as the non-list removal, which is still refused.
+    if (shape.anyLi && !shape.allLi && !listsCoveredWhole(els, recs)) {
+      refuseStructuralListEdit(BATCH_PARTIAL_LIST_DELETE_MESSAGE); return;
+    }
     // Fix round 1, item 2: the block immediately ABOVE the span, read out of
     // the PRE-commit `blocks` and carried to the wrapper. It cannot be
     // recovered afterwards from the hole's coordinate — see
@@ -6892,14 +6920,17 @@
   // clone re-serialises the class attribute joined by single spaces — byte-
   // identical to what the renderer emitted — and an attribute left empty is
   // dropped outright (the renderer never emits `class=""`).
+  // .ed-cell-range (the cell-range paint) is stripped for the same reason.
   function burstBaselineHtml(editEl) {
     const html = editEl.innerHTML;
-    if (html.indexOf('ed-te-hl') === -1 && html.indexOf('ed-te-row-dragging') === -1) return html;
+    if (html.indexOf('ed-te-hl') === -1 && html.indexOf('ed-te-row-dragging') === -1 &&
+        html.indexOf('ed-cell-range') === -1) return html;
     const clone = editEl.cloneNode(true);
-    const marked = clone.querySelectorAll('.ed-te-hl, .ed-te-row-dragging');
+    const marked = clone.querySelectorAll('.ed-te-hl, .ed-te-row-dragging, .ed-cell-range');
     Array.prototype.forEach.call(marked, (el) => {
       el.classList.remove('ed-te-hl');
       el.classList.remove('ed-te-row-dragging');
+      el.classList.remove('ed-cell-range');
       if (!el.className) el.removeAttribute('class');
     });
     return clone.innerHTML;
@@ -6969,6 +7000,7 @@
     hideTableGrips();
     hideTableEdgeMenu();
     cancelTeDrag();
+    clearCellRange();
     // S4 Task 2: and an in-flight ⠿ block drag, for the same reason — this
     // resolution is about to commit and re-render whichever block it holds an
     // ordinal into.
@@ -7471,6 +7503,11 @@
     setBlockSelection({ anchorLine: anchorLine, focusLine: focusLine });
   };
   window.__edTestClearSelection = function () { clearBlockSelection(); };
+  window.__edTestCaretAtEdge = function (dir) {
+    const a = document.activeElement;
+    const surface = a && a.closest && a.closest('.ed-wys-armed, .ed-wys-cell');
+    return surface ? caretAtEdge(surface, dir) : null;
+  };
   window.__edTestGetSelection = function () {
     if (!blockSelection) return null;
     const members = selectionLib ? selectionLib.membersOf(blockSelection, blocks) : [];
@@ -8425,6 +8462,24 @@
     // meant here (heading depth / list indent). Set BEFORE the li dispatch
     // below so both surfaces see the same cleared mark.
     if (e.key !== 'Tab' && e.key !== 'Shift') currentBurst.arrivedByTab = false;
+    // Arrow walk: ↑ on the first line / ↓ on the last line crosses into the
+    // neighbouring block. Anywhere else — and with any modifier, a
+    // non-collapsed selection or an IME composition — the browser's own move.
+    if ((e.key === 'ArrowUp' || e.key === 'ArrowDown') && !e.shiftKey && !e.ctrlKey &&
+        !e.altKey && !e.metaKey && !e.isComposing) {
+      const dir = e.key === 'ArrowUp' ? -1 : 1;
+      if (caretAtEdge(editEl, dir < 0 ? 'up' : 'down')) {
+        const fromBlockEl = editEl.closest('.ed-block');
+        const step = (el) => (dir > 0 ? el.nextElementSibling : el.previousElementSibling);
+        let probe = fromBlockEl ? step(fromBlockEl) : null;
+        while (probe && !probe.classList.contains('ed-block')) probe = step(probe);
+        if (probe) {
+          e.preventDefault();
+          walkToAdjacentBlockByArrow(fromBlockEl, dir, caretClientX());
+        }
+        return;
+      }
+    }
     // Task 8 (Phase 4): per-li burst — Enter / Shift+Enter / Tab / Shift+Tab
     // are owned by handleLiKeydown() below (spec §4's key semantics for li
     // surfaces, acceptance rows 1, 3, 5, 6, 7, 8). Every other key (Escape,
@@ -9724,6 +9779,656 @@
     await walkToAdjacentBlockByTab(tableEl ? tableEl.closest('.ed-block') : null, delta);
   }
 
+  // ── Arrow-key navigation across blocks and table cells ──────────────────
+  // Spec: docs/superpowers/specs/2026-09-23-editor-arrow-nav-design.md.
+  // Every block is its own contenteditable, so the native caret cannot cross
+  // into a neighbour; these helpers do that crossing once the caret is at the
+  // text boundary, and leave every other arrow press to the browser.
+
+  // The x a walk aims for when it starts from a SELECTED block, which has no
+  // caret to read one from: the x of the last walk that had one.
+  let arrowGoalX = null;
+
+  function collapsedCaretRangeIn(surface) {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0 || !sel.isCollapsed) return null;
+    const r = sel.getRangeAt(0);
+    return surface.contains(r.startContainer) ? r : null;
+  }
+
+  // First line's top and last line's bottom, from the surface's own line
+  // boxes. Null for a surface with nothing that paints (empty).
+  function surfaceLineBounds(surface) {
+    const all = document.createRange();
+    all.selectNodeContents(surface);
+    const rects = Array.prototype.filter.call(all.getClientRects(), (r) => r.height > 0);
+    if (!rects.length) return null;
+    let top = Infinity;
+    let bottom = -Infinity;
+    rects.forEach((r) => { top = Math.min(top, r.top); bottom = Math.max(bottom, r.bottom); });
+    return { top: top, bottom: bottom,
+      firstH: rects[0].height, lastH: rects[rects.length - 1].height };
+  }
+
+  // A collapsed range's rect. A caret at an ELEMENT offset (right after a
+  // <br>, which is where Shift+Enter leaves it) has no rect of its own, so
+  // the character beside it is measured instead: the one after it when that
+  // is text on the same line, else the one before it. Null when neither
+  // side is text (an empty line between <br>s, or an empty surface).
+  function caretRectOf(range) {
+    const rects = range.getClientRects();
+    if (rects.length && rects[0].height > 0) return rects[0];
+    const b = range.getBoundingClientRect();
+    if (b.height > 0) return b;
+    const node = range.startContainer;
+    const at = range.startOffset;
+    const charRect = (text, i) => {
+      const r = document.createRange();
+      r.setStart(text, i);
+      r.setEnd(text, i + 1);
+      const cr = r.getClientRects();
+      return cr.length && cr[0].height > 0 ? cr[0] : null;
+    };
+    if (node.nodeType === Node.TEXT_NODE) {
+      if (at < node.data.length) return charRect(node, at);
+      return at > 0 ? charRect(node, at - 1) : null;
+    }
+    const next = node.childNodes[at];
+    if (next && next.nodeType === Node.TEXT_NODE && next.data.length) return charRect(next, 0);
+    const prev = node.childNodes[at - 1];
+    if (prev && prev.nodeType === Node.TEXT_NODE && prev.data.length) {
+      return charRect(prev, prev.data.length - 1);
+    }
+    return null;
+  }
+
+  function caretClientX() {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0) return null;
+    const rect = caretRectOf(sel.getRangeAt(0));
+    return rect ? rect.left : null;
+  }
+
+  // Whether the collapsed caret in `surface` is on its first line ('up'),
+  // last line ('down'), at its start ('left') or at its end ('right'). False
+  // for a non-collapsed selection or a caret outside `surface`. A caret with
+  // no rect falls back to the text test, which is right for the one shape
+  // that produces it (an empty line, whose only neighbours are <br>s).
+  function rangeAtEdge(surface, r, dir) {
+    const before = document.createRange();
+    before.setStart(surface, 0);
+    before.setEnd(r.startContainer, r.startOffset);
+    const after = document.createRange();
+    after.setStart(r.startContainer, r.startOffset);
+    after.setEnd(surface, surface.childNodes.length);
+    const atStart = before.toString() === '';
+    const atEnd = after.toString() === '';
+    if (dir === 'left') return atStart;
+    if (dir === 'right') return atEnd;
+    const bounds = surfaceLineBounds(surface);
+    const cr = caretRectOf(r);
+    if (!bounds || !cr) return dir === 'up' ? atStart : atEnd;
+    const half = cr.height / 2;
+    return dir === 'up' ? cr.top - bounds.top < half : bounds.bottom - cr.bottom < half;
+  }
+
+  function caretAtEdge(surface, dir) {
+    const r = collapsedCaretRangeIn(surface);
+    return r ? rangeAtEdge(surface, r, dir) : false;
+  }
+
+  // The same edge test for the SELECTION'S FOCUS point, so Shift+Arrow can
+  // tell when a text selection has reached the cell's boundary.
+  function selectionFocusAtEdge(surface, dir) {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0 || !surface.contains(sel.focusNode)) return false;
+    const r = document.createRange();
+    r.setStart(sel.focusNode, sel.focusOffset);
+    r.collapse(true);
+    return rangeAtEdge(surface, r, dir);
+  }
+
+  // caretPositionFromPoint() HIT-TESTS, so the target line must be on
+  // screen and not under the fixed .ed-toolbar, or the point resolves to
+  // whatever is painted there instead. With `onLastLine` given, the LINE is
+  // what is brought into reach, not the surface's top: for a surface taller
+  // than the viewport, revealing its top pushes its last line off-screen.
+  // Without it (a selected block, a cell entered by ←/→), the top.
+  function scrollSurfaceIntoReach(surface, onLastLine) {
+    surface.scrollIntoView({ block: 'nearest' });
+    const bar = document.querySelector('.ed-toolbar');
+    const barBottom = bar ? bar.getBoundingClientRect().bottom : 0;
+    const bounds = onLastLine === undefined ? null : surfaceLineBounds(surface);
+    let top;
+    let bottom;
+    if (bounds) {
+      top = onLastLine ? bounds.bottom - bounds.lastH : bounds.top;
+      bottom = onLastLine ? bounds.bottom : bounds.top + bounds.firstH;
+    } else {
+      top = surface.getBoundingClientRect().top;
+      bottom = top;
+    }
+    if (top < barBottom) window.scrollBy(0, top - barBottom - 8);
+    else if (bottom > window.innerHeight) window.scrollBy(0, bottom - window.innerHeight + 8);
+  }
+
+  // Collapsed caret on the surface's first line (or last, `onLastLine`) at
+  // the character nearest `x`. No x, an empty surface, or a point that
+  // resolves outside the surface → the line's start (first) / end (last).
+  function landCaretAtX(surface, x, onLastLine) {
+    scrollSurfaceIntoReach(surface, onLastLine);
+    const fallback = () => {
+      if (onLastLine) placeCaretAtEnd(surface); else placeCaretAtSurfaceStart(surface);
+    };
+    const bounds = surfaceLineBounds(surface);
+    if (!bounds || x === null) { fallback(); return; }
+    const box = surface.getBoundingClientRect();
+    const y = onLastLine ? bounds.bottom - bounds.lastH / 2 : bounds.top + bounds.firstH / 2;
+    const px = Math.min(Math.max(x, box.left + 1), box.right - 1);
+    let node = null;
+    let offset = 0;
+    if (document.caretPositionFromPoint) {
+      const p = document.caretPositionFromPoint(px, y);
+      if (p) { node = p.offsetNode; offset = p.offset; }
+    } else if (document.caretRangeFromPoint) {
+      const rr = document.caretRangeFromPoint(px, y);
+      if (rr) { node = rr.startContainer; offset = rr.startOffset; }
+    }
+    if (!node || !surface.contains(node)) { fallback(); return; }
+    window.getSelection().setBaseAndExtent(node, offset, node, offset);
+  }
+
+  // Puts the caret (or the block selection) on `blockEl` arriving from
+  // direction `delta`: from above (+1) onto its first line, from below (-1)
+  // onto its last.
+  function arrowLandOn(blockEl, delta, x) {
+    const surface = focusableSurfaceOf(blockEl);
+    if (!surface) {
+      // No typing surface (fenced code, blockquote, hr, a degraded block):
+      // stop ON it as a one-block selection. setBlockSelection() moves the
+      // roving focus to its wrapper, which is where the plain-arrow, Enter
+      // and Delete branches of the document keydown pick it up.
+      const rec = blockRecOf(blockEl);
+      if (!rec || rec.endLine < rec.startLine) return;
+      setBlockSelection({ anchorLine: rec.startLine, focusLine: rec.startLine });
+      scrollSurfaceIntoReach(blockEl);
+      return;
+    }
+    const tableEl = blockEl.querySelector('table');
+    if (tableEl && surface.classList.contains('ed-wys-cell')) {
+      // Entering a table: the header row from above, the last row from
+      // below, in the column whose span holds x (nearest centre otherwise).
+      const rows = allRowsOf(tableEl);
+      const row = delta > 0 ? rows[0] : rows[rows.length - 1];
+      const cells = Array.prototype.slice.call(row.cells);
+      const ax = x !== null ? x : arrowGoalX;
+      let cell = cells[0];
+      if (ax !== null) {
+        let best = Infinity;
+        cells.forEach((c) => {
+          const r = c.getBoundingClientRect();
+          const d = ax >= r.left && ax <= r.right ? 0 : Math.abs((r.left + r.right) / 2 - ax);
+          if (d < best) { best = d; cell = c; }
+        });
+      }
+      cell.focus({ preventScroll: true });
+      landCaretAtX(cell, ax, delta < 0);
+      return;
+    }
+    surface.focus({ preventScroll: true });
+    landCaretAtX(surface, x, delta < 0);
+  }
+
+  // All four arrows inside a table cell, once the caret is at that text
+  // boundary. Moving within the table is not a burst switch — the burst
+  // spans the whole table and the cell's own focusin updates activeCellEl —
+  // so nothing commits here. Leaving the table (header ↑, last row ↓) goes
+  // through the block walk, which resolves the burst first.
+  function moveTableCellByArrow(cellEl, key, x) {
+    const tableEl = cellEl.closest('table');
+    if (key === 'ArrowLeft' || key === 'ArrowRight') {
+      const cells = tableCellsOf(tableEl);
+      const i = cells.indexOf(cellEl) + (key === 'ArrowLeft' ? -1 : 1);
+      if (i < 0 || i >= cells.length) return false;
+      cells[i].focus({ preventScroll: true });
+      scrollSurfaceIntoReach(cells[i]);
+      if (key === 'ArrowLeft') placeCaretAtEnd(cells[i]); else placeCaretAtSurfaceStart(cells[i]);
+      return true;
+    }
+    const delta = key === 'ArrowUp' ? -1 : 1;
+    const rows = allRowsOf(tableEl);
+    const r = rows.indexOf(cellEl.parentElement) + delta;
+    if (r < 0 || r >= rows.length) {
+      walkToAdjacentBlockByArrow(tableEl.closest('.ed-block'), delta, x);
+      return true;
+    }
+    const target = rows[r].cells[Math.min(colIndexOf(cellEl), rows[r].cells.length - 1)];
+    target.focus({ preventScroll: true });
+    landCaretAtX(target, x, delta < 0);
+    return true;
+  }
+
+  // ── Table cell-range selection ───────────────────────────────────────────
+  // Spec: docs/superpowers/specs/2026-09-24-editor-cell-range-design.md.
+  // The range lives on the TABLE burst as row/column indices
+  // (currentBurst.cellRange = { anchor: {r, c}, focus: {r, c} }), never as
+  // cell nodes: undo/redo swap the table's innerHTML, and indices survive
+  // that where nodes would not. A range over exactly one cell is no range.
+  // The paint (.ed-cell-range) is stripped by burstBaselineHtml(), so it
+  // never reaches a snapshot or a commit.
+
+  function cellRangeBurst() {
+    return currentBurst && currentBurst.blockType === 'table' && currentBurst.cellRange
+      ? currentBurst : null;
+  }
+
+  function cellPointOf(cellEl) {
+    const tableEl = cellEl && cellEl.closest('table');
+    if (!tableEl) return null;
+    const r = allRowsOf(tableEl).indexOf(cellEl.parentElement);
+    return r < 0 ? null : { r: r, c: colIndexOf(cellEl) };
+  }
+
+  function cellAtPoint(tableEl, p) {
+    const row = allRowsOf(tableEl)[p.r];
+    return row ? (row.cells[Math.min(p.c, row.cells.length - 1)] || null) : null;
+  }
+
+  function cellRangeCells(burst) {
+    const rect = cellRangeLib.normalize(burst.cellRange.anchor, burst.cellRange.focus);
+    return cellRangeLib.cellsIn(rect).map((p) => cellAtPoint(burst.editEl, p)).filter(Boolean);
+  }
+
+  function unpaintCellRange(tableEl) {
+    tableEl.classList.remove('ed-cell-range-active');
+    Array.prototype.forEach.call(tableEl.querySelectorAll('.ed-cell-range'),
+      (el) => el.classList.remove('ed-cell-range'));
+  }
+
+  // The toolbar is normally driven by a non-collapsed native selection; a
+  // range keeps the native caret collapsed, so it is shown over the range.
+  function showSelToolbarForCellRange() {
+    const burst = cellRangeBurst();
+    if (!burst) return;
+    const cells = cellRangeCells(burst);
+    if (!cells.length) return;
+    const r = document.createRange();
+    r.setStartBefore(cells[0]);
+    r.setEndAfter(cells[cells.length - 1]);
+    positionSelToolbar(r);
+  }
+
+  // Re-applies the paint from the state, clamping the state to the table
+  // first (a structural undo can leave fewer rows or columns).
+  function paintCellRange() {
+    const burst = currentBurst && currentBurst.blockType === 'table' ? currentBurst : null;
+    if (!burst) return;
+    unpaintCellRange(burst.editEl);
+    if (!burst.cellRange) return;
+    const rows = allRowsOf(burst.editEl);
+    if (!rows.length) { burst.cellRange = null; return; }
+    const clampP = (p) => {
+      const r = Math.max(0, Math.min(rows.length - 1, p.r));
+      return { r: r, c: Math.max(0, Math.min(rows[r].cells.length - 1, p.c)) };
+    };
+    const anchor = clampP(burst.cellRange.anchor);
+    const focus = clampP(burst.cellRange.focus);
+    if (cellRangeLib.isSingle(anchor, focus)) { burst.cellRange = null; return; }
+    burst.cellRange = { anchor: anchor, focus: focus };
+    burst.editEl.classList.add('ed-cell-range-active');
+    cellRangeCells(burst).forEach((el) => el.classList.add('ed-cell-range'));
+    const focusCell = cellAtPoint(burst.editEl, focus);
+    if (focusCell) {
+      if (document.activeElement !== focusCell) focusCell.focus({ preventScroll: true });
+      placeCaretAtSurfaceStart(focusCell);
+    }
+    showSelToolbarForCellRange();
+  }
+
+  function setCellRange(anchor, focus) {
+    if (!currentBurst || currentBurst.blockType !== 'table' || !anchor || !focus) return;
+    currentBurst.cellRange = { anchor: anchor, focus: focus };
+    paintCellRange();
+  }
+
+  function clearCellRange() {
+    const burst = currentBurst && currentBurst.blockType === 'table' ? currentBurst : null;
+    if (!burst || !burst.cellRange) return;
+    burst.cellRange = null;
+    unpaintCellRange(burst.editEl);
+    hideSelToolbar();
+  }
+
+  // Shift+click on another cell of the table whose burst is open. Shift+click
+  // inside the active cell (with no range yet) stays a native text selection.
+  function beginCellRangeShiftClick(e) {
+    const cellEl = e.target.closest && e.target.closest('.ed-wys-cell');
+    if (!cellEl) return false;
+    const tableEl = cellEl.closest('table');
+    const burst = currentBurst;
+    if (!burst || burst.blockType !== 'table' || burst.editEl !== tableEl) return false;
+    const base = burst.cellRange ? burst.cellRange.anchor
+      : (burst.activeCellEl ? cellPointOf(burst.activeCellEl) : null);
+    const target = cellPointOf(cellEl);
+    if (!base || !target) return false;
+    if (!burst.cellRange && cellRangeLib.isSingle(base, target)) return false;
+    e.preventDefault();
+    clearNativeTextSelection();
+    setCellRange(base, target);
+    return true;
+  }
+
+  // Keys while a range stands. True = handled (the caller returns).
+  function handleCellRangeKeydown(e, cellEl) {
+    const plain = !e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey;
+    // Tab / Enter move or edit at the caret, not over the range: clear it and
+    // let the key take its ordinary path. A range left standing would make
+    // the next keystroke clear the RANGE and land in its focus cell.
+    if (e.key === 'Tab' || e.key === 'Enter') { clearCellRange(); return false; }
+    if (e.key === 'Escape') { e.preventDefault(); clearCellRange(); return true; }
+    if (plain && /^Arrow(Up|Down|Left|Right)$/.test(e.key)) {
+      e.preventDefault();
+      clearCellRange();
+      return true;
+    }
+    const RANGE_MARK_KEYS = { b: 'STRONG', i: 'EM', u: 'U' };
+    if ((e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey && RANGE_MARK_KEYS[e.key.toLowerCase()]) {
+      e.preventDefault();
+      applyMarkToCellRange(RANGE_MARK_KEYS[e.key.toLowerCase()]);
+      return true;
+    }
+    if (e.key === 'Delete' || e.key === 'Backspace') {
+      e.preventDefault();
+      clearCellRangeContents('range-clear');
+      paintCellRange();
+      return true;
+    }
+    // A printable character: clear the range, collapse to the focus cell and
+    // let the browser insert the character there (no preventDefault).
+    if (e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey && !e.isComposing) {
+      const burst = cellRangeBurst();
+      const focusCell = cellAtPoint(burst.editEl, burst.cellRange.focus);
+      clearCellRangeContents('range-type', false);
+      clearCellRange();
+      if (focusCell) { focusCell.focus({ preventScroll: true }); placeCaretAtSurfaceStart(focusCell); }
+      return true;
+    }
+    const SHIFT_DIR = { ArrowUp: 'up', ArrowDown: 'down', ArrowLeft: 'left', ArrowRight: 'right' };
+    if (e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey && SHIFT_DIR[e.key]) {
+      e.preventDefault();
+      const burst = cellRangeBurst();
+      const rows = allRowsOf(burst.editEl);
+      const focus = cellRangeLib.step(burst.cellRange.focus, SHIFT_DIR[e.key],
+        rows.length, rows[0].cells.length);
+      setCellRange(burst.cellRange.anchor, focus);
+      if (!cellRangeBurst()) hideSelToolbar();
+      return true;
+    }
+    return false;
+  }
+
+  // Drag across cells. Armed on every press on a cell body (grips are
+  // chrome: hitTestGrip() runs first and the pointerdown returns before
+  // this). While the pointer stays in the origin cell the native text
+  // selection is untouched; entering another cell of the SAME table starts
+  // the range. Outside the table the block-selection drag owns the gesture.
+  let cellDrag = null;
+
+  function armCellDrag(e) {
+    const cellEl = e.target.closest && e.target.closest('.ed-wys-cell');
+    cellDrag = cellEl
+      ? { pointerId: e.pointerId, originCell: cellEl, tableEl: cellEl.closest('table'), active: false }
+      : null;
+  }
+
+  function updateCellDrag(e) {
+    if (!cellDrag || e.pointerId !== cellDrag.pointerId || tePointer) return;
+    if (typeof e.buttons === 'number' && e.buttons === 0) { cellDrag = null; return; }
+    const overEl = document.elementFromPoint(e.clientX, e.clientY);
+    const overCell = overEl && overEl.closest && overEl.closest('.ed-wys-cell');
+    if (!overCell || overCell.closest('table') !== cellDrag.tableEl) return;
+    if (!cellDrag.active && overCell === cellDrag.originCell) return;
+    const burst = currentBurst;
+    if (!burst || burst.blockType !== 'table' || burst.editEl !== cellDrag.tableEl) return;
+    cellDrag.active = true;
+    e.preventDefault();
+    clearNativeTextSelection();
+    setCellRange(cellPointOf(cellDrag.originCell), cellPointOf(overCell));
+  }
+
+  function endCellDrag() {
+    const st = cellDrag;
+    cellDrag = null;
+    // mouseup can leave a native selection behind; re-collapse onto the focus cell.
+    if (st && st.active) paintCellRange();
+  }
+
+  // A cell's text with its <br>s as newlines — what TSV and a grid paste
+  // mean by "the cell's content".
+  function cellPlainText(el) {
+    const clone = el.cloneNode(true);
+    Array.prototype.forEach.call(clone.querySelectorAll('br'),
+      (br) => br.parentNode.replaceChild(document.createTextNode('\n'), br));
+    return clone.textContent.replace(/\n$/, '');
+  }
+
+  function cellRangeGrid() {
+    const burst = cellRangeBurst();
+    const rect = cellRangeLib.normalize(burst.cellRange.anchor, burst.cellRange.focus);
+    const grid = [];
+    for (let r = rect.top; r <= rect.bottom; r++) {
+      const row = [];
+      for (let c = rect.left; c <= rect.right; c++) {
+        const cell = cellAtPoint(burst.editEl, { r: r, c: c });
+        row.push(cell ? cellPlainText(cell) : '');
+      }
+      grid.push(row);
+    }
+    return grid;
+  }
+
+  function cellRangeHtml() {
+    const burst = cellRangeBurst();
+    const rect = cellRangeLib.normalize(burst.cellRange.anchor, burst.cellRange.focus);
+    let html = '<table>';
+    for (let r = rect.top; r <= rect.bottom; r++) {
+      html += '<tr>';
+      for (let c = rect.left; c <= rect.right; c++) {
+        const cell = cellAtPoint(burst.editEl, { r: r, c: c });
+        html += '<td>' + (cell ? cell.innerHTML : '') + '</td>';
+      }
+      html += '</tr>';
+    }
+    return html + '</table>';
+  }
+
+  // Empties every cell in the range as ONE burst-history step. Typing over
+  // a range passes `snapAfter` false: the clear and the character typed into
+  // the focus cell then land in the same step (the typing debounce snaps
+  // them together), so one Ctrl+Z undoes both.
+  function clearCellRangeContents(reason, snapAfter) {
+    const burst = cellRangeBurst();
+    if (!burst) return;
+    snapBurstIfActive(burst.editEl, reason + '-pre');
+    cellRangeCells(burst).forEach((el) => { el.innerHTML = ''; });
+    if (snapAfter !== false) snapBurstIfActive(burst.editEl, reason);
+  }
+
+  const GRID_PASTE_TOO_BIG_MESSAGE = '貼上的表格太大（上限 500 列 × 50 欄）';
+
+  // A clipboard is a GRID when its text holds a TAB or its HTML holds a
+  // <table>. Anything else — including multi-line text — is not, and keeps
+  // the single-cell paste. The TSV wins when both exist: Excel and Sheets
+  // put both on the clipboard, and their HTML is pretty-printed (line breaks
+  // and indentation inside cells) while their TSV is the cell values.
+  function clipboardGrid(dt) {
+    const text = dt.getData('text/plain');
+    if (text && text.indexOf('\t') !== -1) return cellRangeLib.parseTsv(text);
+    const html = dt.getData('text/html');
+    if (!html || !/<table[\s>]/i.test(html)) return null;
+    const table = new DOMParser().parseFromString(html, 'text/html').querySelector('table');
+    if (!table || !table.rows.length) return null;
+    return Array.prototype.map.call(table.rows, (row) => {
+      const out = [];
+      Array.prototype.forEach.call(row.cells, (cell) => {
+        out.push(htmlCellText(cell));
+        // colspan: the columns a spanning cell covers stay empty, so later
+        // cells keep their own column instead of shifting left.
+        for (let k = 1; k < (cell.colSpan || 1); k++) out.push('');
+      });
+      return out;
+    });
+  }
+
+  // An HTML cell's text as a browser would render it: runs of source
+  // whitespace collapse to one space, <br> is a line break.
+  function htmlCellText(cell) {
+    const clone = cell.cloneNode(true);
+    const walker = document.createTreeWalker(clone, NodeFilter.SHOW_TEXT);
+    for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+      n.data = n.data.replace(/[ \t\r\n]+/g, ' ');
+    }
+    Array.prototype.forEach.call(clone.querySelectorAll('br'),
+      (br) => br.parentNode.replaceChild(document.createTextNode('\n'), br));
+    return clone.textContent.split('\n').map((s) => s.trim()).join('\n').trim();
+  }
+
+  function setCellText(cell, text) {
+    cell.textContent = '';
+    String(text).split('\n').forEach((part, i) => {
+      if (i > 0) cell.appendChild(document.createElement('br'));
+      if (part) cell.appendChild(document.createTextNode(part));
+    });
+  }
+
+  // Fills the grid from the range's top-left (or the caret's cell), growing
+  // the table first, as ONE burst-history step; the pasted block is then the
+  // range. False when it could not land (no open burst on this table), so the
+  // caller falls back to the single-cell paste instead of eating the paste.
+  function pasteGridIntoTable(cellEl, grid) {
+    const tableEl = cellEl.closest('table');
+    const burst = currentBurst;
+    if (!burst || burst.blockType !== 'table' || burst.editEl !== tableEl || !grid.length) return false;
+    const width = grid.reduce((w, row) => Math.max(w, row.length), 0);
+    if (grid.length > 500 || width > 50) { showBanner(GRID_PASTE_TOO_BIG_MESSAGE); return true; }
+    const origin = burst.cellRange
+      ? (() => { const rc = cellRangeLib.normalize(burst.cellRange.anchor, burst.cellRange.focus);
+        return { r: rc.top, c: rc.left }; })()
+      : cellPointOf(cellEl);
+    if (!origin) return false;
+    const rows = allRowsOf(tableEl);
+    const need = cellRangeLib.growthNeeded(origin, grid, rows.length, rows[0].cells.length);
+    snapBurstIfActive(tableEl, 'grid-paste-pre');
+    for (let i = 0; i < need.addCols; i++) insertColumn(tableEl, headerRowOf(tableEl).cells.length - 1);
+    for (let i = 0; i < need.addRows; i++) {
+      const body = bodyRowsOf(tableEl);
+      insertRow(tableEl, body.length ? body[body.length - 1] : null);
+    }
+    armNewTableCells(tableEl);
+    const all = allRowsOf(tableEl);
+    grid.forEach((row, i) => row.forEach((text, j) => {
+      const target = all[origin.r + i] && all[origin.r + i].cells[origin.c + j];
+      if (target) setCellText(target, text);
+    }));
+    snapBurstIfActive(tableEl, 'grid-paste');
+    setCellRange(origin, { r: origin.r + grid.length - 1, c: origin.c + width - 1 });
+    return true;
+  }
+
+  // A mark over a range applies to each cell's WHOLE content. The state is
+  // "every non-empty cell is wholly inside `tag`": true removes it from every
+  // cell, false wraps every cell (after unwrapping partial marks, so no
+  // nesting). Empty cells are skipped.
+  function applyMarkToCellRange(tag) {
+    const burst = cellRangeBurst();
+    if (!burst) return;
+    const cells = cellRangeCells(burst).filter((el) => el.textContent.trim() !== '');
+    if (!cells.length) return;
+    const wholly = (cell) => {
+      const walker = document.createTreeWalker(cell, NodeFilter.SHOW_TEXT);
+      for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+        if (n.data.trim() && !closestMarkAncestor(n, tag, cell)) return false;
+      }
+      return true;
+    };
+    const on = !cells.every(wholly);
+    snapBurstIfActive(burst.editEl, 'range-mark-pre');
+    cells.forEach((cell) => {
+      Array.prototype.slice.call(cell.querySelectorAll(tag.toLowerCase()))
+        .forEach((m) => unwrapElement(m));
+      if (on) {
+        // Trimmed to the text, as applyMarkToggle() does: a mark closing
+        // after a space (`**a **`) is not a closing delimiter in markdown.
+        const r = document.createRange();
+        r.selectNodeContents(cell);
+        if (trimRangeToText(r)) wrapRangeIn(r, tag, cell);
+      }
+    });
+    snapBurstIfActive(burst.editEl, 'range-mark');
+    paintCellRange();
+  }
+
+  document.addEventListener('copy', (e) => {
+    if (!cellRangeBurst() || !e.clipboardData) return;
+    e.preventDefault();
+    e.clipboardData.setData('text/plain', cellRangeLib.toTsv(cellRangeGrid()));
+    e.clipboardData.setData('text/html', cellRangeHtml());
+  });
+
+  document.addEventListener('cut', (e) => {
+    if (!cellRangeBurst() || !e.clipboardData) return;
+    e.preventDefault();
+    e.clipboardData.setData('text/plain', cellRangeLib.toTsv(cellRangeGrid()));
+    e.clipboardData.setData('text/html', cellRangeHtml());
+    clearCellRangeContents('range-cut');
+    paintCellRange();
+  });
+
+  // IME: the first composition keystroke behaves like typing a character.
+  document.addEventListener('compositionstart', () => {
+    const burst = cellRangeBurst();
+    if (!burst) return;
+    const focusCell = cellAtPoint(burst.editEl, burst.cellRange.focus);
+    clearCellRangeContents('range-type', false);
+    clearCellRange();
+    if (focusCell) placeCaretAtSurfaceStart(focusCell);
+  }, true);
+
+  // The arrow sibling of walkToAdjacentBlockByTab(), with the same order:
+  // resolve the open burst FIRST (its commit can re-render .content), then
+  // find the destination in the document that exists afterwards.
+  //
+  // The leaving block's commit CAN change the source line count — a table row
+  // inserted inside the burst adds one — which moves the destination's start
+  // line when it lies below, so its identity alone stops re-resolving the
+  // moment the commit was a full render (the first one after a page load
+  // always is). The SOURCE block's own start line does not move under its
+  // own edit, so the destination is re-derived as its neighbour first; the
+  // identity is the fallback for a commit that removed the source block.
+  async function walkToAdjacentBlockByArrow(fromBlockEl, delta, x) {
+    const step = (el) => (delta > 0 ? el.nextElementSibling : el.previousElementSibling);
+    const nextBlock = (el) => {
+      let n = el ? step(el) : null;
+      while (n && !n.classList.contains('ed-block')) n = step(n);
+      return n;
+    };
+    let dest = nextBlock(fromBlockEl);
+    if (!dest) return;
+    const srcStartLine = (blockRecOf(fromBlockEl) || {}).startLine;
+    const destIdentity = captureBlockIdentity(dest);
+    const ok = await switchAwayFrom();
+    if (!ok) return;
+    if (!document.body.contains(dest)) {
+      const srcRec = blocks.find((b) => b.startLine === srcStartLine);
+      const liveSrc = srcRec
+        ? document.querySelector('.ed-block[data-block-id="' + srcRec.id + '"]') : null;
+      dest = (liveSrc && nextBlock(liveSrc)) || reresolveBlockEl(destIdentity);
+      if (!dest) { showBanner(DROPPED_GESTURE_MESSAGE); return; }
+    }
+    if (x !== null) arrowGoalX = x;
+    arrowLandOn(dest, delta, x !== null ? x : arrowGoalX);
+  }
+
   // Esc inside a table burst: revert to the pre-focus baseline and end the
   // burst WITHOUT committing — mirrors revertBurstAndEnd() above, but a
   // table burst has no single always-live element to blur() afterward (the
@@ -9739,6 +10444,7 @@
   // rewrite below fires that synchronous blur, there is no burst left to
   // mistakenly resolve — same "belt and braces" idiom rerenderAll() uses.
   async function revertTableBurstAndEnd(cellEl) {
+    clearCellRange();
     const burst = currentBurst;
     if (!burst || burst.blockType !== 'table' || burst.editEl !== cellEl.closest('table')) return;
     const tableEl = burst.editEl;
@@ -9809,6 +10515,7 @@
         target.focus();
         placeCaretAtEnd(target);
       }
+      paintCellRange();
       return;
     }
     // §10-gap fix (review): same reasoning as burstUndo()'s own guard above
@@ -9849,6 +10556,7 @@
         target.focus();
         placeCaretAtEnd(target);
       }
+      paintCellRange();
       return;
     }
     switchAwayFrom().then((ok) => { if (ok) redo(); });
@@ -9863,6 +10571,20 @@
   function handleTableCellKeydown(e, cellEl) {
     const tableEl = cellEl.closest('table');
     if (!currentBurst || currentBurst.blockType !== 'table' || currentBurst.editEl !== tableEl) return;
+    if (cellRangeBurst() && handleCellRangeKeydown(e, cellEl)) return;
+    // Shift+Arrow at the text boundary starts a cell range with the neighbour.
+    const SHIFT_EDGE = { ArrowUp: 'up', ArrowDown: 'down', ArrowLeft: 'left', ArrowRight: 'right' };
+    if (e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey && !e.isComposing &&
+        SHIFT_EDGE[e.key] && selectionFocusAtEdge(cellEl, SHIFT_EDGE[e.key])) {
+      const from = cellPointOf(cellEl);
+      const rows = allRowsOf(tableEl);
+      const to = cellRangeLib.step(from, SHIFT_EDGE[e.key], rows.length, rows[0].cells.length);
+      if (!cellRangeLib.isSingle(from, to)) {
+        e.preventDefault();
+        setCellRange(from, to);
+      }
+      return;
+    }
     if (e.key === 'Enter') {
       e.preventDefault();
       snapBurstIfActive(tableEl, 'br-pre');
@@ -9880,6 +10602,26 @@
       revertTableBurstAndEnd(cellEl);
       return;
     }
+    if ((e.key === 'ArrowUp' || e.key === 'ArrowDown' || e.key === 'ArrowLeft' ||
+         e.key === 'ArrowRight') && !e.shiftKey && !e.ctrlKey && !e.altKey &&
+        !e.metaKey && !e.isComposing) {
+      const edge = { ArrowUp: 'up', ArrowDown: 'down', ArrowLeft: 'left', ArrowRight: 'right' }[e.key];
+      if (!caretAtEdge(cellEl, edge)) return;
+      const x = caretClientX();
+      if (x !== null) arrowGoalX = x;
+      const tableBlockEl = tableEl.closest('.ed-block');
+      const step = (el) => (e.key === 'ArrowUp' ? el.previousElementSibling : el.nextElementSibling);
+      const rows = allRowsOf(tableEl);
+      const leavesTable = (e.key === 'ArrowUp' && rows.indexOf(cellEl.parentElement) === 0) ||
+        (e.key === 'ArrowDown' && rows.indexOf(cellEl.parentElement) === rows.length - 1);
+      if (leavesTable) {
+        let probe = step(tableBlockEl);
+        while (probe && !probe.classList.contains('ed-block')) probe = step(probe);
+        if (!probe) return;
+      }
+      if (moveTableCellByArrow(cellEl, e.key, x)) e.preventDefault();
+      return;
+    }
     if ((e.ctrlKey || e.metaKey) && !e.shiftKey && e.key === 'z') {
       e.preventDefault();
       tableBurstUndo(cellEl);
@@ -12723,7 +13465,12 @@
 
   document.addEventListener('pointerdown', (e) => {
     if (e.button !== 0) return;
-    if (e.target.closest && e.target.closest('.ed-te-menu')) return; // the menu's own buttons handle themselves
+    if (e.target.closest && e.target.closest('.ed-te-menu')) {
+      // The menu's own buttons handle themselves. A standing cell range is
+      // cleared first: a row/column op shifts the cells its indices name.
+      clearCellRange();
+      return;
+    }
     // Review fix (Critical): a PRIOR gesture's pointerup/pointercancel may
     // never have reached us at all (release over browser chrome / the
     // window edge, the window losing focus without a pointercancel, ...) —
@@ -12747,6 +13494,11 @@
     // and a press-drag on the backdrop both leave the selection null); it is
     // here so that stays true if the backdrop ever stops being `inset: 0`.
     if (waveEditorIsModal()) return;
+    // A plain press clears a standing cell range — except on the selection
+    // toolbar, whose buttons act ON the range.
+    if (!e.shiftKey && cellRangeBurst() && !(e.target.closest && e.target.closest('.ed-seltb'))) {
+      clearCellRange();
+    }
     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 ⠿
@@ -12790,7 +13542,9 @@
       // crosses the threshold still opens the menu, so nothing was taken away.
       // Pinned by the RV5 scenario in test/editor-client-runtime.test.js.
       if (armBlockDrag(e)) return;
+      if (e.shiftKey && beginCellRangeShiftClick(e)) return;
       if (e.shiftKey) { beginShiftClickSelection(e); return; }
+      armCellDrag(e);
       armBlockSelDrag(e);
       return;
     }
@@ -12843,6 +13597,14 @@
     else updateColDropIndicator(e.clientX);
   });
 
+  // The table cell-range drag's pointermove (updateCellDrag()). It acts only
+  // while the pointer is over another cell of the origin table, and never
+  // calls preventDefault() outside it, so the block-selection drag below
+  // still takes over once the pointer leaves the table.
+  document.addEventListener('pointermove', (e) => {
+    updateCellDrag(e);
+  });
+
   // 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
@@ -12861,6 +13623,7 @@
   });
 
   document.addEventListener('pointerup', async (e) => {
+    endCellDrag();
     // 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
@@ -13072,6 +13835,7 @@
   // same way activateCell() used to — brief: "wire your cell edit root the
   // same way paragraph editing does (reuse, don't fork)").
   function onSelectionChangeForToolbar() {
+    if (cellRangeBurst()) { showSelToolbarForCellRange(); return; }
     // v3.1.0: the fixed toolbar's five inline-format buttons enable/disable on
     // exactly the same question this listener already answers ("is there a
     // non-collapsed selection inside `selToolbarEditEl`?"), so it piggybacks
@@ -13184,9 +13948,10 @@
   // collectLeftovers() + dropEmptied() above, which is all an extractContents()
   // call site needs. applyMarkToggle()'s wrap branch reaches it through
   // wrapRangeIn() below; applyLinkToggleBody()'s new-link path calls it
-  // directly. A native Ctrl+B does not arrive here at all: client.js binds no
-  // Ctrl/Cmd + b/i/u, so that keystroke reaches the contenteditable as the
-  // browser's own execCommand and produces a <b>. The journey suite drives
+  // directly. A native Ctrl+B does not arrive here at all: outside a table
+  // cell range client.js binds no Ctrl/Cmd + b/i/u, so that keystroke reaches
+  // the contenteditable as the browser's own execCommand and produces a <b>
+  // (with a range standing, handleCellRangeKeydown() takes it instead). The journey suite drives
   // that keystroke and the toolbar button side by side, each with its own tag
   // pattern, for exactly that reason.
   function extractRangeInto(range, el, root) {
@@ -13295,6 +14060,7 @@
   // Applies the toggle policy for a plain mark type (STRONG/EM/CODE/DEL/U —
   // link has its own entry point below because it also needs a URL prompt).
   function applyMarkToggle(tag) {
+    if (cellRangeBurst()) { applyMarkToCellRange(tag); return; }
     const root = selToolbarEditEl;
     if (!root) return;
     const sel = window.getSelection();
@@ -16223,6 +16989,31 @@
     // class names, and it protects every future surface too.
     if (blockSelection && !e.ctrlKey && !e.metaKey && !e.altKey &&
         !isTextEntryTarget(e.target)) {
+      // Arrow walk from a selected block: plain ↑/↓ clears the selection and
+      // continues from its focus block, aiming at the x the walk last had.
+      if (!e.shiftKey && (e.key === 'ArrowUp' || e.key === 'ArrowDown')) {
+        const from = selectionFocusBlockEl();
+        if (from) {
+          e.preventDefault();
+          clearBlockSelection();
+          walkToAdjacentBlockByArrow(from, e.key === 'ArrowUp' ? -1 : 1, null);
+        }
+        return;
+      }
+      // Enter on ONE selected block opens its MD 原始碼 — the keyboard route
+      // into a block that has no typing surface. A wavedrom block is excluded
+      // and every other case falls through: Enter on a standing selection
+      // over a wave diagram already opens the wave editor further down.
+      if (!e.shiftKey && e.key === 'Enter') {
+        const from = selectionFocusBlockEl();
+        const members = selectionLib ? selectionLib.membersOf(blockSelection, blocks) : [];
+        if (from && members.length === 1 && !waveDiagramInside(from)) {
+          e.preventDefault();
+          clearBlockSelection();
+          openRawViaGutter(from);
+          return;
+        }
+      }
       if (e.key === 'Tab') {
         // §3.5, in as many words: 必須 preventDefault()，否則 Tab 在 body 上是
         // 瀏覽器焦點巡覽.
@@ -16465,12 +17256,14 @@
   });
 
   // The `inputType` values Chromium reports for the BROWSER's own formatting
-  // commands. md2doc binds no formatting shortcut of its own — the keys its
-  // `ctrlKey || metaKey` branches act on are `Enter`, `z`, `y`, shift+`Z`,
-  // `s` and shift+`v`/`V`: the raw editor's commit, undo, redo, save and
-  // plain-paste arming. `b`, `i` and `u` are not among them, so Ctrl+B
-  // reaches the contenteditable as the browser's own execCommand and does not
-  // pass through any snapBurstIfActive() call site.
+  // commands. Outside a table cell range md2doc binds no formatting shortcut
+  // of its own — the keys its `ctrlKey || metaKey` branches act on are
+  // `Enter`, `z`, `y`, shift+`Z`, `s` and shift+`v`/`V`: the raw editor's
+  // commit, undo, redo, save and plain-paste arming. `b`, `i` and `u` are not
+  // among them, so Ctrl+B reaches the contenteditable as the browser's own
+  // execCommand and does not pass through any snapBurstIfActive() call site.
+  // (With a cell range standing, handleCellRangeKeydown() takes b/i/u and
+  // applies the mark to every cell — see applyMarkToCellRange().)
   //
   // MEASURED (puppeteer 24.42.0 / headless Chromium, an `.ed-wys-armed`
   // paragraph, ' typed sentence' typed then a five-character selection
@@ -16592,6 +17385,8 @@
     if (cellEl) {
       e.preventDefault();
       const dt = e.clipboardData || window.clipboardData;
+      const grid = dt ? clipboardGrid(dt) : null;
+      if (grid && pasteGridIntoTable(cellEl, grid)) return;
       snapBurstIfActive(cellEl.closest('table'), 'paste-pre');
       insertTextAtCaret(dt ? dt.getData('text/plain') : '');
       snapBurstIfActive(cellEl.closest('table'), 'paste');