@helping-ai-workflow/md2doc 3.9.1 → 3.11.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++) {
@@ -731,7 +731,7 @@
   const toolbarModel = window.md2docToolbarModel;
   const pasteMd = window.md2docPasteMd;
   const assetLib = window.md2docAsset;
-  const docSourceLib = window.md2docDocSource;
+  const icons = window.md2docIcons;
   let lines = ED.lines, blocks = ED.blocks, mtimeMs = ED.mtimeMs;
   let lastParts = null;
   // v3.4.0 batch2 Task 6 fix round 1 (review F1) — true while `lastParts` is
@@ -1146,6 +1146,7 @@
 
   function setDirty() {
     document.title = (documentIsDirty() ? '● ' : '') + baseTitle;
+    paintSaveStatus(documentIsDirty() ? 'dirty' : 'clean');
   }
 
   // setDirty() is push-driven: something has to call it. MEASURED by keeping
@@ -1202,9 +1203,9 @@
   }
 
   // ── banners (conflict / render-failed / save-failed) ──────────────────
-  // One shared, dismissible banner element. `actionLabel`+`onAction` add an
-  // extra button ahead of the always-present ✕ dismiss button (e.g. the
-  // conflict banner's "Reload"); omit them for a plain dismiss-only notice.
+  // One shared banner element. `actionLabel`+`onAction` add an extra button
+  // ahead of the ✕ (e.g. the conflict card's 重新載入). Since v3.10.0 callers
+  // go through showError() / showNotice() below; only an error card has a ✕.
   let activeBanner = null;
   // Review recommendation 5 (2026-08-31): whether the banner on screen is a
   // structural REFUSAL — 「無法整批操作」 and its siblings — as opposed to a
@@ -1223,7 +1224,7 @@
   // dismissKeynavExitBanner()'s own comment for why Escape, specifically,
   // is the only OTHER thing allowed to clear it.
   let activeBannerIsKeynavExit = false;
-  function showBanner(message, actionLabel, onAction) {
+  function showBanner(message, actionLabel, onAction, level) {
     if (activeBanner) { activeBanner.remove(); activeBanner = null; }
     // Reset unconditionally: refuseStructuralListEdit() sets it back to true
     // straight after its own call, so every OTHER caller gets false without
@@ -1265,7 +1266,20 @@
     closeToolbarMenu();
     const el = document.createElement('div');
     el.className = 'ed-conflict';
+    // v3.10.0 (spec §5.2): two levels on the one .ed-conflict element (tests
+    // and every dismiss path find banners by that class). 'error' is a card
+    // under the toolbar that stays until closed (role alert): a problem that
+    // can lose or skip an edit. 'notice' is a small box at the bottom that
+    // fades after 4 seconds (role status): a refusal or an explanation.
+    const lv = level === 'notice' ? 'notice' : 'error';
+    el.setAttribute('data-level', lv);
+    el.setAttribute('role', lv === 'error' ? 'alert' : 'status');
+    const ico = document.createElement('span');
+    ico.className = 'ed-msg-ico';
+    ico.innerHTML = icons.svg(lv === 'error' ? 'circle-alert' : 'info', 18);
+    el.appendChild(ico);
     const msg = document.createElement('span');
+    msg.className = 'ed-msg-text';
     msg.textContent = message;
     el.appendChild(msg);
     if (actionLabel && onAction) {
@@ -1277,22 +1291,38 @@
     }
     const dismissBtn = document.createElement('button');
     dismissBtn.type = 'button';
-    dismissBtn.textContent = '✕';
-    dismissBtn.setAttribute('aria-label', 'Dismiss');
-    dismissBtn.addEventListener('click', () => {
-      el.remove();
-      if (activeBanner === el) {
-        activeBanner = null;
-        activeBannerIsRefusal = false;
-        activeBannerIsSwallow = false;
-        activeBannerIsKeynavExit = false;
-      }
-    });
-    el.appendChild(dismissBtn);
+    dismissBtn.className = 'ed-msg-x';
+    dismissBtn.innerHTML = icons.svg('x', 16);
+    dismissBtn.setAttribute('aria-label', '關閉');
+    dismissBtn.addEventListener('click', () => dismissBannerEl(el));
+    // A notice has no close button: it goes away by itself.
+    if (lv === 'error') el.appendChild(dismissBtn);
     document.body.appendChild(el);
     activeBanner = el;
+    if (lv === 'notice') {
+      // The fade runs the SAME cleanup the ✕ does, so the flags above go back
+      // to "no banner" and the next Escape is not swallowed by a stale one
+      // (Review Focus 3). Hovering pauses it; leaving gives at least 0.8s back.
+      let left = 4000; let t0 = Date.now(); let timer = setTimeout(() => dismissBannerEl(el), left);
+      el.addEventListener('mouseenter', () => { clearTimeout(timer); left -= Date.now() - t0; });
+      el.addEventListener('mouseleave', () => { t0 = Date.now(); timer = setTimeout(() => dismissBannerEl(el), Math.max(left, 800)); });
+    }
     return el;
   }
+  // The one way a banner leaves the screen by the user's hand or by its own
+  // timer: scoped to THIS element, so a newer banner that has replaced it is
+  // left alone (and its flags with it).
+  function dismissBannerEl(el) {
+    el.remove();
+    if (activeBanner === el) {
+      activeBanner = null;
+      activeBannerIsRefusal = false;
+      activeBannerIsSwallow = false;
+      activeBannerIsKeynavExit = false;
+    }
+  }
+  function showError(message, actionLabel, onAction) { return showBanner(message, actionLabel, onAction, 'error'); }
+  function showNotice(message) { return showBanner(message, null, null, 'notice'); }
 
   // Task 9 review I3: MEASURED AT THE TIME — `.ed-conflict` was
   // `position:fixed; top:0; z-index:999` against `.ed-toolbar`'s
@@ -1341,12 +1371,8 @@
   }
 
   function showConflictBanner() {
-    showBanner(
-      'File changed on disk — reload to pick up external edits ' +
-      '(your unsaved changes will be lost).',
-      'Reload',
-      () => location.reload()
-    );
+    showError('這個檔案剛在別處被修改。重新載入會帶入新內容，並捨棄你在這裡還沒儲存的變更。',
+      '重新載入', () => location.reload());
   }
 
   // F10 ——「一道沒閉合的圍欄把後面的內容吃掉了」那一句，單獨一個常數。
@@ -1547,24 +1573,24 @@
         body: JSON.stringify({ fileId: ED.fileId, content: lines.join('\n') }),
       });
     } catch (e) {
-      showBanner('Render failed — network error (' + describeFailure(e) +
-        '). Your edit was not applied.', null, null);
+      showError('這次修改沒有套用：連不到編輯伺服器（' + describeFailure(e) +
+        '）。文件維持修改前的樣子。', null, null);
       return false;
     }
     if (!res.ok) {
       const reason = await describeHttpFailure(res);
-      showBanner('Render failed — ' + reason + '. Your edit was not applied.', null, null);
+      showError('這次修改沒有套用：' + reason + '。文件維持修改前的樣子。', null, null);
       return false;
     }
     let j;
     try {
       j = await res.json();
     } catch (e) {
-      showBanner('Render failed — malformed server response. Your edit was not applied.', null, null);
+      showError('這次修改沒有套用：伺服器回傳的內容無法解析。文件維持修改前的樣子。', null, null);
       return false;
     }
     if (!Array.isArray(j.parts) || !Array.isArray(j.blocks)) {
-      showBanner('Render failed — malformed server response. Your edit was not applied.', null, null);
+      showError('這次修改沒有套用：伺服器回傳的內容無法解析。文件維持修改前的樣子。', null, null);
       return false;
     }
     // Past every failure exit: this render is going to happen, so whatever
@@ -1775,7 +1801,7 @@
     // 者【現在看到的】那份文件。applyPatch()／applyFullRender() 自己不呼叫
     // showBanner()，所以這一句不會被同一次 render 裡的另一句蓋掉。
     if (swallowed) {
-      showBanner(SWALLOW_MESSAGE, null, null);
+      showError(SWALLOW_MESSAGE, null, null);
       activeBannerIsSwallow = true;   // 順序同 refuseStructuralListEdit()：
                                       // showBanner() 自己會把旗標歸零。
     } else if (!nowUnclosed) {
@@ -2568,8 +2594,8 @@
     try {
       return await rerenderAll(editRange);
     } catch (e) {
-      showBanner('Render failed — unexpected error (' + describeFailure(e) +
-        '). Your edit was not applied.', null, null);
+      showError('這次修改沒有套用：發生未預期的錯誤（' + describeFailure(e) +
+        '）。文件維持修改前的樣子。', null, null);
       return false;
     }
   }
@@ -3292,20 +3318,20 @@
   // listRunSupportsStructuralEdit() — see its comment for why this is a
   // parameter and not a second function). One constant so both call sites
   // stay byte-identical instead of two hand-typed copies drifting apart.
-  const NO_SOURCE_LINE_MESSAGE = '此項目沒有自己的來源行，無法刪除或直接編輯';
+  const NO_SOURCE_LINE_MESSAGE = '此項目沒有自己的來源行，無法在這裡刪除或編輯。請用文字編輯器修改，存檔後這裡會自動更新。';
   // T7 fix round 1 (LOW-2): insertBlockBelow()'s own wording. A second
   // constant rather than a reuse, because the one above NAMES the two
   // operations it refuses — an insert that answered '無法刪除' would be
   // telling the user something that is not true of the button they pressed.
-  const NO_SOURCE_LINE_INSERT_MESSAGE = '此項目沒有自己的來源行，無法在其後插入區塊';
+  const NO_SOURCE_LINE_INSERT_MESSAGE = '此項目沒有自己的來源行，無法在其後插入。請用文字編輯器修改，存檔後這裡會自動更新。';
   // The degraded-subtree wording (see blockRangeIsUnlocatable() above). Each
   // one NAMES ITS OPERATION exactly as the pair above does — that is the whole
   // reason the pair above is a pair — and differs from it only in the clause
   // that states the cause. Deliberately says nothing about the refusal being
   // temporary: nothing lifts it, so wording like 「已暫停」 would promise a state
   // change that never comes.
-  const UNLOCATABLE_LINE_MESSAGE = '這段巢狀清單對不到自己的來源行，無法刪除或直接編輯';
-  const UNLOCATABLE_LINE_INSERT_MESSAGE = '這段巢狀清單對不到自己的來源行，無法在其後插入區塊';
+  const UNLOCATABLE_LINE_MESSAGE = '這段巢狀清單對不到自己的來源行，無法在這裡刪除或編輯。請用文字編輯器修改，存檔後這裡會自動更新。';
+  const UNLOCATABLE_LINE_INSERT_MESSAGE = '這段巢狀清單對不到自己的來源行，無法在其後插入。請用文字編輯器修改，存檔後這裡會自動更新。';
   // Both refusals go through one chooser each, so a call site cannot pick the
   // right guard and the wrong sentence.
   function noSourceLineMessageFor(blockEl) {
@@ -3419,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;
   }
 
@@ -4237,6 +4290,38 @@
       blockEl.appendChild(buildGutterInsertButton());
       blockEl.appendChild(buildGutterHandle());
     });
+    alignGutterTops(blockEls);
+  }
+
+  // The ⠿ / ＋ pair sits on the block's first line of text, whatever the
+  // block's own margin and line-height (a heading line is 49.5px tall, a
+  // paragraph's 24.75px). Measured from the first real text node's first
+  // line box, so tables, list items and code all land on their first row; a
+  // block with no text (an image, a bare diagram) keeps top 0. armEditables()
+  // also runs on a detached <template> fragment (the partial re-render path),
+  // where nothing has a layout yet: then it waits one frame and measures the
+  // blocks that have been connected by then.
+  function alignGutterTops(blockEls) {
+    if (!blockEls.length || !blockEls[0].isConnected) {
+      if (blockEls.length) requestAnimationFrame(() => alignGutterTops(blockEls.filter((b) => b.isConnected)));
+      return;
+    }
+    for (const b of blockEls) {
+      const walker = document.createTreeWalker(b, NodeFilter.SHOW_TEXT, {
+        acceptNode: (n) => (n.data.trim() && !n.parentElement.closest('.ed-handle, .ed-insert, .ed-li-marker, svg'))
+          ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP,
+      });
+      const t = walker.nextNode();
+      let top = 0;
+      if (t) {
+        const rg = document.createRange();
+        rg.selectNodeContents(t);
+        const line = rg.getClientRects()[0];
+        const handle = b.querySelector('.ed-handle');
+        if (line && handle) top = Math.round(line.top + line.height / 2 - b.getBoundingClientRect().top - handle.offsetHeight / 2);
+      }
+      b.style.setProperty('--ed-pair-top', top + 'px');
+    }
   }
 
   // A fresh ⠿ button per block — deliberately NOT wired with its own
@@ -4248,7 +4333,7 @@
     const el = document.createElement('button');
     el.type = 'button';
     el.className = 'ed-handle';
-    el.textContent = '⠿';
+    el.innerHTML = icons.svg('grip-vertical', 16);
     el.setAttribute('aria-label', '區塊選項');
     // v2.11.1: a <button> is a sequential focus stop, and there is one of
     // these plus one ＋ standing immediately after EVERY block — so any Tab
@@ -4703,7 +4788,7 @@
     const el = document.createElement('button');
     el.type = 'button';
     el.className = 'ed-insert';
-    el.textContent = '＋';
+    el.innerHTML = icons.svg('plus', 16);
     el.setAttribute('aria-label', '插入區塊');
     // Not a tab stop — see buildGutterHandle() above for the whole reason.
     el.setAttribute('tabindex', '-1');
@@ -4963,7 +5048,7 @@
     if (!document.body.contains(blockEl)) {
       liveBlockEl = reresolveBlockEl(identity) ||
         (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
-      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+      if (!liveBlockEl) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
     }
     // T7 fix round 1 (LOW-2): same refusal deleteBlockViaGutter() makes below,
     // for the same reason and against the same LIVE block. A block that owns
@@ -5292,14 +5377,14 @@
     if (!document.body.contains(blockEl)) {
       liveBlockEl = reresolveBlockEl(identity) ||
         (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
-      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null; }
+      if (!liveBlockEl) { showError(DROPPED_GESTURE_MESSAGE, null, null); return null; }
     }
     // A block that owns no source line has an INVERTED range
     // (endLine === startLine - 1) and every commit helper handed one does
     // something plausible and wrong.
     if (blockOwnsNoLine(liveBlockEl)) { refuseStructuralListEdit(noSourceLineMessageFor(liveBlockEl)); return null; }
     const rec = blockRecOf(liveBlockEl);
-    if (!rec) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null; }
+    if (!rec) { showError(DROPPED_GESTURE_MESSAGE, null, null); return null; }
     if (anchor) anchor.line = rec.startLine;
 
     const res = selectionLib
@@ -5336,7 +5421,7 @@
     const els = [];
     for (let i = 0; i < members.length; i++) {
       const el = blockElById(members[i].id);
-      if (!el) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null; }
+      if (!el) { showError(DROPPED_GESTURE_MESSAGE, null, null); return null; }
       // Belt to membersOf()'s own braces: selection.js excludes a block that
       // owns no line from every member set it builds, so this is unreachable —
       // but "another module filters it" is an argument about another file's
@@ -5369,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 + '"]');
@@ -5670,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)
@@ -5718,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
@@ -5761,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
@@ -5955,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
@@ -6010,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);
@@ -6021,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
@@ -6204,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
@@ -6244,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;
@@ -6313,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);
@@ -6323,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
@@ -6499,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;
@@ -6680,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
@@ -7088,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
@@ -7106,7 +7434,7 @@
       // not before: the user can reach exactly that through the ⠿ menu.
       const editedIdStr = String(burst.blockId);
       if (unsupportedByLi.some((u) => u.blockId === editedIdStr)) {
-        showBanner('含不支援的格式，改用原始碼編輯', null, null);
+        showNotice('含不支援的格式，改用原始碼編輯');
         endBurstWithoutResolve();
         await safeRerenderAll();
         return false;
@@ -7114,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.
@@ -7222,7 +7558,7 @@
       // `lines`), and return false so the caller (switchAwayFrom(), on
       // behalf of whatever triggered this resolution) aborts instead of
       // proceeding as if the burst resolved cleanly.
-      showBanner('含不支援的格式，改用原始碼編輯', null, null);
+      showNotice('含不支援的格式，改用原始碼編輯');
       endBurstWithoutResolve();
       openRawEditor(burst.blockEl);
       return false;
@@ -7543,6 +7879,10 @@
     }));
   };
   window.__edTestForceRerender = function () { return rerenderAll(); };
+  // v3.10.0: a notice has no close button (it fades after 4s). Tests that only
+  // need the banner gone before their next gesture take it down through the
+  // same dismissBannerEl() the fade timer and the ✕ use.
+  window.__edTestDismissBanner = function () { if (activeBanner) dismissBannerEl(activeBanner); };
   window.__edTestTruncateTo = function (n) { lines = lines.slice(0, n); };
 
   // v3.0.2: computeIndentClamp() lives past this file's node early-exit
@@ -7944,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
@@ -8011,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) {
@@ -8020,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;
@@ -8107,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
@@ -9060,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];
@@ -9117,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);
   }
@@ -9222,7 +9688,7 @@
   // and shadowed each other silently (last-declaration-wins), so the
   // no-source-line callers pass their own text instead of a second function.
   function refuseStructuralListEdit(message) {
-    showBanner(message || '此清單含不支援的格式，無法調整結構', null, null);
+    showNotice(message || '此清單含不支援的格式，無法調整結構');
     // Review recommendation 5: mark it, so the next SUCCESSFUL render clears
     // it (dismissRefusalBanner(), called from rerenderAll()). Set after the
     // showBanner() call, which resets the flag for every other caller.
@@ -10310,7 +10776,7 @@
     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; }
+    if (grid.length > 500 || width > 50) { showNotice(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 }; })()
@@ -10423,7 +10889,7 @@
       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 (!dest) { showError(DROPPED_GESTURE_MESSAGE); return; }
     }
     if (x !== null) arrowGoalX = x;
     arrowLandOn(dest, delta, x !== null ? x : arrowGoalX);
@@ -10991,7 +11457,7 @@
       // Dropping is still the right answer (see the S1 comment above); saying
       // nothing was not.
       if (!liveTableEl) {
-        showBanner(DROPPED_GESTURE_MESSAGE, null, null); return null;
+        showError(DROPPED_GESTURE_MESSAGE, null, null); return null;
       }
     }
     if (currentBurst && currentBurst.blockType === 'table' && currentBurst.editEl === liveTableEl) return liveTableEl;
@@ -11059,7 +11525,7 @@
     // 15 call sites): can't relocate it on the live table -> drop the
     // gesture and say so, never guess.
     if (!targetCell) {
-      showBanner(DROPPED_GESTURE_MESSAGE, null, null);
+      showError(DROPPED_GESTURE_MESSAGE, null, null);
       return;
     }
     currentBurst.history.snap('insert-col-pre');
@@ -11111,7 +11577,7 @@
     // can't relocate it on the live table -> drop the gesture and say so,
     // never guess.
     if (afterRowIndex >= 0 && !afterRow) {
-      showBanner(DROPPED_GESTURE_MESSAGE, null, null);
+      showError(DROPPED_GESTURE_MESSAGE, null, null);
       return;
     }
     currentBurst.history.snap('insert-row-pre');
@@ -11587,7 +12053,7 @@
     if (!liveTableEl) return;
     const headerRow = headerRowOf(liveTableEl);
     if (!headerRow || headerRow.cells.length <= 1) {
-      showBanner('無法刪除最後一欄', null, null);
+      showNotice('這是表格的最後一欄。要刪除整張表格，請用 ⠿ → 刪除。');
       return;
     }
     currentBurst.history.snap('delete-col-pre');
@@ -11614,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)) {
-      showBanner('無法刪除標題列', null, null);
-      return;
-    }
-    if (bodyRowsOf(liveTableEl).length <= 1) {
-      showBanner('無法刪除最後一列', null, null);
+      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');
@@ -12158,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();
@@ -12485,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;
 
@@ -12936,7 +13418,7 @@
     const sourceEl = els[st.sourceIndex];
     const destEl = target.mode === 'append' ? null : (els[target.blockIndex] || null);
     if (!sourceEl || (target.mode !== 'append' && !destEl)) {
-      showBanner(DROPPED_GESTURE_MESSAGE, null, null);
+      showError(DROPPED_GESTURE_MESSAGE, null, null);
       return;
     }
     const destIdentity = destEl ? captureBlockIdentity(destEl) : null;
@@ -12970,7 +13452,7 @@
     if (destEl && !document.body.contains(destEl)) {
       liveDestEl = reresolveBlockEl(destIdentity) ||
         (destSelfSession ? reresolveBlockElAfterSelfCommit(destIdentity) : null);
-      if (!liveDestEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+      if (!liveDestEl) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
     }
     // ── S4 Task 6: THE OPERAND SET (spec §4.5, §3.3, §3.6) ────────────────
     // §4.5: 「grip 在選取集合內 → 整批搬（3.3 的成員資格規則）」. Up to Task 5
@@ -12998,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
@@ -13039,7 +13510,7 @@
     const sj = live.indexOf(opEls[opEls.length - 1]);
     const rest = live.filter((el) => opEls.indexOf(el) === -1);
     const di = liveDestEl ? rest.indexOf(liveDestEl) : rest.length;
-    if (si < 0 || sj < 0 || di < 0) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    if (si < 0 || sj < 0 || di < 0) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
     // §3.3's set is contiguous in block order — resolveGutterOperands()'s own
     // gate — so its members' lines plus the separators between them are ONE
     // range, which is what makes a batch move the same single commitRangeEdit
@@ -13047,7 +13518,7 @@
     const srcRec = spanMoveRange(opRecs);
     const destRec = liveDestEl ? blockRecOf(liveDestEl) : null;
     if (!srcRec || (liveDestEl && !destRec)) {
-      showBanner(DROPPED_GESTURE_MESSAGE, null, null);
+      showError(DROPPED_GESTURE_MESSAGE, null, null);
       return;
     }
     // A destination that owns no source line has an INVERTED range, and its
@@ -13114,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);
@@ -13206,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];
@@ -13217,7 +13872,7 @@
     const run = listRunOf(liEl);
     const srcIdxs = liEls.map((el) => run.indexOf(el));
     const srcIdx = srcIdxs[0];
-    if (srcIdx < 0) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    if (srcIdx < 0) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
     // A member outside the grip's own commit span means the set straddles TWO
     // runs — contiguity in `blocks` does not imply one run, because two
     // adjacent runs separated by a delimiter change ('- a' / '1. b') are
@@ -13225,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
@@ -13294,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.
@@ -13305,7 +13963,7 @@
     // the ARRAY, and the reordered span's first member is not the run's first
     // line.
     const range = runRangeOfBlocks({ lines, blocks, stack }, run);
-    if (!range) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+    if (!range) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
     const span = order.map((i) => run[i]);
     // ── THE SEAM TASK 7 OWNS — §4.5's indent clamp ─────────────────────
     //
@@ -13357,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
@@ -13437,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) => {
@@ -13662,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 —
@@ -14319,6 +14972,11 @@
   // paintSelToolbarMarks() below. Filled by buildSelToolbar(), which runs once.
   const selToolbarMarkBtns = [];
 
+  const SELTB_ICON = {
+    'ed-seltb-b': 'bold', 'ed-seltb-i': 'italic', 'ed-seltb-s': 'strikethrough',
+    'ed-seltb-u': 'underline', 'ed-seltb-code': 'code', 'ed-seltb-link': 'link',
+  };
+
   function buildSelToolbar() {
     const el = document.createElement('div');
     el.className = 'ed-seltb';
@@ -14326,7 +14984,7 @@
       const b = document.createElement('button');
       b.type = 'button';
       b.className = 'ed-seltb-btn ' + cls;
-      b.textContent = label;
+      b.innerHTML = icons.svg(SELTB_ICON[cls], 16);
       b.setAttribute('aria-label', ariaLabel);
       b.setAttribute('aria-pressed', 'false');
       selToolbarMarkBtns.push({ btn: b, tag: tag });
@@ -14344,6 +15002,10 @@
     addBtn('ed-seltb-s', 'S', '刪除線', 'DEL', () => applyMarkToggle('DEL'));
     addBtn('ed-seltb-u', 'U', '底線', 'U', () => applyMarkToggle('U'));
     addBtn('ed-seltb-code', '<>', 'Code', 'CODE', () => applyMarkToggle('CODE'));
+    const sep = document.createElement('span');
+    sep.className = 'ed-seltb-sep';
+    sep.setAttribute('aria-hidden', 'true');
+    el.appendChild(sep);
     addBtn('ed-seltb-link', '\u{1F517}', 'Link', 'A', () => applyLinkToggle());
     return el;
   }
@@ -14713,7 +15375,24 @@
   }
 
   // ── save ───────────────────────────────────────────────────────────────
+  // v3.10.0: the outside-edit check (onDiskMtime() below) must not read its
+  // own saves as someone else's edit. A ping answered while a save is in
+  // flight, or one sent before a save that has since landed, carries an mtime
+  // that is not comparable with `mtimeMs`; saveGen / savesInFlight let the
+  // ping tell (no save in flight when it was sent, none started or in flight
+  // when it came back). Reasoned from the ordering, not measured — both directions: a
+  // stale pre-save mtime
+  // against the post-save baseline would reload a clean page for nothing, and
+  // a post-write mtime read before the save's reply lands would raise the
+  // conflict card over the user's own save.
+  let saveGen = 0;
+  let savesInFlight = 0;
   async function save() {
+    saveGen++;
+    savesInFlight++;
+    try { return await sendSave(); } finally { savesInFlight--; }
+  }
+  async function sendSave() {
     // fix 3: the receipt for the bytes about to leave, taken BEFORE the request
     // and not after it. `markSaved()` used to read the stack depth when the
     // RESPONSE landed, and a save round trip is hundreds of milliseconds —
@@ -14726,6 +15405,7 @@
     // See UndoStack.saveToken()/markSaved() for why the receipt carries an op
     // identity and not just a depth.
     const token = stack.saveToken();
+    paintSaveStatus('saving');
     //
     // ⚠ There is deliberately NO in-flight lock and no supersede guard here, and
     // that is a correction of something this file briefly carried. The premise
@@ -14754,8 +15434,9 @@
         body: JSON.stringify({ fileId: ED.fileId, content: lines.join(EOL), baseMtimeMs: mtimeMs }),
       });
     } catch (e) {
-      showBanner('Save failed — network error (' + describeFailure(e) +
-        '); changes NOT saved.', null, null);
+      paintSaveStatus('failed');
+      showError('無法儲存：連不到編輯伺服器（' + describeFailure(e) +
+        '）。變更還在這個分頁裡，請稍後再按 ' + SAVE_KEY_HINT + '。', null, null);
       return;
     }
     if (res.status === 200) {
@@ -14763,7 +15444,8 @@
       try {
         j = await res.json();
       } catch (e) {
-        showBanner('Save failed — malformed server response; changes NOT saved.', null, null);
+        paintSaveStatus('failed');
+        showError('無法儲存：伺服器回傳的內容無法解析。變更還在這個分頁裡。', null, null);
         return;
       }
       mtimeMs = j.mtimeMs;
@@ -14781,6 +15463,7 @@
       return;
     }
     if (res.status === 409) {
+      paintSaveStatus('failed');
       showConflictBanner();
       return;
     }
@@ -14788,7 +15471,8 @@
     // user's edits. Dirty state (and `mtimeMs`) is left untouched, and
     // there is no auto-retry; the user decides what to do next.
     const reason = await describeHttpFailure(res);
-    showBanner('Save failed — ' + reason + '; changes NOT saved.', null, null);
+    paintSaveStatus('failed');
+    showError('無法儲存：' + reason + '。變更還在這個分頁裡。', null, null);
   }
 
   // v3.4.0 §3: the "resolve whatever is open, THEN save" precondition —
@@ -15067,12 +15751,6 @@
   let toolbarMenuEl = null; // the H▾ dropdown panel, or null when closed
   let toolbarBlockEl = null;
   let toolbarStateSig = '';
-  // 追加 4's document mode: 'edit' | 'source'. v3.2.1 removed the third
-  // state ('preview'); docsource.js's MODES comment records why.
-  // docsource.js owns the cycle order and the lines[]<->string conversion.
-  let docMode = 'edit';
-  let sourceTextarea = null;
-  let sourceBaseLines = null;
   // 追加 2: Ctrl+Shift+V arms a plain-text-only paste for the NEXT paste
   // event. A ClipboardEvent carries no modifier state of its own, so the
   // intent has to be captured on the keystroke that produced it.
@@ -15109,9 +15787,10 @@
   // stray-key hand-back raises this rather than only some of them.
   const TOOLBAR_KEYNAV_EXIT_MESSAGE = '已離開鍵盤游標，按 Alt+F10 可以再進入工具列';
 
-  // Extra visual classes for the three inline buttons whose own glyph is the
-  // affordance (B is bold, I is italic, S is struck through) — the same
-  // idiom .ed-seltb-b/-i/-s use.
+  // Extra classes on the three inline buttons. Until v3.10.0 their text glyph
+  // was the affordance (B bold, I italic, S struck) and these classes styled
+  // it; the buttons draw Lucide icons now and the classes carry no CSS, but
+  // they stay as stable hooks, same as .ed-seltb-b/-i/-s.
   const TOOLBAR_BTN_CLASS = {
     bold: 'ed-toolbar-b', italic: 'ed-toolbar-i', strike: 'ed-toolbar-s',
   };
@@ -15286,7 +15965,6 @@
       // measures it here because toolbar-model.js may not touch the DOM, and
       // .ed-seltb is painted from the same measurement — see updateToolbar().
       marks: selectionMarkStates(sel),
-      mode: docMode,
       // v3.4.0 §3: the `save` button's own state. documentIsDirty() (just
       // above burstHasUncommittedEdit()'s own comment) is the SAME
       // expression setDirty() paints the title dot from — not a second copy
@@ -15329,9 +16007,9 @@
         btn.setAttribute('aria-pressed',
           st.mixed ? 'mixed' : (st.active ? 'true' : 'false'));
       }
-      // `headings` (H / H1..H6) and, since v3.2.1, the mode button carry a
-      // derived label; every other button keeps the glyph it was built with.
-      if (typeof st.label === 'string') btn.textContent = st.label;
+      // v3.10.0: every button draws the fixed Lucide icon buildToolbar() gave
+      // it. A derived label (H1..H6 on `headings`) no longer reaches the
+      // button's content; the title below still follows the state.
       // v3.2.1: a per-mode title CANNOT be baked in buildToolbar() — the mode
       // button's title names the NEXT state, so it has to be rewritten every
       // time the mode changes. It rides the same diffed loop as everything
@@ -15457,10 +16135,11 @@
   // Steps over disabled buttons. The walk is bounded by the button count and
   // wraps, so a bar with nothing enabled would leave the index where it was
   // rather than spin — see the model's own guarantee that this cannot happen
-  // (deriveState() keeps `preview` out of every disabling branch, including
-  // the source-mode override; T11-2 later exempted `outline` from that
-  // override too, so the enabled set there is `['outline','preview']` — the
-  // guarantee holds more strongly than when this was written, not less).
+  // (deriveState() keeps `outline` out of every disabling branch. Until
+  // v3.10.0 the guarantee rested on the source-mode button `preview`; that
+  // button is gone, and `outline` — enabled in all 264 ctx combinations a
+  // sweep of blockType x inList x indent x dirty x hasSelection produces —
+  // carries it now).
   function moveToolbarCursor(delta) {
     const btns = toolbarRovingBtns();
     if (!btns.length) return;
@@ -15533,29 +16212,13 @@
   // Scoped to genuine standalone controls only — INPUT/TEXTAREA/SELECT —
   // not to `.ed-wys-armed`/`.ed-wys-cell`: wireToolbarTracking()'s own
   // focusin comment is explicit that SOME toolbar activations (list,
-  // ordered-list, check, table, insert-before, insert-after, preview)
+  // ordered-list, check, table, insert-before, insert-after)
   // deliberately land a focusin on an editable block WITHOUT ending keynav,
   // so a real block surface must not trip this bail.
   //
-  // ⚠ FIX ROUND 1 (self-review, caught before ship): `preview`'s own landing
-  // is `sourceTextarea` — a real `<textarea>`, not a `.ed-wys-armed` block —
-  // so the exemption above named it but the first cut of this function did
-  // not actually implement it, and the omission is load-bearing: source
-  // mode's model disables every button except outline/preview (this file's
-  // own "S/4.1 Source mode" comment — the cursor is meant to be walked with
-  // Left/Right/Home/End between those two, THEN activated), and MEASURED,
-  // that walk is exactly what this function's first cut broke — the very
-  // next arrow key after landing in the source textarea silently exited
-  // keynav instead of moving between the two enabled buttons, closing off
-  // the one route backlog #6's own still-open `preview` round-trip gap (see
-  // activateToolbarCursor()'s comment) names as "THE WAY OUT". `sourceTextarea`
-  // is therefore excluded by reference (not by tag/class — an ordinary
-  // `textarea.ed-raw`, e.g. backlog #6's own quote/code rescue, still trips
-  // this bail exactly as intended, since typing there IS the user's own
-  // text, not bar navigation).
   function toolbarKeynavBlockedByRealControl() {
     const ae = document.activeElement;
-    if (!ae || ae === sourceTextarea) return false;
+    if (!ae) return false;
     return !!(ae.tagName && (ae.tagName === 'INPUT' ||
       ae.tagName === 'TEXTAREA' || ae.tagName === 'SELECT'));
   }
@@ -15566,8 +16229,9 @@
   // WHERE THE CARET ENDS UP AFTERWARDS, driven button by button over the
   // enabled row in a plain paragraph, pressing Enter on the cursor and then
   // typing to see whether the characters land anywhere — UPDATED for Task 9
-  // (backlog #6), which fixed the first two bullets below; only the third
-  // remains an open gap, tracked below rather than left unstated:
+  // (backlog #6), which fixed both bullets below. (A third, the source-mode
+  // button's return trip leaving the caret on BODY, was still open when
+  // v3.10.0 removed source mode altogether.)
   //
   //   * FIXED: quote, code and line used to end on BODY with typing going
   //     nowhere, clean burst and dirty one alike. restoreAfterStructuralOp()'s
@@ -15579,35 +16243,9 @@
   //     what dropped the caret). undoViaToolbar()/redoViaToolbar()/
   //     imageViaToolbar() now wrap the same captureCaretForSave()/
   //     restoreCaretForSave() pair saveViaToolbar() uses.
-  //   * STILL OPEN: `preview` (cycleDocMode(), the document-wide edit↔source
-  //     toggle) is UNCHANGED — going INTO source mode focuses the source
-  //     textarea correctly, but the RETURN trip (source → edit) still leaves
-  //     the caret on BODY, MEASURED unchanged by this task's own review.
-  //     Deliberately left open rather than rushed: unlike the two bullets
-  //     above, there is no established rescue to reuse here —
-  //     captureCaretForSave()'s block-id + text-offset coordinate system has
-  //     no meaning for a source-textarea cursor position (a raw character
-  //     offset into the WHOLE document string, not one block's rendered
-  //     text), so a correct fix needs its own coordinate mapping and its own
-  //     tests, not a copy-paste of this task's other two fixes. Backlog #6's
-  //     first two clauses no longer make this escape hatch NECESSARY the way
-  //     they used to (quote/code/line now have their own direct rescue,
-  //     rather than needing the preview round-trip as their only way out),
-  //     which is why this is deferred rather than treated as still blocking.
   //
   // A mouse click on those same buttons does exactly the same thing, so none
-  // of this is something the keyboard route introduced — a mouse user can
-  // always climb out of the still-open `preview` case by clicking into any
-  // OTHER editable text on the page, where a keyboard user cannot, because Tab
-  // from BODY goes nowhere (this file's own §3.5 contract).
-  //
-  // THE WAY OUT for the still-open case, driven end to end from a stranded
-  // BODY: the entry chord still works there (the bar's own state survives,
-  // and its row is fully enabled), so walking to the mode button and pressing
-  // Enter puts the caret in the source textarea, where typing lands. Coming
-  // back the same way returns the document to edit mode but leaves the caret
-  // on BODY again — the hatch is somewhere to keep typing, not (yet) a way
-  // back to the WYSIWYG caret.
+  // of this is something the keyboard route introduced.
   function activateToolbarCursor() {
     const btn = toolbarRovingBtns()[toolbarRovingIndex];
     if (!btn || btn.disabled) return;
@@ -15640,7 +16278,7 @@
       btn.type = 'button';
       btn.className = 'ed-toolbar-btn' +
         (TOOLBAR_BTN_CLASS[def.id] ? ' ' + TOOLBAR_BTN_CLASS[def.id] : '');
-      btn.textContent = def.icon;
+      btn.innerHTML = icons.svg(def.icon, 18);
       btn.title = def.title;
       btn.setAttribute('aria-label', def.title);
       btn.setAttribute('data-ed-tb', def.id);
@@ -15693,9 +16331,8 @@
     }, true);
     toolbarBtns = btns;
     // v3.1.0 的 spec 承諾「元素存在但無內容，§3 上線時填入、不需要重排版面」，
-    // 但元素從未被建立。這裡把承諾兌現：佔好寬度。內容不再是空的 ——
-    // paintModeStatus() 會在 mountToolbar() 掛上之後、以及每次 setDocMode()
-    // 切換時寫入當前模式名稱。
+    // 但元素從未被建立。這裡把承諾兌現：佔好寬度。v3.10.0 起它顯示存檔狀態
+    // （paintSaveStatus()）；原本寫的模式名稱隨原始碼模式一起移除。
     const statusEl = document.createElement('span');
     statusEl.className = 'ed-toolbar-status';
     // Final wave, M7: the only announcement a mode switch ever gets. Every
@@ -15756,7 +16393,6 @@
       // for the caret rescue.
       case 'image': return imageViaToolbar();
       case 'outline': return toggleOutlineSidebar(!!viaKeyboard);
-      case 'preview': return cycleDocMode();
       default: return undefined;
     }
   }
@@ -15921,7 +16557,7 @@
     if (!document.body.contains(blockEl)) {
       liveBlockEl = reresolveBlockEl(identity) ||
         (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null);
-      if (!liveBlockEl) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
+      if (!liveBlockEl) { showError(DROPPED_GESTURE_MESSAGE, null, null); return; }
     }
     const rec = blockRecOf(liveBlockEl);
     // A block that owns no source line has an inverted range, and there is
@@ -16076,14 +16712,14 @@
     // two literals and then parses the bytes. Keep the two rules the same
     // shape, and let the server's refusal be the one the user sees.
     if (!insertableFile(blob)) {
-      showBanner(TOOLBAR_UNSUPPORTED_IMAGE_MESSAGE, null, null);
+      showNotice(TOOLBAR_UNSUPPORTED_IMAGE_MESSAGE);
       return null;
     }
     let data;
     try {
       data = await blobToBase64(blob);
     } catch (e) {
-      showBanner('圖片讀取失敗 — ' + describeFailure(e), null, null);
+      showError('圖片讀取失敗 — ' + describeFailure(e), null, null);
       return null;
     }
     let res;
@@ -16095,12 +16731,12 @@
         }),
       });
     } catch (e) {
-      showBanner('圖片上傳失敗 — ' + describeFailure(e) + '。檔案未寫入。', null, null);
+      showError('圖片上傳失敗 — ' + describeFailure(e) + '。檔案未寫入。', null, null);
       return null;
     }
     if (!res.ok) {
       const reason = await describeHttpFailure(res);
-      showBanner('圖片上傳失敗 — ' + reason + '。檔案未寫入。', null, null);
+      showError('圖片上傳失敗 — ' + reason + '。檔案未寫入。', null, null);
       return null;
     }
     let j;
@@ -16111,11 +16747,11 @@
     // that is not a draw.io diagram -- so the reason has to arrive.
     if (!res.ok) {
       const why = (j && typeof j.error === 'string' && j.error) ? j.error : ('HTTP ' + res.status);
-      showBanner('檔案上傳失敗 — ' + why, null, null);
+      showError('檔案上傳失敗 — ' + why, null, null);
       return null;
     }
     if (!j || typeof j.path !== 'string') {
-      showBanner('圖片上傳失敗 — 伺服器回應格式不正確。', null, null);
+      showError('圖片上傳失敗 — 伺服器回應格式不正確。', null, null);
       return null;
     }
     return j.path;
@@ -16154,7 +16790,7 @@
     }
     if (!paths.length) return;
     const target = (anchorEl && document.body.contains(anchorEl)) ? anchorEl : lastBlockEl();
-    if (!target) { showBanner(TOOLBAR_NO_ANCHOR_MESSAGE, null, null); return; }
+    if (!target) { showNotice(TOOLBAR_NO_ANCHOR_MESSAGE); return; }
     const newLines = [];
     paths.forEach((p, i) => {
       if (i > 0) newLines.push('');
@@ -16219,7 +16855,7 @@
       ? blockEl
       : (reresolveBlockEl(identity) ||
         (selfSession ? reresolveBlockElAfterSelfCommit(identity) : null));
-    if (!anchorEl) { showBanner(TOOLBAR_NO_ANCHOR_MESSAGE, null, null); return; }
+    if (!anchorEl) { showNotice(TOOLBAR_NO_ANCHOR_MESSAGE); return; }
     // Re-captured AFTER the commit: `identity` above holds the PRE-commit
     // fingerprint, which the commit we just awaited may itself have
     // invalidated. What has to survive the dialog is the anchor as it stands
@@ -16251,7 +16887,7 @@
       // very symptom being fixed.
       const live = document.body.contains(anchorEl)
         ? anchorEl : reresolveBlockEl(dialogIdentity);
-      if (!live) { showBanner(TOOLBAR_NO_ANCHOR_MESSAGE, null, null); return; }
+      if (!live) { showNotice(TOOLBAR_NO_ANCHOR_MESSAGE); return; }
       insertImages(files, live);
     });
     input.click();
@@ -16279,31 +16915,11 @@
   }
 
   function wireImageDrop() {
-    // ⚠ BOTH listeners are gated on `docMode === 'edit'`, and that gate is
-    // load-bearing rather than tidy-minded.
-    //
-    // In SOURCE mode `enterSourceMode()` only sets `contentEl.hidden = true` —
-    // every `.ed-block` is still in the DOM, so `lastBlockEl()` resolves and an
-    // ungated drop ran the whole upload plus an `insertBlockBelow()` commit
-    // behind the hidden content, against `lines`. The textarea the user is
-    // looking at still held the PRE-drop source, and `leaveSourceMode()` then
-    // commits `commitRangeEdit(1, lines.length, ta.value)` over the post-drop
-    // `lines` — erasing the reference that was just inserted. MEASURED:
-    // '# Doc\n\nBody para.\n' -> source mode -> drop x.png -> type EDITED ->
-    // leave, and the file ends '# Doc\n\nBody para.\n\nEDITED\n' with
-    // assets/x.png orphaned on disk. No error, no visible effect, and a stray
-    // binary left in what is usually a git working tree.
-    //
-    // v3.2.1: `!== 'edit'` rather than `=== 'source'` on purpose. Source is
-    // the only other mode today, but the gate's reason is "the content the
-    // user is looking at is not the content a drop would write into" — a
-    // future third mode inherits the refusal rather than the hole.
     document.addEventListener('dragover', (e) => {
       // Nothing is dropped into a document behind a modal. Returning WITHOUT
       // preventDefault() is what makes the browser refuse the drop, so the
       // gesture is declined visibly rather than swallowed.
       if (waveEditorIsModal()) return;
-      if (docMode !== 'edit') return;
       if (!dragCarriesFiles(e)) return;
       e.preventDefault();
       if (e.dataTransfer) e.dataTransfer.dropEffect = 'copy';
@@ -16313,7 +16929,6 @@
       // took the document behind it from 4 blocks to 5 and put an `<img>` into
       // `.content`, with the overlay still up and saying nothing.
       if (waveEditorIsModal()) return;
-      if (docMode !== 'edit') return;
       if (!dragCarriesFiles(e)) return;
       const files = e.dataTransfer
         ? Array.prototype.slice.call(e.dataTransfer.files || [])
@@ -16433,94 +17048,26 @@
     }, true);
   }
 
-  // ── 追加 4: the whole-document source escape hatch ─────────────────────
-  // v3.2.1: applyPreviewEditability() lived here and was preview mode's ONLY
-  // effect. Preview is gone (docsource.js's MODES comment carries the
-  // measurement), and with it the last caller of this function.
-
-  function enterSourceMode() {
-    // The pre-edit snapshot fromSource() diffs against. Omitting it makes
-    // `changed` unconditionally true (docsource.js's documented fail-safe),
-    // i.e. a needless write of byte-identical content on every exit.
-    sourceBaseLines = lines.slice();
-    const ta = document.createElement('textarea');
-    ta.className = 'ed-source';
-    ta.setAttribute('aria-label', '文件原始碼');
-    ta.value = docSourceLib.toSource(lines, EOL);
-    contentEl.hidden = true;
-    contentEl.parentNode.insertBefore(ta, contentEl);
-    sourceTextarea = ta;
-    ta.focus();
-  }
-
-  // Returns false when the commit's render failed — the textarea is then left
-  // standing with the user's text intact (a failed round trip must never be
-  // the thing that discards a whole document's edit), and the mode does not
-  // advance.
-  async function leaveSourceMode() {
-    const ta = sourceTextarea;
-    if (!ta) return true;
-    const parsed = docSourceLib.fromSource(ta.value, EOL, sourceBaseLines);
-    if (parsed.changed) {
-      // 全量置換 through the SAME replaceLines() pipeline every other edit
-      // uses — one commitRangeEdit over the whole document, therefore one
-      // undo op, and no second writer of `lines`.
-      const result = commitRangeEdit({ lines, blocks, stack }, 1, lines.length,
-        parsed.lines.join('\n'));
-      if (result.op !== null) {
-        const prevLines = lines;
-        lines = result.lines;
-        setDirty();
-        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);
-          setDirty();
-          return false;
-        }
-      }
-    }
-    sourceTextarea = null;
-    sourceBaseLines = null;
-    ta.remove();
-    contentEl.hidden = false;
-    return true;
-  }
-
-  async function cycleDocMode() {
-    if (!docSourceLib) return;
-    await setDocMode(docSourceLib.next(docMode));
-  }
-
-  async function setDocMode(next) {
-    if (next === docMode) return;
-    if (docMode === 'edit') {
-      // Same precondition every structural operation has: resolve whatever
-      // session is open before the DOM it lives in is swapped or hidden.
-      const ok = await switchAwayFrom();
-      if (!ok) return;
-    }
-    if (docMode === 'source') {
-      const ok = await leaveSourceMode();
-      if (!ok) return;
-    }
-    docMode = next;
-    if (docMode === 'source') enterSourceMode();
-    document.body.setAttribute('data-ed-mode', docMode);
-    paintModeStatus();
-    updateToolbar();
-  }
-
-  // v3.2.1: 模式必須說出來 —— 使用者按第二下以為卡住，其實是進了 source。
-  // Called from setDocMode() AND from mountToolbar(), so the slot is truthful
-  // from the first paint rather than only after the first mode change.
-  function paintModeStatus() {
+  // The toolbar's right-hand status slot says whether the file on disk matches
+  // the page. Save stays manual (Ctrl/Cmd+S or the save button); this only
+  // makes the state visible. role="status" (mountToolbar()) so a screen
+  // reader hears it. v3.10.0: it used to name the document mode, which went
+  // with source mode. The save button's aria-pressed follows 'dirty' — save
+  // is not in TOOLBAR_TOGGLE_IDS, so updateToolbar() never writes it back.
+  const SAVE_KEY_HINT = /Mac|iPhone|iPad/.test(navigator.platform) ? '⌘S' : 'Ctrl+S';
+  function paintSaveStatus(state) {
     const statusEl = document.querySelector('.ed-toolbar-status');
-    if (statusEl) statusEl.textContent = docMode === 'source' ? '原始碼' : '編輯';
+    if (!statusEl) return;
+    // setDirty() runs on every burst mutation; rewriting an unchanged role=
+    // "status" region would have a screen reader re-announce it per keystroke.
+    if (statusEl.getAttribute('data-state') === state) return;
+    statusEl.setAttribute('data-state', state);
+    if (state === 'clean') statusEl.innerHTML = icons.svg('check', 15) + '<span>已儲存</span>';
+    else if (state === 'dirty') statusEl.innerHTML = '<i class="ed-status-dot"></i><span>有未儲存的變更 · ' + SAVE_KEY_HINT + ' 儲存</span>';
+    else if (state === 'saving') statusEl.innerHTML = '<span>儲存中…</span>';
+    else statusEl.innerHTML = icons.svg('circle-alert', 15) + '<span>無法儲存</span>';
+    const btn = toolbarBtns && toolbarBtns.save;
+    if (btn) btn.setAttribute('aria-pressed', state === 'dirty' ? 'true' : 'false');
   }
 
   // ── mount ──────────────────────────────────────────────────────────────
@@ -16600,8 +17147,7 @@
     // while both had to end up with the hint out.
     toolbarEl.addEventListener('scroll', paintToolbarOverflow, { passive: true });
     window.addEventListener('resize', paintToolbarOverflow);
-    document.body.setAttribute('data-ed-mode', docMode);
-    paintModeStatus();
+    paintSaveStatus(documentIsDirty() ? 'dirty' : 'clean');
     wireToolbarTracking();
     wireImageDrop();
     wirePlainPasteArming();
@@ -16620,10 +17166,7 @@
     // That bail returns for EVERY key, so an entry gesture placed under it
     // would be dead while a degraded block's raw editor holds focus — driven
     // from that editor, the gesture lands on the bar and the caret stays in
-    // the textarea. Source mode is a different surface (`textarea.ed-source`,
-    // which that bail does not match) and reaches the bar as well; there the
-    // model disables the row apart from the button that gets you back out, so
-    // the cursor lands on that one.
+    // the textarea.
     //
     // Escape is NOT claimed here. It belongs to the ordered prologue just
     // below, which already ranks a drag and an open menu above everything
@@ -16789,7 +17332,7 @@
           e.key !== 'Control' && e.key !== 'Meta') {
         exitToolbarKeynav();
         if (e.key !== 'Tab') {
-          showBanner(TOOLBAR_KEYNAV_EXIT_MESSAGE, null, null);
+          showNotice(TOOLBAR_KEYNAV_EXIT_MESSAGE);
           activeBannerIsKeynavExit = true;
         }
       }
@@ -17746,7 +18289,7 @@
       return;
     }
     drawioDeferredNotice = null;
-    showBanner(message, null, null);
+    showNotice(message);
   }
   function flushDrawioNotice() {
     if (!drawioDeferredNotice) return;
@@ -17757,7 +18300,7 @@
     if (activeBanner || noticeTeardownWouldDisrupt()) return;
     const m = drawioDeferredNotice.message;
     drawioDeferredNotice = null;
-    showBanner(m, null, null);
+    showNotice(m);
   }
   const DRAWIO_PAGE_GONE_MSG =
     '目前檢視的 drawio 分頁已不存在（可能已刪除或改名），已切回第一頁。';
@@ -18071,6 +18614,45 @@
     }
   }
 
+  // v3.10.0: an edit made outside the browser. Clean page: reload it and land
+  // on the same heading. Unsaved work here: say so now, once per outside
+  // version, instead of waiting for the save to bounce with a 409.
+  // documentIsDirty() already counts an uncommitted burst, so typing that has
+  // not been committed yet takes the conflict branch (Review Focus 4).
+  let conflictShownFor = 0;
+  function onDiskMtime(disk) {
+    if (disk === mtimeMs || waveEditorIsModal()) return;
+    // An open MD 原始碼 box with typed-but-uncommitted text is unsaved work
+    // too, and documentIsDirty() cannot see it (a textarea's value touches no
+    // block's innerHTML). A reload would silently throw it away.
+    const rawPending = !!(activeEditor && activeEditor.hasChanges());
+    if (!documentIsDirty() && !rawPending) {
+      try { sessionStorage.setItem('md2doc-reload-anchor', JSON.stringify(readingAnchor())); } catch (e) { /* private mode */ }
+      location.reload();
+      return;
+    }
+    if (conflictShownFor === disk) return;
+    conflictShownFor = disk;
+    showConflictBanner();
+  }
+  function readingAnchor() {
+    const hs = [].slice.call(document.querySelectorAll('.content h1[id], .content h2[id], .content h3[id], .content h4[id]'));
+    let best = null;
+    for (const h of hs) { if (h.getBoundingClientRect().top <= 80) best = h; else break; }
+    return best ? { id: best.id, off: Math.round(best.getBoundingClientRect().top) } : { y: Math.round(scrollY) };
+  }
+  (function restoreReloadAnchor() {
+    let a = null;
+    try { a = JSON.parse(sessionStorage.getItem('md2doc-reload-anchor') || 'null'); sessionStorage.removeItem('md2doc-reload-anchor'); } catch (e) { a = null; }
+    if (!a) return;
+    requestAnimationFrame(() => {
+      const h = a.id && document.getElementById(a.id);
+      if (h) scrollTo(0, scrollY + h.getBoundingClientRect().top - a.off);
+      else if (typeof a.y === 'number') scrollTo(0, a.y);
+      showNotice('檔案在別處被修改，已重新載入。');
+    });
+  })();
+
   setInterval(() => {
     // A notice this refresh could not show earlier because the slot was
     // taken (see noteDrawioNotice) gets its next chance here, on the same
@@ -18095,10 +18677,17 @@
     // is the accepted worst-case latency for this whole feature.
     const ack = drawioAckPending;
     drawioAckPending = null;
+    const pingSaveGen = saveGen;
+    const pingSavesInFlight = savesInFlight;
     fetch('/api/ping', {
       method: 'POST', headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ fileId: ED.fileId, drawioClientId: ED.drawioClientId, drawioAck: ack }),
     }).then((res) => {
+      // v3.10.0: X-Md2doc-Mtime is the file's mtime as the server saw it. Only
+      // comparable when no save started or ran during this round trip.
+      const disk = Number(res.headers.get('x-md2doc-mtime'));
+      if (isFinite(disk) && disk > 0 && saveGen === pingSaveGen &&
+          pingSavesInFlight === 0 && savesInFlight === 0) onDiskMtime(disk);
       if (res.status !== 200) return null;
       return res.json().catch(() => null);
     }).then((j) => {
@@ -18748,7 +19337,7 @@
     // missing from the file after the user has read about it, and the dirty
     // net is about the work, not about the notice.
     let el = null;
-    el = showBanner(
+    el = showError(
       '這個改動沒辦法只改幾個位元組寫回檔案，所以【沒有】寫回去 —— 編輯器上看到的' +
       '比檔案裡多一步。受影響的是這個 wavedrom 區塊的內容，' + range +
       '（不含前後兩道圍欄）。原因：' + reason,
@@ -18866,7 +19455,7 @@
       // Kept, with a hole in it. The user is told once more on the way out,
       // because the status line they were reading has just been removed from
       // the screen along with the rest of the dialog.
-      showBanner(
+      showError(
         '這次波形編輯有一個改動沒辦法寫回檔案，它沒有留下來 —— 檔案裡是其餘' +
         '寫得回去的部分（這個區塊的內容在第 ' + seam.startLine + '–' +
         seam.endLine + ' 行）。',
@@ -18904,7 +19493,7 @@
       // it. Losing a session is bad; silently corrupting the document the user
       // keeps editing afterwards is worse, and before fix 1 this path risked
       // both at once.
-      showBanner(
+      showError(
         '畫面沒有重畫成功，但你畫的波形還在文件裡（按 Ctrl+S 可以存檔，' +
         'Ctrl+Z 可以撤銷）。', null, null);
     }