@helping-ai-workflow/md2doc 3.10.0 → 3.12.0

package/lib/editor/client.js

@@ -434,9 +434,9 @@
   // reordered span it refused 1425 of the 4067 legal drops; the clamp now
   // answers 1411 of those, and what this still refuses is the 14 no
   // removal-clamp can reach — a batch whose last member is shallower than the
-  // block it lands before, i.e. the INSERTION half of the move. See
-  // performListItemDrop() for the single site and BLOCK_MOVE_ORPHAN_MESSAGE
-  // for the family and the sweep behind those numbers.
+  // block it lands before, i.e. the INSERTION half of the move. v3.11: those
+  // 14 no longer refuse — performListItemDrop() hands them to
+  // moveSpanAcrossLists(), whose own clamp re-anchors the landing.
   function spanIndentsAreAnchored(items) {
     let prevLi = null;
     for (let i = 0; i < (items || []).length; i++) {
@@ -3445,10 +3445,37 @@
     return out;
   }
 
+  // v3.11 (batch-2 §6): every list serialization goes through here, so every
+  // caller agrees on where a LOOSE list's blank lines go — the commit, and the
+  // line arithmetic (runLineOfBlock(), the per-li commit's lineMeta index)
+  // that has to land on the same lines. Read off the FILE, never guessed from
+  // the DOM: two items that were already neighbours keep whatever separated
+  // them; a new neighbour (a deletion closed the gap, a move or a copy landed,
+  // Enter made the item) takes the spacing of the list it joins, which the
+  // renderer stamped from marked's own looseness as data-list-loose.
+  function serializeListEls(els, opts) {
+    return listMd.serializeBlocks(els, Object.assign({ blankBefore: looseBlankBefore }, opts || {}));
+  }
+  function looseBlankBefore(el, prevEl) {
+    if (!prevEl) return false;
+    const rec = blockRecOf(el);
+    const prevRec = blockRecOf(prevEl);
+    if (rec && prevRec && rec !== prevRec && blocks[blocks.indexOf(rec) - 1] === prevRec) {
+      for (let ln = prevRec.endLine + 1; ln < rec.startLine; ln++) {
+        if (String(lines[ln - 1]).trim() === '') return true;
+      }
+      return false;
+    }
+    const loose = (x) => x.getAttribute('data-list-loose') === '1';
+    // A brand-new item (no record yet) carries no list of its own to ask, so
+    // the item after it answers for the list both of them are in.
+    return prevRec ? loose(prevEl) : (loose(prevEl) || loose(el));
+  }
+
   function canWysiwygForLi(blockEl) {
     if (!blockEl) return false;
     if (blockOwnsNoLine(blockEl)) return false;
-    const res = listMd.serializeBlocks([blockEl]);
+    const res = serializeListEls([blockEl]);
     return armBlockingNames(res.unsupported).length === 0 && res.unsupportedByLi.length === 0;
   }
 
@@ -5427,58 +5454,20 @@
 
   const BATCH_EMPTY_MESSAGE = '沒有選取任何區塊';
   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
-  // (BLOCK_MOVE_LIST_SEAM_MESSAGE, '區塊搬移不能跨越清單邊界') and said THIS task
-  // owned the final wording. They are three different problems with three
-  // OPPOSITE remedies, so one sentence for all of them sends two thirds of
-  // the users to fix the wrong end of their own gesture:
-  //   * the SOURCE seam — the block cannot leave where it is, because the two
-  //     lists it stands between would join into one loose run. No destination
-  //     helps; the remedy is not to move it (or to move something else).
-  //   * the DESTINATION seam — the block cannot go INSIDE a list. The remedy
-  //     is to aim somewhere else, which is the exact opposite advice.
-  //   * OUT OF RUN — a list item may only move among its own §3.8 siblings.
-  //     The remedy is to stay inside its own list.
-  // Naming follows the BATCH_*_MESSAGE convention above. None of the three is
-  // a substring of another, of §4.3's own gate message, or of
-  // BLOCK_MOVE_ORPHAN_MESSAGE below — which is what lets a test assert WHICH
-  // refusal fired rather than that some banner mentioning 清單 appeared.
-  const BLOCK_MOVE_SOURCE_SEAM_MESSAGE = '移走這個區塊會讓上下兩串清單接在一起，無法搬移';
+  // The ⠿ drag's one remaining cross-boundary refusal: a drop onto a list
+  // item that owns no source line (the outer item of a same-line nest such
+  // as `- - b`) — there is no line to land in front of. v3.11 retired the
+  // other four (source seam, destination seam inside a list, out of the run,
+  // an orphaned landing): moveSpanAcrossLists() performs those moves instead.
+  // Not a substring of any other refusal in this file, which is what lets a
+  // test assert WHICH one fired.
   const BLOCK_MOVE_DEST_SEAM_MESSAGE = '無法把區塊放進清單項目之間';
-  const BLOCK_MOVE_OUT_OF_RUN_MESSAGE = '清單項目只能在所屬清單內搬移';
-  // S4 Task 7: what is LEFT of Task 4's indent refusal, and it is 14 drops out
-  // of 4067. §4.5's clamp is now performed (performListItemDrop() runs the
-  // removal half of the move through clampIndents()'s `{ removed: true }`),
-  // which answers every SOURCE-side orphan. What no removal-clamp can reach is
-  // the INSERTION half: a BATCH whose last member is SHALLOWER than the block
-  // it lands before leaves that block with no parent chain above it, at the
-  // NEW index, and §3.4 has no rule for that seam. MEASURED over every legal
-  // indent array of length 2..6 and depth 0..3, every operand-set size and
-  // every destination the run gate admits: 4067 drops, 1425 refused by Task
-  // 4's predicate, 14 still unanchored after the clamp — every one of them a
-  // multi-block set breaking at the block immediately after the landed set.
-  // (test/editor-client.test.js re-runs that sweep and pins all three numbers.)
-  //
-  // RE-WORDED with the narrowing, and the wording is the point: Task 4's
-  // 「搬移後子項目會失去上層項目，暫時無法搬移到這裡」 said "temporarily", which
-  // was true while the capability was missing and is a lie now that it is not.
-  // What is left is a DESTINATION objection with the same remedy
-  // BLOCK_MOVE_DEST_SEAM_MESSAGE has — aim somewhere else — so it says which
-  // end of the gesture is at fault. Still not a substring of any other refusal
-  // in this file, which is what lets a test assert WHICH one fired.
-  const BLOCK_MOVE_ORPHAN_MESSAGE = '落點的子項目會失去上層項目，無法搬移到這裡';
   // 轉換成's own refusals are NOT declared here. They are per block TYPE, and
   // they are the same ruling §3.7 applies to a single block's ⠿ — so they live
   // with that predicate, in BATCH_CONVERT_WITHHELD_MESSAGES above
   // toggleGutterMenu(), where the menu-hiding call site can share them. The
-  // four constants above are shape-level and belong to every batch operation.
+  // constants above are shape-level and belong to every batch operation.
 
   function blockElById(id) {
     return document.querySelector('.ed-block[data-block-id="' + id + '"]');
@@ -5728,9 +5717,11 @@
   //                                           null (dropped gesture, no source
   //                                           line, empty/gapped/no-element
   //                                           batch)
-  //   2. the mixed list/non-list refusal    (BATCH_MIXED_MESSAGE)
-  //   3. the withheld-type refusal          (BATCH_CONVERT_WITHHELD_MESSAGES)
-  //   4. `if (!liRun)`                      (BATCH_MULTIRUN_MESSAGE)
+  //   2. (v3.11: retired — a mixed / withheld / two-list span routes to
+  //      convertSpanAcrossLists(), which has its own exits below)
+  //   3. the all-withheld refusal           (BATCH_CONVERT_WITHHELD_MESSAGES)
+  //   4. `if (!liRun)`                      (BATCH_MULTIRUN_MESSAGE; now
+  //                                           unreachable, kept as a guard)
   //   5. `!listRunSupportsStructuralEdit()` (§4.1's run-wide gate)
   //   6. `if (!stripped.ok)`                (per-block 「此區塊的格式無法轉換」)
   // — six, not three, plus `result.op === null` (a commit that wrote nothing)
@@ -5776,41 +5767,20 @@
     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;
+    // §3.7 / §7 withhold 轉換成 from a table, an hr and a raw html block —
+    // toggleGutterMenu() hides the item outright on a single one of them.
+    // v3.11: a SPAN holding one converts its other members and keeps the
+    // withheld ones byte for byte, with a notice naming what was skipped
+    // (Notion skips what it cannot turn); a span mixing list items with other
+    // blocks, or taking items of two lists, converts as well. All three used
+    // to refuse (BATCH_MIXED_MESSAGE / BATCH_MULTIRUN_MESSAGE /
+    // BATCH_CONVERT_WITHHELD_MESSAGES). Before the withheld refusal existed a
+    // table span wrote '> | A | B |' … — convertSpanAcrossLists() never
+    // strips a withheld member, which is why it is the route for all of them.
+    // A span of ONLY withheld blocks still refuses: nothing in it converts.
+    if ((shape.anyLi && !shape.allLi) || shape.kinds.some(convertWithheldFor) ||
+        (shape.allLi && !batchRunOf(els))) {
+      return await convertSpanAcrossLists(els, recs, shape.kinds, target);
     }
 
     // §4.3's run-wide gate: 轉換／建立副本／刪除／拖曳 all pass through
@@ -5819,25 +5789,20 @@
     // is exactly what listRunOf() returns (the outermost run PLUS every
     // descendant of its members) — see deleteListItemsViaGutter()'s own note.
     //
-    // ORDERING IS LOAD-BEARING, not incidental. This sits AHEAD of the
-    // 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.
+    // It sits AHEAD of the per-target routing below, so a run the gate
+    // refuses (an unsupported shape) reports §4.1's
+    // 「此清單含不支援的格式，無法調整結構」 before anything else is tried.
     //
-    // 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.
+    // v3.11: { replaysTargets: true } — a multi-line li converts (a li→li
+    // change replays its bytes with the marker's column delta; li → non-list
+    // reads them from `lines` through stripMarker()), so §4.1 修訂 2's
+    // TARGET refusal no longer applies. S3 Task 6 passes the WHOLE operand set
+    // — every member is being rewritten, so every member clears the gate.
     let liRun = null;
     if (shape.allLi) {
       liRun = batchRunOf(els);
       if (!liRun) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); return; }
-      if (!listRunSupportsStructuralEdit(liRun, els)) { refuseStructuralListEdit(); return; }
+      if (!listRunSupportsStructuralEdit(liRun, els, { replaysTargets: true })) { refuseStructuralListEdit(); return; }
     }
 
     // S2 Task 3 / S3 Task 6: li → a LIST target. The blocks stay list items, so
@@ -6013,7 +5978,12 @@
     const els = operands.els;
     const recs = operands.recs;
     const shape = spanListKinds(els);
-    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+    // v3.11: a span mixing list items with other blocks, or taking items of
+    // two lists, duplicates too (it used to refuse with BATCH_MIXED_MESSAGE /
+    // BATCH_MULTIRUN_MESSAGE).
+    if ((shape.anyLi && !shape.allLi) || (shape.allLi && !batchRunOf(els))) {
+      return (await duplicateSpanAcrossLists(els, recs)) ? recs[0].startLine : undefined;
+    }
 
     if (shape.allLi) {
       // recs[0].startLine is unchanged by this commit — duplicateListItems()'s
@@ -6068,6 +6038,60 @@
   // of the four refusal exits — duplicateBlockViaMenu()'s wrapper needs to tell
   // a refusal (nothing was duplicated, the block is still where it was) apart
   // from a completed duplicate.
+  // v3.11: 建立副本 over a span that mixes list items with other blocks, or
+  // takes items of two lists. The copy is the span's own source lines,
+  // byte for byte, inserted after the span (after the last member's subtree
+  // when that member is a list item, like duplicateListItems()), in ONE
+  // commit. Where the copy meets a neighbour it joins tight when both sides
+  // are list items — the copied items rejoin the list, as in Notion — and is
+  // kept apart by a blank line otherwise.
+  async function duplicateSpanAcrossLists(els, recs) {
+    const first = recs[0];
+    const lastEl = els[els.length - 1];
+    let endRec = recs[recs.length - 1];
+    if (lastEl.getAttribute('data-block-type') === 'li') {
+      const sub = subtreeBlocksAfter(lastEl, Number(lastEl.getAttribute('data-indent')) || 0);
+      const subRec = sub.length ? blockRecOf(sub[sub.length - 1]) : null;
+      if (subRec) endRec = subRec;
+    }
+    const at = endRec.endLine;
+    const copy = lines.slice(first.startLine - 1, recs[recs.length - 1].endLine);
+    const isLi = (el) => !!el && el.getAttribute('data-block-type') === 'li';
+    const endEl = blockElById(endRec.id);
+    const nextRec = blocks[blocks.indexOf(endRec) + 1] || null;
+    const nextEl = nextRec ? blockElById(nextRec.id) : null;
+    const nextLine = at < lines.length ? String(lines[at]) : null;
+    const out = [];
+    const tightBefore = isLi(endEl) && isLi(els[0]);
+    if (!tightBefore) {
+      // A blank line in front: an indented first line would read as code, and
+      // an ordered item restarts its own count.
+      if (/^( {4}|\t)/.test(copy[0])) { refuseStructuralListEdit(); return false; }
+      if (isLi(els[0])) copy[0] = copy[0].replace(/^(\s*)\d+([.)])/, '$11$2');
+      out.push('');
+    }
+    out.push(...copy);
+    const tightAfter = isLi(lastEl) && isLi(nextEl) && nextLine !== null && nextLine.trim() !== '';
+    if (!tightAfter && nextLine !== null && nextLine.trim() !== '') out.push('');
+    const result = commitRangeEdit({ lines, blocks, stack }, at, at,
+      [lines[at - 1]].concat(out).join('\n'));
+    if (result.op === null) return false;
+    endBurstWithoutResolve();
+    const prevLines = lines;
+    lines = result.lines;
+    declareCollapse({ startLine: first.startLine, endLine: recs[recs.length - 1].endLine });
+    const editRange = result.op
+      ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
+          endLine: Math.max(result.op.startLine - 1, result.op.endLine),
+          delta: result.op.after.length - result.op.before.length }
+      : undefined;
+    if (!(await safeRerenderAll(editRange))) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+      return false;
+    }
+    return true;
+  }
+
   async function duplicateListItems(liEls, recs) {
     // Every list batch is one run's problem — see batchRunOf().
     const run = batchRunOf(liEls);
@@ -6079,7 +6103,7 @@
     // it adds the item's lines over again), so a multi-line li refuses as a
     // TARGET while remaining a perfectly good bystander — and in a batch EVERY
     // member is a target.
-    if (!listRunSupportsStructuralEdit(run, liEls)) { refuseStructuralListEdit(); return false; }
+    if (!listRunSupportsStructuralEdit(run, liEls, { replaysTargets: true })) { refuseStructuralListEdit(); return false; }
     // 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
@@ -6262,15 +6286,13 @@
     const els = operands.els;
     const recs = operands.recs;
     const shape = spanListKinds(els);
-    // 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;
-    }
+    // A mixed span that covers every list it touches WHOLE is one contiguous
+    // line range like any non-list span -- the commitRangeRemoval() branch
+    // below, one undo op. v3.11: a list covered only in PART (or items of two
+    // lists) no longer refuses — deleteSpanAcrossLists(), routed below once
+    // the caret landing has been read.
+    const acrossLists = (shape.anyLi && !shape.allLi && !listsCoveredWhole(els, recs)) ||
+      (shape.allLi && !batchRunOf(els));
     // 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
@@ -6302,6 +6324,10 @@
     // splice. S1 is what first put a ⠿ on a li, and the plain range removal
     // below corrupts a list three separate ways — see
     // deleteListItemsViaGutter() for the measurements and the routing.
+    if (acrossLists) {
+      return (await deleteSpanAcrossLists(els, recs))
+        ? { prevLine: prevLine, spanIsFirst: spanIsFirst } : undefined;
+    }
     if (shape.allLi) {
       return (await deleteListItemsViaGutter(els))
         ? { prevLine: prevLine, spanIsFirst: spanIsFirst } : undefined;
@@ -6371,6 +6397,94 @@
   // of its three refusal exits — deleteBlockViaGutter()'s wrapper needs to tell
   // a refusal (nothing was removed, the block is still where it was) apart from
   // a completed delete before it goes looking for a neighbour.
+  // v3.11: 刪除 over a span that cuts into one or more lists. ONE commit (one
+  // undo step) over the region from the first touched list's first line to
+  // the last touched list's last line: every touched list keeps its unselected
+  // items (re-serialized the way deleteListItemsViaGutter() does it, bystander
+  // bytes replayed), every other selected block is dropped. Two lists whose
+  // survivors end up adjacent join tight — Notion's behaviour; the serializer
+  // renumbers every ordered piece from 1, so the join is always well-formed.
+  async function deleteSpanAcrossLists(els, recs) {
+    const groups = [];
+    for (let i = 0; i < els.length; i++) {
+      const el = els[i];
+      if (el.getAttribute('data-block-type') !== 'li') continue;
+      let g = groups.find((x) => x.run.indexOf(el) !== -1);
+      if (!g) {
+        const run = listRunOf(el);
+        if (!run.length) { refuseStructuralListEdit(); return false; }
+        g = { run: run, targets: [] };
+        groups.push(g);
+      }
+      g.targets.push(el);
+    }
+    for (let i = 0; i < groups.length; i++) {
+      const g = groups[i];
+      if (!listRunSupportsStructuralEdit(g.run, g.targets, { replaysTargets: true })) {
+        refuseStructuralListEdit(); return false;
+      }
+      g.range = runRangeOfBlocks({ lines, blocks, stack }, g.run);
+      if (!g.range) return false;
+    }
+    let lo = recs[0].startLine;
+    let hi = recs[recs.length - 1].endLine;
+    groups.forEach((g) => { lo = Math.min(lo, g.range.startLine); hi = Math.max(hi, g.range.endLine); });
+    // Everything inside [lo, hi] must be either selected or one of a touched
+    // list's own lines — anything else would be silently lost, so refuse.
+    const inRun = (b) => groups.some((g) => b.startLine >= g.range.startLine && b.endLine <= g.range.endLine);
+    for (let i = 0; i < blocks.length; i++) {
+      const b = blocks[i];
+      if (b.endLine < lo || b.startLine > hi) continue;
+      const k = recs.indexOf(b);
+      if (k !== -1 && els[k].getAttribute('data-block-type') !== 'li' && inRun(b)) {
+        refuseStructuralListEdit(); return false;
+      }
+      if (k === -1 && !inRun(b)) { refuseStructuralListEdit(); return false; }
+    }
+    groups.forEach((g) => {
+      g.survivors = g.run.filter((el) => g.targets.indexOf(el) === -1);
+    });
+    mutateListRun(() => {
+      groups.forEach((g) => {
+        applyIndentClamp(g.run, g.targets, spanMinIndent(g.targets), { removed: true });
+        g.targets.forEach((el) => removeListItem(el));
+      });
+    });
+    const carry = bystanderCarryOver([].concat(...groups.map((g) => g.survivors)));
+    const pieces = groups
+      .map((g) => g.survivors.length ? serializeListEls(g.survivors, { carryOver: carry }).md : '')
+      .filter((piece) => piece !== '');
+    let md = pieces.join('\n');
+    if (md !== '') {
+      // A removed block at an edge of the region: keep the new text apart
+      // from a neighbour that is not a blank line.
+      const head = groups[0];
+      const tail = groups[groups.length - 1];
+      const startsInRun = head && head.range.startLine === lo && head.survivors.length;
+      const endsInRun = tail && tail.range.endLine === hi && tail.survivors.length;
+      if (!startsInRun && lo > 1 && String(lines[lo - 2]).trim() !== '') md = '\n' + md;
+      if (!endsInRun && hi < lines.length && String(lines[hi]).trim() !== '') md = md + '\n';
+    }
+    declareCollapse(null);
+    const result = md === ''
+      ? commitRangeRemoval({ lines, blocks, stack }, lo, hi)
+      : commitRangeEdit({ lines, blocks, stack }, lo, hi, md);
+    endBurstWithoutResolve();
+    const prevLines = lines;
+    if (result.op !== null) lines = result.lines;
+    const editRange = result.op
+      ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
+          endLine: Math.max(result.op.startLine - 1, result.op.endLine),
+          delta: result.op.after.length - result.op.before.length }
+      : undefined;
+    const ok = await safeRerenderAll(editRange);
+    if (!ok) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+      return false;
+    }
+    return true;
+  }
+
   async function deleteListItemsViaGutter(liEls) {
     // Every list batch is one run's problem — see batchRunOf().
     const run = batchRunOf(liEls);
@@ -6381,7 +6495,7 @@
     // 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 — and in a batch every member is a target.
-    if (!listRunSupportsStructuralEdit(run, liEls)) { refuseStructuralListEdit(); return false; }
+    if (!listRunSupportsStructuralEdit(run, liEls, { replaysTargets: true })) { refuseStructuralListEdit(); return false; }
     const range = runRangeOfBlocks({ lines, blocks, stack }, run);
     if (!range) return false;
     // §3.4 rule 3's batch anchor: the SMALLEST old indent in the set, never the
@@ -6557,6 +6671,162 @@
     };
   }
 
+  // v3.11: 轉換成 over a span the single-kind paths cannot take — list items
+  // mixed with other blocks, items of two lists, or a table / hr / html block
+  // among the members (those three have no content to re-host, so they are
+  // kept as they are and a notice says so — Notion skips what it cannot
+  // turn). ONE commit over the region from the first touched list's first
+  // line to the last touched list's last line: unselected items before the
+  // span (first list) and after it (last list) are re-serialized the way
+  // convertListItemsAway() does it, orphaned children clamped; every selected
+  // block is stripMarker() → emitAs()'d from its own source lines. A list
+  // target turns the members into one list (nested items keep their nesting,
+  // re-based on the first member); pieces that are list items on both sides
+  // of a seam join tight.
+  async function convertSpanAcrossLists(els, recs, kinds, target) {
+    const toList = convertMd.targetIsList(target);
+    const isLi = (el) => el.getAttribute('data-block-type') === 'li';
+    const groups = [];
+    for (let i = 0; i < els.length; i++) {
+      if (!isLi(els[i])) continue;
+      let g = groups.find((x) => x.run.indexOf(els[i]) !== -1);
+      if (!g) {
+        const run = listRunOf(els[i]);
+        if (!run.length) { refuseStructuralListEdit(); return; }
+        g = { run: run, targets: [] };
+        groups.push(g);
+      }
+      g.targets.push(els[i]);
+    }
+    for (let i = 0; i < groups.length; i++) {
+      const g = groups[i];
+      if (!listRunSupportsStructuralEdit(g.run, g.targets, { replaysTargets: true })) {
+        refuseStructuralListEdit(); return;
+      }
+      g.range = runRangeOfBlocks({ lines, blocks, stack }, g.run);
+      if (!g.range) return;
+    }
+    let lo = recs[0].startLine;
+    let hi = recs[recs.length - 1].endLine;
+    groups.forEach((g) => { lo = Math.min(lo, g.range.startLine); hi = Math.max(hi, g.range.endLine); });
+    const inRun = (b) => groups.some((g) => b.startLine >= g.range.startLine && b.endLine <= g.range.endLine);
+    for (let i = 0; i < blocks.length; i++) {
+      const b = blocks[i];
+      if (b.endLine < lo || b.startLine > hi) continue;
+      const k = recs.indexOf(b);
+      if (k !== -1 && !isLi(els[k]) && inRun(b)) { refuseStructuralListEdit(); return; }
+      if (k === -1 && !inRun(b)) { refuseStructuralListEdit(); return; }
+    }
+    // Unselected items may only sit BEFORE the span (in its first list) or
+    // AFTER it (in its last list) — the span is one contiguous line range.
+    const firstEl = els[0];
+    const lastEl = els[els.length - 1];
+    const allEls = allBlockEls();
+    const before = [];
+    const after = [];
+    for (let i = 0; i < groups.length; i++) {
+      const g = groups[i];
+      for (let j = 0; j < g.run.length; j++) {
+        const el = g.run[j];
+        if (g.targets.indexOf(el) !== -1) continue;
+        if (allEls.indexOf(el) < allEls.indexOf(firstEl)) before.push(el);
+        else if (allEls.indexOf(el) > allEls.indexOf(lastEl)) after.push(el);
+        else { refuseStructuralListEdit(); return; }
+      }
+    }
+
+    // The members, converted. A run of consecutive convertible members is one
+    // chunk; a withheld member is its own chunk, kept byte for byte.
+    const skipped = [];
+    const chunks = [];
+    let cur = null;
+    let level0 = null;
+    const ordinals = [];
+    for (let i = 0; i < els.length; i++) {
+      const src = lines.slice(recs[i].startLine - 1, recs[i].endLine);
+      if (convertWithheldFor(kinds[i])) {
+        if (skipped.indexOf(kinds[i]) === -1) skipped.push(kinds[i]);
+        chunks.push({ list: false, text: src.join('\n') });
+        cur = null;
+        ordinals.length = 0;
+        continue;
+      }
+      const stripped = convertMd.stripMarker(src, kinds[i]);
+      if (!stripped.ok) { refuseStructuralListEdit('此區塊的格式無法轉換'); return; }
+      if (!toList) {
+        chunks.push({ list: false, text: convertMd.emitAs(stripped.content, target, {}).join('\n') });
+        continue;
+      }
+      // Nesting, re-based so the first member sits at level 0 and no item
+      // is ever more than one level deeper than the one above it.
+      let level = isLi(els[i]) ? (Number(els[i].getAttribute('data-indent')) || 0) : 0;
+      if (level0 === null) level0 = level;
+      level = Math.max(0, level - level0);
+      if (!cur) { cur = { list: true, lines: [], prevLevel: -1 }; chunks.push(cur); ordinals.length = 0; }
+      level = Math.min(level, cur.prevLevel + 1);
+      cur.prevLevel = level;
+      ordinals.length = level + 1;
+      ordinals[level] = (ordinals[level] || 0) + 1;
+      const width = target === 'ol' ? 3 : 2;
+      const checked = /^\s*(?:[-*+]|\d+[.)])\s+\[[xX]\]/.test(src[0]);
+      cur.lines.push(...convertMd.emitAs(stripped.content, target,
+        { ordinal: ordinals[level], checked: checked, indentPrefix: ' '.repeat(level * width) }));
+    }
+    const middle = chunks.map((c) => (c.list ? { list: true, text: c.lines.join('\n') } : c));
+    if (skipped.length === middle.length) {
+      refuseStructuralListEdit(BATCH_CONVERT_WITHHELD_MESSAGES[skipped[0]]); return;
+    }
+
+    // Orphans after the span lose an ancestor that is no longer an item.
+    if (!toList && after.length && groups.length) {
+      const g = groups[groups.length - 1];
+      mutateListRun(() => {
+        applyIndentClamp(g.run, g.targets, spanMinIndent(g.targets), { operatedBecomes: { type: convertedBlockType(target) } });
+      });
+    }
+    const carry = bystanderCarryOver(before.concat(after));
+    const pieces = [];
+    if (before.length) pieces.push({ list: true, text: serializeListEls(before, { carryOver: carry }).md });
+    const midFrom = pieces.length;
+    pieces.push(...middle);
+    const midTo = pieces.length;
+    if (after.length) pieces.push({ list: true, text: serializeListEls(after, { carryOver: carry }).md });
+    const out = [];
+    let midStart = null;
+    let midEnd = null;
+    pieces.forEach((p, i) => {
+      if (i > 0) {
+        if (!(p.list && pieces[i - 1].list)) out.push('');
+      }
+      if (i === midFrom) midStart = out.length;
+      out.push(...p.text.split('\n'));
+      if (i === midTo - 1) midEnd = out.length - 1;
+    });
+    let lead = 0;
+    if (!before.length && lo > 1 && String(lines[lo - 2]).trim() !== '') { out.unshift(''); lead = 1; }
+    if (!after.length && hi < lines.length && String(lines[hi]).trim() !== '') out.push('');
+
+    const result = commitRangeEdit({ lines, blocks, stack }, lo, hi, out.join('\n'));
+    if (result.op === null) return;
+    endBurstWithoutResolve();
+    const prevLines = lines;
+    lines = result.lines;
+    declareCollapse({ startLine: lo + lead + midStart, endLine: lo + lead + midEnd });
+    const editRange = result.op
+      ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
+          endLine: Math.max(result.op.startLine - 1, result.op.endLine),
+          delta: result.op.after.length - result.op.before.length }
+      : undefined;
+    if (!(await safeRerenderAll(editRange))) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+      return;
+    }
+    if (skipped.length) {
+      showNotice('已略過無法轉換的區塊：' + skipped.map((k) => CONVERT_SKIP_LABELS[k]).join('、'));
+    }
+  }
+  const CONVERT_SKIP_LABELS = { table: '表格', hr: '分隔線', html: 'HTML 區塊' };
+
   async function convertListItemsType(liEls, run, recs, target) {
     const range = runRangeOfBlocks({ lines, blocks, stack }, run);
     if (!range) return;
@@ -6738,13 +7008,13 @@
     // 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);
+    if (before.length) pieces.push(serializeListEls(before, { carryOver: carry }).md);
     // 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);
+    if (after.length) pieces.push(serializeListEls(after, { carryOver: carry }).md);
     let md = pieces.join('\n\n');
 
     // §4.3 rule 1 at the RUN's own edges. Inside the range the '\n\n' joins
@@ -7146,7 +7416,7 @@
       // source range.
       const carry = bystanderCarryOver(runEls, editedLiEl);
       const { md: runMd, unsupported, unsupportedByLi, lineMeta } =
-        listMd.serializeBlocks(runEls, { carryOver: carry });
+        serializeListEls(runEls, { carryOver: carry });
       // Refuse if the EDITED li itself has unsupported inline content.
       // Show banner + teardown + rerenderAll (file is untouched, burst never
       // wrote to `lines`) + return false — this path does NOT fall back to
@@ -7172,7 +7442,15 @@
       const range = runRangeOfBlocks({ lines, blocks, stack }, runEls);
       if (!range) { endBurstWithoutResolve(); return true; }
       let commitMd, commitStart, commitEnd;
-      if (unsupported.length > 0) {
+      // v3.11: a LOOSE run used to reach this branch through its 'P' items,
+      // and a loose run holding a same-line nest ('- - b', an item with no
+      // line of its own) still has to: re-serializing the whole run re-emits
+      // that nest in its canonical multi-line form, which inside a loose list
+      // changes the rendered nesting (measured: '- - - b' came back with an
+      // escaped empty item). Committing only the edited item's lines keeps it.
+      const looseWithNest = runEls.some((el) => blockOwnsNoLine(el)) &&
+        runEls.some((el) => el.getAttribute('data-list-loose') === '1');
+      if (unsupported.length > 0 || looseWithNest) {
         // The run contains SOME unsupported content — commit only the edited
         // li's own line range so nothing else in the run is round-tripped
         // through the tight (blank-line-collapsed) runMd.
@@ -8006,7 +8284,7 @@
   async function commitListStructure(runEls, focusStartLine, caretToEnd, opts) {
     const span = runEls || [];
     const presetRange = opts && opts.presetRange;
-    const { md } = listMd.serializeBlocks(span, { carryOver: (opts && opts.carryOver) || null });
+    const { md } = serializeListEls(span, { carryOver: (opts && opts.carryOver) || null });
     // The run's line range is read back off its own li blocks' ids — which
     // requires at least one li to still BE there. A caller whose mutation
     // removed the run's last item therefore captures the range BEFORE mutating
@@ -8073,7 +8351,7 @@
     // can emit a different number of lines than a re-serialized one would (a
     // blank continuation is dropped on the re-serialize path but replayed
     // verbatim here), and this answer is an index INTO those lines.
-    const { lineMeta } = listMd.serializeBlocks(runEls, { carryOver: carryOver || null });
+    const { lineMeta } = serializeListEls(runEls, { carryOver: carryOver || null });
     // A provisional block (split's new item) has no id yet, so it cannot be
     // found by one — fall back to counting the lines emitted before it.
     if (targetId === null) {
@@ -8082,7 +8360,16 @@
       const before = runEls.slice(0, at).map((el) => el.getAttribute('data-block-id'));
       let n = 0;
       lineMeta.forEach((m) => { if (before.indexOf(m.blockId) !== -1) n++; });
-      return range.startLine + n;
+      // v3.11: a loose list's blank lines (lineMeta `blank`) sit between the
+      // items counted above and this one; they are lines too.
+      let k = 0;
+      let seen = 0;
+      while (k < lineMeta.length && seen < n) {
+        if (before.indexOf(lineMeta[k].blockId) !== -1) seen++;
+        k++;
+      }
+      while (k < lineMeta.length && lineMeta[k].blank) k++;
+      return range.startLine + k;
     }
     const idx = lineMeta.findIndex((m) => m.blockId === targetId);
     if (idx === -1) return null;
@@ -8169,13 +8456,21 @@
   // excluding a burst whose surface has actually been edited.
   function listRunSupportsStructuralEdit(runEls, targetEl, opts) {
     if (!runEls || !runEls.length) return false;
-    const res = listMd.serializeBlocks(runEls);
+    const res = serializeListEls(runEls);
     const multi = res.multiLineBlockIds || [];
     // Anything OTHER than MULTILINE still refuses run-wide, unchanged.
     for (let i = 0; i < res.unsupported.length; i++) {
       if (res.unsupported[i] !== 'MULTILINE') return false;
     }
     if (opts && opts.columnOnly) return true;
+    // v3.11: `replaysTargets` — the operation never re-serializes a target's
+    // CONTENT: it removes the target (delete), replays its source bytes
+    // (duplicate's copy carries the original's id into bystanderCarryOver();
+    // a li→li type change replays them with the marker's column delta), or
+    // reads them straight from `lines` (li → non-list, convert-md.js's
+    // stripMarker()). A multi-line target is then no different from a
+    // multi-line bystander, which has always been fine.
+    if (opts && opts.replaysTargets) return true;
     // 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
@@ -9122,6 +9417,114 @@
   // 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.
+  // v3.11: Tab / Shift+Tab over a span mixing list items with other blocks,
+  // or taking items of two lists. Each kind follows its own rule — items
+  // indent (indentListItemsBySelection()'s headroom and clamp, per list),
+  // headings change depth (changeHeadingDepthsInSpan()), paragraphs stay —
+  // in ONE commit over the region the touched lists span, which is what the
+  // old refusal said could not be done (two commits, two undo ops). Lists
+  // that are adjacent blocks (a marker change between them, no gap) move as
+  // one group, so an item of the second can land under an item of the first.
+  async function tabSpanAcrossLists(els, recs, dir) {
+    const isLi = (el) => el.getAttribute('data-block-type') === 'li';
+    const all = allBlockEls();
+    const groups = [];
+    for (let i = 0; i < els.length; i++) {
+      if (!isLi(els[i])) continue;
+      let g = groups.find((x) => x.run.indexOf(els[i]) !== -1);
+      if (!g) {
+        const run = listRunOf(els[i]);
+        if (!run.length) { refuseStructuralListEdit(); return; }
+        const prev = groups[groups.length - 1];
+        if (prev && all.indexOf(run[0]) === all.indexOf(prev.run[prev.run.length - 1]) + 1) {
+          prev.run = prev.run.concat(run);
+          g = prev;
+        } else {
+          g = { run: run, targets: [] };
+          groups.push(g);
+        }
+      }
+      g.targets.push(els[i]);
+    }
+    for (let i = 0; i < groups.length; i++) {
+      const g = groups[i];
+      if (!listRunSupportsStructuralEdit(g.run, g.targets, { columnOnly: true })) {
+        refuseStructuralListEdit(); return;
+      }
+      g.range = runRangeOfBlocks({ lines, blocks, stack }, g.run);
+      if (!g.range) return;
+    }
+    let lo = recs[0].startLine;
+    let hi = recs[recs.length - 1].endLine;
+    groups.forEach((g) => { lo = Math.min(lo, g.range.startLine); hi = Math.max(hi, g.range.endLine); });
+    const inRun = (b) => groups.some((g) => b.startLine >= g.range.startLine && b.endLine <= g.range.endLine);
+    for (let i = 0; i < blocks.length; i++) {
+      const b = blocks[i];
+      if (b.endLine < lo || b.startLine > hi) continue;
+      const k = recs.indexOf(b);
+      if (k !== -1 && !isLi(els[k]) && inRun(b)) { refuseStructuralListEdit(); return; }
+      if (k === -1 && !inRun(b)) { refuseStructuralListEdit(); return; }
+    }
+
+    let changed = false;
+    groups.forEach((g) => {
+      g.delta = batchIndentDelta(g.targets, dir);
+      if (g.delta !== 0) changed = true;
+    });
+    // Segments in document order: each list group re-serialized, each other
+    // member's own lines (a heading re-depthed). Whatever lies between two
+    // segments — blank lines, by the check above — is copied as it is.
+    const segs = [];
+    for (let i = 0; i < recs.length; i++) {
+      if (isLi(els[i])) continue;
+      const src = lines.slice(recs[i].startLine - 1, recs[i].endLine);
+      if (recs[i].type === 'heading' && /^#{1,6}(\s|$)/.test(src[0])) {
+        const depth = headingDepthOf(src[0]);
+        const next = Math.max(1, Math.min(6, depth + dir));
+        if (next !== depth) { src[0] = withHeadingDepth(src[0], next); changed = true; }
+      }
+      segs.push({ start: recs[i].startLine, end: recs[i].endLine, text: src });
+    }
+    if (!changed) return;
+    mutateListRun(() => {
+      groups.forEach((g) => {
+        if (g.delta === 0) return;
+        const oldIndent = spanMinIndent(g.targets);
+        g.targets.forEach((el) => setBlockIndent(el,
+          Math.max(0, (Number(el.getAttribute('data-indent')) || 0) + g.delta)));
+        applyIndentClamp(g.run, g.targets, oldIndent);
+      });
+    });
+    const carry = bystanderCarryOver([].concat(...groups.map((g) => g.run)), null);
+    groups.forEach((g) => {
+      segs.push({ start: g.range.startLine, end: g.range.endLine,
+        text: serializeListEls(g.run, { carryOver: carry }).md.split('\n') });
+    });
+    segs.sort((a, b) => a.start - b.start);
+    const out = [];
+    let at = lo;
+    segs.forEach((sg) => {
+      out.push(...lines.slice(at - 1, sg.start - 1));
+      out.push(...sg.text);
+      at = sg.end + 1;
+    });
+    out.push(...lines.slice(at - 1, hi));
+    const result = commitRangeEdit({ lines, blocks, stack }, lo, hi, out.join('\n'));
+    if (result.op === null) return;
+    endBurstWithoutResolve();
+    const prevLines = lines;
+    lines = result.lines;
+    declareCollapse({ startLine: recs[0].startLine, endLine: recs[recs.length - 1].endLine });
+    const editRange = result.op
+      ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
+          endLine: Math.max(result.op.startLine - 1, result.op.endLine),
+          delta: result.op.after.length - result.op.before.length }
+      : undefined;
+    if (!(await safeRerenderAll(editRange))) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
   async function changeHeadingDepthsInSpan(els, recs, dir) {
     const first = recs[0];
     const last = recs[recs.length - 1];
@@ -9179,13 +9582,14 @@
     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; }
+    // v3.11: a span mixing both kinds applies each rule to its own kind (the
+    // S3 plan's Task 7 text) in ONE commit — tabSpanAcrossLists() — so §3.4's
+    // 「一次使用者手勢 = 恰好一個 undo op」 holds; so does a span taking items of
+    // two lists. Both used to refuse (§3.6's 2026-08-31 ruling, which only
+    // stood because the combined commit did not exist).
+    if ((shape.anyLi && !shape.allLi) || (shape.allLi && !batchRunOf(els))) {
+      await tabSpanAcrossLists(els, recs, dir); return;
+    }
     if (shape.allLi) { await indentListItemsBySelection(els, recs, dir); return; }
     await changeHeadingDepthsInSpan(els, recs, dir);
   }
@@ -11649,7 +12053,7 @@
     if (!liveTableEl) return;
     const headerRow = headerRowOf(liveTableEl);
     if (!headerRow || headerRow.cells.length <= 1) {
-      showNotice('無法刪除最後一欄');
+      showNotice('這是表格的最後一欄。要刪除整張表格，請用 ⠿ → 刪除。');
       return;
     }
     currentBurst.history.snap('delete-col-pre');
@@ -11676,12 +12080,28 @@
     if (!liveTableEl) return;
     const liveRowEl = rowIndex >= 0 ? allRowsOf(liveTableEl)[rowIndex] : null;
     if (!liveRowEl) return;
+    // v3.11 (Notion does what the gesture says): deleting the header row
+    // promotes the first body row into it; with no body rows left the table
+    // has nothing to keep, so the whole table block goes. The last BODY row
+    // goes like any other — a header-only table is valid GFM.
     if (liveRowEl === headerRowOf(liveTableEl)) {
-      showNotice('無法刪除標題列');
-      return;
-    }
-    if (bodyRowsOf(liveTableEl).length <= 1) {
-      showNotice('無法刪除最後一列');
+      const firstBody = bodyRowsOf(liveTableEl)[0];
+      if (!firstBody) {
+        hideTableEdgeMenu();
+        const tableBlockEl = liveTableEl.closest('.ed-block');
+        if (tableBlockEl) await deleteBlockViaGutter(tableBlockEl);
+        return;
+      }
+      currentBurst.history.snap('delete-header-pre');
+      const head = liveRowEl.cells;
+      for (let i = 0; i < head.length; i++) {
+        const src = firstBody.cells[i];
+        head[i].innerHTML = src ? src.innerHTML : '';
+      }
+      refocusAwayFromRow(liveTableEl, firstBody);
+      deleteRow(firstBody);
+      currentBurst.history.snap('delete-header');
+      hideTableEdgeMenu();
       return;
     }
     currentBurst.history.snap('delete-row-pre');
@@ -12220,12 +12640,10 @@
     // v3.0.1 (spec §4.2 hit-test conflict 2 — see the geometry note above
     // buildTableGrip() for the S4 T1 detour into an inset grip and how it
     // was undone), vertically centred on its own row; no
-    // header special case. The
-    // one exception is a header-only table (no body rows): its single row
-    // is thead's only row, and dragging it away would empty the thead —
-    // serializeTable() would degrade it and the user's table would vanish
-    // from the page. Withhold the grip there instead.
-    if (rowEl && (rowEl !== headerRow || bodyRowsOf(tableEl).length > 0)) {
+    // header special case. v3.11: that includes a header-only table — its
+    // grip opens the row menu (刪除列 there removes the table); the DRAG is
+    // what must not empty the thead, and performRowDrop() refuses it.
+    if (rowEl) {
       gripRowTableEl = tableEl;
       gripRowEl = rowEl;
       const r = rowEl.getBoundingClientRect();
@@ -12547,6 +12965,8 @@
     // land on the header cell.
     const liveTableEl = await ensureTableBurstOpen(tableEl, true);
     if (!liveTableEl) return;
+    // A header-only table has nowhere to move its one row to.
+    if (!bodyRowsOf(liveTableEl).length) return;
     const liveRows = allRowsOf(liveTableEl);
     if (rowIndex < 0 || !liveRows[rowIndex]) return;
 
@@ -13060,23 +13480,12 @@
     // SECOND home position of its own — see performListItemDrop().
     if (liveDestEl && opEls.indexOf(liveDestEl) !== -1) return;
     const shape = spanListKinds(opEls);
-    // §3.6's 2026-08-31 ruling, and the EXISTING banner: 「混合 span 一律拒絕」.
-    // A mixed span would need a blank-line rule at the run/non-run seam — the
-    // li half has to stay tight while the non-li half has to keep its
-    // separators, and inside ONE commit range those two demands conflict. §3.6
-    // records that the spec does not have that rule and that inventing it in
-    // the last stage repeats the §3.4 marker-width error, so this refuses with
-    // 建立副本 / 刪除 / 轉換's own message rather than a fifth move message.
-    //
-    // DELIBERATELY ABOVE the second home position, which is the one place this
-    // function departs from Task 3's "answer a home position before every
-    // gate" rule, and the departure is the point: a seam objection depends on
-    // where the user AIMED, so refusing a put-it-back gesture with one would
-    // be a banner for a gesture in which nothing went wrong. MIXED is a
-    // property of the SET — it gives the same answer at every destination, so
-    // there is no aim that would have worked and saying so is the honest
-    // outcome. (The drop-on-a-member case is already out, above.)
-    if (shape.anyLi && !shape.allLi) { refuseStructuralListEdit(BATCH_MIXED_MESSAGE); return; }
+    // v3.11: a span mixing list items with other blocks moves too. It used to
+    // refuse (§3.6's 2026-08-31 ruling: the blank-line rule at the run/non-run
+    // seam had no answer). moveSpanAcrossLists() gives it one — list items in
+    // a row are serialized as one tight list, everything else keeps its own
+    // separators or gets one blank line — so the set has a destination.
+    if (shape.anyLi && !shape.allLi) { await moveSpanAcrossLists(opEls, liveDestEl); return; }
     // S4 Task 4 / Task 6: a li source has its own path. Its lines cannot be
     // relocated verbatim (markers and ordinals are run-global), so the whole
     // run is re-serialized in the new span order instead — still ONE
@@ -13176,12 +13585,11 @@
     const seamRefusal = blockMoveSeamRefusal(
       { prev: seamDesc(live[si - 1]), next: seamDesc(live[sj + 1]) },
       { prev: seamDesc(rest[di - 1]), next: seamDesc(rest[di]) });
-    if (seamRefusal === 'source') {
-      refuseStructuralListEdit(BLOCK_MOVE_SOURCE_SEAM_MESSAGE);
-      return;
-    }
-    if (seamRefusal === 'destination') {
-      refuseStructuralListEdit(BLOCK_MOVE_DEST_SEAM_MESSAGE);
+    // v3.11: neither seam refuses any more. Two lists that meet once this
+    // block has left join; a block dropped between two items splits the list.
+    // Both need list items re-serialized, so they take moveSpanAcrossLists().
+    if (seamRefusal === 'source' || seamRefusal === 'destination') {
+      await moveSpanAcrossLists(opEls, liveDestEl);
       return;
     }
     const result = commitBlockMove({ lines, blocks, stack }, srcRec, destRec);
@@ -13268,6 +13676,191 @@
   // contiguous slice of the document (listRunOf()'s own contract), so the
   // members occupy CONSECUTIVE slots of `run` and "move them" is one call to
   // reorderSpanRange() with a count instead of two paths.
+  // v3.11: the ⠿ drop the narrower paths used to refuse — a paragraph into
+  // the middle of a list (it splits), a list item out of its list or into
+  // another one (it leaves / joins), a block whose removal makes two lists
+  // meet (they join), a span mixing list items with other blocks, or items
+  // of two lists. A list item takes its subtree along, as in Notion.
+  //
+  // ONE commit over the region the move touches: the moved span, the blocks
+  // on either side of where it left and where it lands, and every list any of
+  // those belongs to, whole. Inside it the blocks are laid out in their new
+  // order; each maximal run of consecutive list items is re-serialized as one
+  // list (serializeBlocks(), bystander bytes replayed, indents clamped so no
+  // item is more than one level below the one above it), every other block
+  // is its own source lines. Two blocks that were already neighbours keep the
+  // lines that separated them; new neighbours get one blank line.
+  async function moveSpanAcrossLists(opEls, destEl) {
+    const all = allBlockEls();
+    const isLi = (el) => !!el && el.getAttribute('data-block-type') === 'li';
+    const indentOf = (el) => Number(el.getAttribute('data-indent')) || 0;
+    const opLi = opEls.filter(isLi);
+    const minLi = opLi.length ? spanMinIndent(opLi) : 0;
+    const moving = opEls.slice();
+    if (opLi.length) {
+      subtreeBlocksAfter(moving[moving.length - 1], minLi).forEach((el) => {
+        if (moving.indexOf(el) === -1) moving.push(el);
+      });
+    }
+    const firstIdx = all.indexOf(moving[0]);
+    const lastIdx = all.indexOf(moving[moving.length - 1]);
+    if (firstIdx < 0 || lastIdx - firstIdx + 1 !== moving.length) {
+      showError(DROPPED_GESTURE_MESSAGE, null, null); return;
+    }
+    if (destEl && moving.indexOf(destEl) !== -1) return;
+    const rest = all.filter((el) => moving.indexOf(el) === -1);
+    const di = destEl ? rest.indexOf(destEl) : rest.length;
+    if (di < 0) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    if (di === firstIdx) return; // dropped where it already is
+
+    // The region: indices into `all`, widened until every list it touches is
+    // inside it whole.
+    const touched = moving.concat([all[firstIdx - 1], all[lastIdx + 1], rest[di - 1], rest[di]])
+      .filter(Boolean);
+    let lo = Math.min(...touched.map((el) => all.indexOf(el)));
+    let hi = Math.max(...touched.map((el) => all.indexOf(el)));
+    for (let grew = true; grew;) {
+      grew = false;
+      for (let k = lo; k <= hi; k++) {
+        if (!isLi(all[k])) continue;
+        const run = listRunOf(all[k]);
+        if (!run.length) continue;
+        const a = all.indexOf(run[0]);
+        const b = all.indexOf(run[run.length - 1]);
+        if (a < lo) { lo = a; grew = true; }
+        if (b > hi) { hi = b; grew = true; }
+      }
+    }
+    const regionEls = all.slice(lo, hi + 1);
+    for (let k = 0; k < regionEls.length; k++) {
+      if (blockOwnsNoLine(regionEls[k])) { refuseStructuralListEdit(noSourceLineMessageFor(regionEls[k])); return; }
+      if (!blockRecOf(regionEls[k])) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    }
+    const seenRuns = [];
+    const runOf = new Map(); // each item's list BEFORE the move
+    for (let k = 0; k < regionEls.length; k++) {
+      if (!isLi(regionEls[k]) || runOf.has(regionEls[k])) continue;
+      const run = listRunOf(regionEls[k]);
+      seenRuns.push(run);
+      run.forEach((el) => runOf.set(el, run));
+      if (!listRunSupportsStructuralEdit(run, null, { columnOnly: true })) { refuseStructuralListEdit(); return; }
+    }
+
+    // The new order.
+    const restRegion = regionEls.filter((el) => moving.indexOf(el) === -1);
+    const at = destEl ? restRegion.indexOf(destEl) : restRegion.length;
+    if (at < 0) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    const seq = restRegion.slice(0, at).concat(moving, restRegion.slice(at));
+    // Indents: a moved item lands at the level of the item it is dropped in
+    // front of (top level otherwise), keeping its own subtree's shape; then
+    // every item is clamped to at most one level below the item above it.
+    const base = isLi(destEl) ? indentOf(destEl) : 0;
+    const want = new Map();
+    let prev = -1;
+    seq.forEach((el) => {
+      if (isLi(el)) {
+        let ind = moving.indexOf(el) !== -1 ? base + (indentOf(el) - minLi) : indentOf(el);
+        ind = Math.max(0, Math.min(ind, prev + 1));
+        want.set(el, ind);
+        prev = ind;
+      } else {
+        prev = -1;
+      }
+    });
+    const firstRec = blockRecOf(regionEls[0]);
+    const lastRec = blockRecOf(regionEls[regionEls.length - 1]);
+    const carry = bystanderCarryOver(seq.filter(isLi));
+    const origIndent = new Map(seq.filter(isLi).map((el) => [el, indentOf(el)]));
+    mutateListRun(() => {
+      seq.forEach((el, k) => {
+        if (isLi(el)) {
+          if (want.get(el) !== indentOf(el)) setBlockIndent(el, want.get(el));
+          // A list boundary survives only where the same two blocks still meet.
+          const before = seq[k - 1];
+          if (isLi(before) && all[all.indexOf(el) - 1] !== before) el.removeAttribute('data-list-start');
+        }
+      });
+    });
+
+    const out = [];
+    const movedIds = moving.map((el) => el.getAttribute('data-block-id'));
+    let movedFrom = null;
+    let movedTo = null;
+    const mark = (id, idx) => {
+      if (movedIds.indexOf(id) !== -1) {
+        if (movedFrom === null || idx < movedFrom) movedFrom = idx;
+        if (movedTo === null || idx > movedTo) movedTo = idx;
+      }
+    };
+    // Two items that were already neighbours in two DIFFERENT lists stay two
+    // lists, with whatever separated them.
+    const keepsApart = (x, y) => all[all.indexOf(x) + 1] === y && runOf.get(x) !== runOf.get(y);
+    let lastEl = null;
+    for (let k = 0; k < seq.length;) {
+      let unit;
+      let unitLines;
+      let meta = null;
+      if (isLi(seq[k])) {
+        let j = k + 1;
+        while (j < seq.length && isLi(seq[j]) && !keepsApart(seq[j - 1], seq[j])) j++;
+        unit = seq.slice(k, j);
+        const orig = runOf.get(unit[0]);
+        if (orig && orig.length === unit.length && orig.every((el, n) => el === unit[n] &&
+            moving.indexOf(el) === -1 && want.get(el) === origIndent.get(el))) {
+          // A list the move did not touch keeps its own bytes.
+          const r0 = blockRecOf(unit[0]);
+          const r1 = blockRecOf(unit[unit.length - 1]);
+          unitLines = lines.slice(r0.startLine - 1, r1.endLine);
+        } else {
+          const res = serializeListEls(unit, { carryOver: carry });
+          unitLines = res.md.split('\n');
+          meta = res.lineMeta;
+        }
+        k = j;
+      } else {
+        unit = [seq[k]];
+        const r = blockRecOf(seq[k]);
+        unitLines = lines.slice(r.startLine - 1, r.endLine);
+        k++;
+      }
+      if (lastEl) {
+        const a = blockRecOf(lastEl);
+        const b = blockRecOf(unit[0]);
+        if (all[all.indexOf(lastEl) + 1] === unit[0]) out.push(...lines.slice(a.endLine, b.startLine - 1));
+        else out.push('');
+      }
+      const base0 = out.length;
+      unitLines.forEach((l, n) => {
+        mark(meta ? (meta[n] && meta[n].blockId) : unit[0].getAttribute('data-block-id'), base0 + n);
+      });
+      out.push(...unitLines);
+      lastEl = unit[unit.length - 1];
+    }
+    let lead = 0;
+    if (seq[0] !== regionEls[0] && firstRec.startLine > 1 &&
+        String(lines[firstRec.startLine - 2]).trim() !== '') { out.unshift(''); lead = 1; }
+    if (seq[seq.length - 1] !== regionEls[regionEls.length - 1] && lastRec.endLine < lines.length &&
+        String(lines[lastRec.endLine]).trim() !== '') out.push('');
+
+    const result = commitRangeEdit({ lines, blocks, stack }, firstRec.startLine, lastRec.endLine, out.join('\n'));
+    if (result.op === null) return;
+    endBurstWithoutResolve();
+    const prevLines = lines;
+    lines = result.lines;
+    if (movedFrom !== null) {
+      declareCollapse({ startLine: firstRec.startLine + lead + movedFrom,
+        endLine: firstRec.startLine + lead + movedTo });
+    }
+    const editRange = result.op
+      ? { startLine: Math.min(result.op.startLine, result.op.endLine + 1),
+          endLine: Math.max(result.op.startLine - 1, result.op.endLine),
+          delta: result.op.after.length - result.op.before.length }
+      : undefined;
+    if (!(await safeRerenderAll(editRange))) {
+      lines = rollbackFailedRender({ lines, stack }, result, prevLines);
+    }
+  }
+
   async function performListItemDrop(liEls, destEl) {
     const liEl = liEls[0];
     const lastLiEl = liEls[liEls.length - 1];
@@ -13287,7 +13880,8 @@
     // convertBlockViaMenu() gives, through the same message: the commit
     // re-serializes ONE run's line range and a member outside it would be
     // rewritten by a range that does not cover it.
-    if (srcIdxs.indexOf(-1) !== -1) { refuseStructuralListEdit(BATCH_MULTIRUN_MESSAGE); return; }
+    // v3.11: items of two lists move together through moveSpanAcrossLists().
+    if (srcIdxs.indexOf(-1) !== -1) { await moveSpanAcrossLists(liEls, destEl); return; }
     // ...and they must be CONSECUTIVE slots of it. Guaranteed today by
     // spanIsContiguous() plus listRunOf() returning a contiguous slice, and
     // checked anyway rather than asserted in prose: reorderSpanRange() takes a
@@ -13356,7 +13950,9 @@
     // {mode:'append'} target when a block follows the run. Task 5 gave them
     // their own message — the remedy is "stay inside your own list", which
     // neither seam message says.
-    if (insertAt < 0) { refuseStructuralListEdit(BLOCK_MOVE_OUT_OF_RUN_MESSAGE); return; }
+    // v3.11: out of its own list — into another list, or anywhere else —
+    // used to refuse with BLOCK_MOVE_OUT_OF_RUN_MESSAGE.
+    if (insertAt < 0) { await moveSpanAcrossLists(liEls, destEl); return; }
     // `null` is the order-is-unchanged answer — the two home positions above
     // reach this by another road (an item whose next block is a sibling), and
     // it stays SILENT for the same reason.
@@ -13419,7 +14015,9 @@
       indent: clamped.has(el) ? clamped.get(el)
         : (Number(el.getAttribute('data-indent')) || 0),
     })))) {
-      refuseStructuralListEdit(BLOCK_MOVE_ORPHAN_MESSAGE);
+      // v3.11: the generic move re-anchors instead of refusing (its indent
+      // clamp keeps every item within one level of the item above it).
+      await moveSpanAcrossLists(liEls, destEl);
       return;
     }
     // S4 review round (2026-09-01): this WRITE is load-bearing, and it took a
@@ -13499,7 +14097,7 @@
   function movedLiRangeAfterReorder(span, liEls, carryOver, range) {
     const ids = liEls.map((el) => el.getAttribute('data-block-id'));
     if (ids.indexOf(null) !== -1) return null;
-    const { lineMeta } = listMd.serializeBlocks(span, { carryOver: carryOver || null });
+    const { lineMeta } = serializeListEls(span, { carryOver: carryOver || null });
     let first = -1;
     let last = -1;
     lineMeta.forEach((m, i) => {
@@ -13724,17 +14322,10 @@
     }
     // A plain press-release with no drag threshold crossed: open the menu
     // for whatever zone was hit at pointerdown.
+    // v3.11: the header row's grip opens the same menu — deleting the header
+    // promotes the first body row (runDeleteRow()).
     if (st.hit.kind === 'col') showColumnMenu(st.hit.tableEl, st.hit.colIndex);
-    else if (st.hit.isHeader) {
-      // The row menu's only item is "delete row", and the header row can
-      // never be deleted — showing it would just be an empty box. A plain
-      // click on the header grip highlights the row instead.
-      // clearEdgeHighlight() runs first so re-clicking a different header
-      // (or a different row's menu having been open) doesn't stack
-      // highlights within the same session.
-      clearEdgeHighlight();
-      highlightRow(st.hit.rowEl);
-    } else showRowMenu(st.hit.tableEl, st.hit.rowEl);
+    else showRowMenu(st.hit.tableEl, st.hit.rowEl);
   });
 
   // Review fix (Critical): the browser/OS can ABORT a gesture outright —