@helping-ai-workflow/md2doc 2.11.0 → 2.11.1

package/lib/editor/client.js

@@ -1553,6 +1553,16 @@
     el.className = 'ed-handle';
     el.textContent = '⠿';
     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
+    // that reaches the browser walks straight into gutter chrome, which is the
+    // most jarring shape of the two escape classes fixed above. Both are
+    // mouse-only affordances with no keyboard contract of their own (the ⠿
+    // menu is opened by click; nothing here is reachable or operable by
+    // keyboard today), so they are removed from the tab order rather than
+    // given one they do not have. tabindex="-1" keeps them programmatically
+    // and click-focusable, so `.ed-handle:focus { opacity: 1 }` still works.
+    el.setAttribute('tabindex', '-1');
     // Deliberately NOT wired with its own addEventListener here (see the
     // paragraph above) — including for Final-review Finding 5a's mousedown
     // preventDefault() (see wireBlockSelection()'s delegated 'mousedown'
@@ -1565,7 +1575,7 @@
     return el;
   }
 
-  // The single shared ⠿ menu (spec §3.7: 轉換成 › / 複製 / 刪除 / MD 原始碼)
+  // The single shared ⠿ menu (spec §3.7: 轉換成 › / 建立副本 / 刪除 / MD 原始碼)
   // — built once, moved into whichever block's DOM the user opened it on,
   // same pattern as `selToolbar` elsewhere in this file. `gutterMenuBlockEl`
   // names which block it's currently open for. Because the node is a
@@ -1609,7 +1619,7 @@
       openConvertSubmenu(gutterMenuConvert);
     });
 
-    gutterMenuDuplicate = item('複製', 'Duplicate this block', (e) => {
+    gutterMenuDuplicate = item('建立副本', 'Duplicate this block', (e) => {
       e.stopPropagation();
       const blockEl = gutterMenuBlockEl;
       closeGutterMenu();
@@ -1745,6 +1755,8 @@
     el.className = 'ed-insert';
     el.textContent = '＋';
     el.setAttribute('aria-label', '插入區塊');
+    // Not a tab stop — see buildGutterHandle() above for the whole reason.
+    el.setAttribute('tabindex', '-1');
     return el;
   }
 
@@ -1944,7 +1956,7 @@
     // the ids — see captureBlockIdentity()'s comment.
     const identity = captureBlockIdentity(blockEl);
     // S2 Task 7: the FOURTH and last call site of the hole 轉換 (Task 2), 刪除
-    // and 複製 (Task 6) already closed, and the one that was latent only
+    // and 建立副本 (Task 6) already closed, and the one that was latent only
     // because a li had no ＋ to press. Finding 5a's delegated mousedown
     // preventDefault() names '.ed-insert' as well as '.ed-handle', so the
     // burst survives the press and the commit that lands inside
@@ -1987,7 +1999,7 @@
     //
     // 1. THE INSERTION POINT IS THE END OF THE ANCHOR'S SUBTREE, not the
     //    anchor's own last line. This is the ruling §4.3 already made for
-    //    複製 (「副本插在該 block 整棵子樹之後」), and it is what makes every
+    //    建立副本 (「副本插在該 block 整棵子樹之後」), and it is what makes every
     //    non-list kind safe here. Measured on ['# Doc','','- alpha',
     //    '  - child','    - grand','']: anchored on `child`,
     //    commitBlockInsertion() with the 段落 skeleton yields
@@ -2004,7 +2016,7 @@
     //    measured, '# Doc\n\n- alpha\n  - child\n\n  -\n' has a NESTED
     //    list with loose === true, so every item of it grows a <p>,
     //    serializeBlocks() pushes 'P' for each and the run degrades read-only
-    //    with no banner. Same fork 複製 hit in Task 6, and the same answer:
+    //    with no banner. Same fork 建立副本 hit in Task 6, and the same answer:
     //    route the li through its own run's re-serialization, which emits no
     //    blank at all, re-runs §3.8's renumbering, and — the point of carry 2
     //    — takes the new item's indent prefix from the serializer's own
@@ -2183,7 +2195,7 @@
     if (!rec) { showBanner(DROPPED_GESTURE_MESSAGE, null, null); return; }
     const kind = liveBlockEl.getAttribute('data-block-type');
 
-    // §4.3's run-wide gate: 轉換／複製／刪除／拖曳 all pass through
+    // §4.3's run-wide gate: 轉換／建立副本／刪除／拖曳 all pass through
     // listRunSupportsStructuralEdit() BEFORE any mutation, the same door
     // Tab/Enter/checkbox already use. Its input is §3.4 rule 2's SCOPE, which
     // is exactly what listRunOf() returns (the outermost run PLUS every
@@ -2272,7 +2284,7 @@
     return document.querySelector('.ed-block[data-block-id="' + at.id + '"]');
   }
 
-  // S2 Task 6 — 複製 (§4.3).
+  // S2 Task 6 — 建立副本 (§4.3).
   //
   // The copy is inserted after the block's ENTIRE SUBTREE, never after its own
   // line. The spec records the measurement and it reproduces here:
@@ -2348,16 +2360,16 @@
     }
   }
 
-  // The li half of 複製. The copy is spliced into the run's own span and the
+  // The li half of 建立副本. The copy is spliced into the run's own span and the
   // WHOLE span is re-serialized over the run's line range — one commitRangeEdit,
-  // therefore one undo op (§4.3: 複製與刪除均為單一 undo), no leading blank, and
+  // therefore one undo op (§4.3: 建立副本與刪除均為單一 undo), no leading blank, and
   // §3.8's renumbering falls out of the re-serialization ('1. alpha' duplicated
   // gives '1. alpha / 2. alpha / 3. bravo', not '1. alpha / 1. alpha / 2.
   // bravo').
   async function duplicateListItem(liEl) {
     const run = listRunOf(liEl);
     if (!run.length) return;
-    // §4.3's run-wide gate — 轉換／複製／刪除／拖曳 each make this call for
+    // §4.3's run-wide gate — 轉換／建立副本／刪除／拖曳 each make this call for
     // themselves; there is no shared helper. Its input is §3.4 rule 2's scope,
     // which is exactly what listRunOf() returns (the outermost run PLUS every
     // descendant of its members). A duplicate is NOT column-only (§4.1 修訂 2:
@@ -3773,7 +3785,24 @@
   // wireBurstListeners() below), Shift+Enter inserts a <br> and snapshots
   // it, Escape reverts, Ctrl+Z/Y drive the burst-local history.
   function handleBurstKeydown(e, editEl) {
-    if (!currentBurst || currentBurst.editEl !== editEl) return;
+    if (!currentBurst || currentBurst.editEl !== editEl) {
+      // v2.11.1 acceptance, escape class B. This bail is reachable with the
+      // surface STILL FOCUSED and still `.ed-wys-armed`: resolveBurst() nulls
+      // `currentBurst` without blurring (Ctrl+S is the everyday way in), and
+      // the delegated handler's call site below `return`s unconditionally, so
+      // nothing else in the document handler runs either. For every other key
+      // that is the right answer — the surface is a plain contenteditable and
+      // the browser's default IS the behaviour we want. Tab is the one key
+      // whose default is not "insert something" but "walk the caret out of the
+      // document": measured on 2.11.0 it moved focus to that same item's own ＋
+      // button (Shift+Tab, to the previous block's ⠿). Spec §3.5 names this
+      // outright — 必須 preventDefault()，否則 Tab 在 body 上是瀏覽器焦點巡覽.
+      // Swallowed, not acted on: there is no burst to act within, and an
+      // indent from a resolved burst would be a structural edit the user did
+      // not ask for.
+      if (e.key === 'Tab') e.preventDefault();
+      return;
+    }
     // Task 8 (Phase 4): per-li burst — Enter / Shift+Enter / Tab / Shift+Tab
     // are owned by handleLiKeydown() below (spec §4's key semantics for li
     // surfaces, acceptance rows 1, 3, 5, 6, 7, 8). Every other key (Escape,
@@ -6462,6 +6491,28 @@
       if (insertMenuBlockEl) closeInsertMenu();
       if (e.target.closest(ED_LIGHTBOX_TARGETS)) return; // let the lightbox open, unchanged
       let blockEl = e.target.closest('.ed-block');
+      // v2.11.1: `.ed-block::before` (lib/md2doc.js's editModeLayoutCss) makes
+      // the 40px gutter part of the block's HIT area so that hovering it keeps
+      // the ＋/⠿ pair visible. That is a hover fix, and it must not become a
+      // click fix by accident: before it, a click in the gutter band hit
+      // main.content and meant "clicked outside any block" — which for a
+      // DEGRADED block (blockquote, fenced code, an unsupported table) is the
+      // difference between committing whatever was open and silently opening
+      // that block's raw source editor from 20px away from it.
+      //
+      // Read only when the click landed on the block's OWN box (a click on any
+      // descendant — the text surface, a marker, a checkbox, a gutter button —
+      // is unaffected) and only when the event actually carries coordinates:
+      // a synthesized `new MouseEvent('click', {bubbles:true})` and
+      // `el.click()` both report clientX/clientY 0, which several scenarios in
+      // test/editor-client-runtime.test.js use precisely because they mean
+      // "the block itself", not "a point". `offsetX < 0` looks like the
+      // tidier test and is NOT usable: for a synthesized event Chromium still
+      // derives offsetX from clientX 0, so it comes back as minus the block's
+      // whole left offset and every such click reads as a gutter click.
+      if (blockEl && e.target === blockEl && (e.clientX || e.clientY)) {
+        if (e.clientX < blockEl.getBoundingClientRect().left) blockEl = null;
+      }
       if (!blockEl) { await switchAwayFrom(); return; } // clicked outside any block
 
       // Task 5: a table block is now armed exactly like paragraph/heading/
@@ -6638,6 +6689,44 @@
       return;
     }
 
+    // v2.11.1 acceptance, escape class A: Tab with NOTHING focused. Every
+    // branch above is keyed on the event target being some edit surface, and
+    // after a commit / Escape / Ctrl+Z, or a click on a bullet marker or in
+    // the block's own gutter, focus is on BODY and the target is BODY — so no
+    // branch matched and the browser ran its own sequential focus navigation,
+    // landing on whichever gutter <button> happens to come next in document
+    // order. Spec §3.5: 必須 preventDefault()，否則 Tab 在 body 上是瀏覽器焦點
+    // 巡覽. This is deliberately a silent no-op rather than "indent the block
+    // nearest the caret": with no focus there is no caret, so there is no
+    // block the key could mean.
+    //
+    // Scoped so a real control keeps its keyboard contract: the reader's own
+    // search input and the raw editor's textarea (which returned above) are
+    // still tabbable, and so is anything else the user has deliberately
+    // focused. What is swallowed is Tab from inside a `.ed-block` and Tab with
+    // no focus at all — the two states the editor puts the user in.
+    if (e.key === 'Tab') {
+      const inBlock = e.target && e.target.closest && e.target.closest('.ed-block');
+      // A REAL control inside a block keeps its keyboard contract. The raw
+      // source editor's own 完成/取消 buttons are the case that matters: Tab
+      // out of its textarea is how a keyboard user reaches them (the textarea
+      // itself returned above), and swallowing the next Tab would trap focus
+      // on the button it just landed on. The ⠿ menu's buttons are the same
+      // shape. The two GUTTER buttons are excluded from that exemption on
+      // purpose — they are the chrome this fix exists to keep out of the tab
+      // order, and buildGutterHandle()/buildGutterInsertButton() give them
+      // tabindex="-1" for the same reason.
+      const control = e.target && e.target.closest && e.target.closest(
+        'button:not(.ed-handle):not(.ed-insert), input, select, textarea, a[href], [tabindex]:not([tabindex="-1"])');
+      const focused = document.activeElement;
+      const nothingFocused = !focused || focused === document.body ||
+        focused === document.documentElement;
+      if ((inBlock && !control) || nothingFocused) {
+        e.preventDefault();
+        return;
+      }
+    }
+
     if (e.key === 'Escape') {
       e.preventDefault();
       closeGutterMenu();

package/lib/editor/list-md.js

@@ -377,6 +377,61 @@
     return n > 0 ? new Array(n + 1).join(' ') : '';
   }
 
+  // ── The setext-underline hazard on an EMPTY bulleted item ───────────────
+  // An empty item is emitted as a BARE marker ('-', no trailing space): '- '
+  // lexes as a PARAGRAPH, which is why lib/editor/client.js's
+  // BLOCK_SKELETONS.list is a bare marker too, and that reasoning is not being
+  // undone here. But CommonMark gives that same bare '-' a SECOND reading, and
+  // which one wins is decided by the line ABOVE it: an EMPTY list item may not
+  // interrupt a paragraph, and a line consisting of nothing but '-' standing
+  // at an open paragraph's own content column is a SETEXT H2 UNDERLINE.
+  //
+  // That is exactly the line an indent produces. `- beta` + Enter + Tab wrote
+  //
+  //     - alpha
+  //     - beta
+  //       -
+  //
+  // and marked (14.1.4) reads it back as `<li><h2>beta</h2></li>`: the new
+  // item is gone and the parent's text has been re-typed as a heading. Two
+  // ordinary keystrokes, silent content destruction, measured on 2.11.0.
+  //
+  // The hazard is POSITIONAL, not a property of the marker. It exists only
+  // where the previously emitted line is a paragraph at this line's own
+  // column, which inside a run means precisely "this item is the FIRST item of
+  // a deeper nesting" (`prev.indent < indent`) — the parent's own text (or its
+  // lazy continuation) is then the line immediately above, and a child's
+  // marker column IS the parent's content column by construction. An empty
+  // item that follows a SAME-level sibling is safe (the line above is a marker
+  // line, so '-' can only be another marker there), and so is one whose
+  // predecessor is deeper.
+  //
+  // Every other shape is left byte-identical:
+  //   * ordered — '1.' is not a run of dashes, so it is not a setext underline;
+  //   * task    — a content-free task item never emits a marker line at all
+  //               (it becomes `pending`, a same-line prefix), which is what the
+  //               `head === indentPrefix + marker` test below detects;
+  //   * non-empty items, and every empty item at top level.
+  //
+  // The escape is a U+200B ZERO WIDTH SPACE: real, non-whitespace content to
+  // the block lexer (so the line is a list item, not an underline) and nothing
+  // at all to a reader. It is the same trade-off client.js already documents
+  // for BLOCK_SKELETONS.paragraph. It never becomes part of the user's text:
+  // lib/md2doc.js's edit-mode list renderer renders a U+200B-only item as an
+  // EMPTY surface, so the next keystroke lands in an empty item, and the
+  // itemMd normalisation above takes the character back off on the way out.
+  const SETEXT_ESCAPE = '\u200b';
+  const SETEXT_ESCAPE_RE = /^\u200b+$/;
+  function escapeSetextHazard(firstOwnLine, ctx) {
+    if (firstOwnLine !== '') return firstOwnLine;
+    if (ctx.listType !== 'ul' || ctx.isTask) return firstOwnLine;
+    // A `pending` task prefix has already been joined onto `head`, so the line
+    // is not a bare run of dashes and needs nothing.
+    if (ctx.head !== ctx.indentPrefix + ctx.marker) return firstOwnLine;
+    if (!ctx.prev || ctx.indent <= ctx.prev.indent) return firstOwnLine;
+    return SETEXT_ESCAPE;
+  }
+
   // `opts.carryOver` (spec §3.4, 多行 li 的旁觀者規則): a map of block id →
   // that block's ORIGINAL source lines. A hard-wrapped item named there is NOT
   // re-serialized; its own bytes are replayed with the column difference of its
@@ -536,6 +591,15 @@
         const res = inlineMd.serializeInline({ childNodes: inlineKids });
         itemMd = res.md;
         res.unsupported.forEach((u) => innerUnsupported.push(u));
+        // The other half of the SETEXT ESCAPE applied at the emission site
+        // below: a U+200B is this serializer's own way of saying "empty item
+        // in a position where a bare marker would re-lex as a heading
+        // underline", so this serializer is also the one that takes it back
+        // off. Without it, an escaped item that later moves somewhere the
+        // escape is not needed (Shift+Tab back to the top level) would keep a
+        // zero-width character it never asked for, and the item would stop
+        // reading as empty to every `itemMd === ''` test in this function.
+        if (SETEXT_ESCAPE_RE.test(itemMd)) itemMd = '';
       }
 
       // Anything in the block that is neither chrome nor the text surface is
@@ -717,7 +781,10 @@
         prev = { indent: indent, listType: listType };
         return;
       }
-      lines.push((head + ownLines[0]).replace(/[ \t]+$/, ''));
+      lines.push((head + escapeSetextHazard(ownLines[0], {
+        head: head, indentPrefix: indentPrefix, marker: marker,
+        listType: listType, isTask: isTask, indent: indent, prev: prev,
+      })).replace(/[ \t]+$/, ''));
       lineMeta.push({ blockId: blockId, indentPrefix: metaPrefix, marker: marker });
       for (let k = 1; k < ownLines.length; k++) {
         const body = ownLines[k].replace(/^[ \t]+/, '').replace(/[ \t]+$/, '');

package/lib/md2doc.js

@@ -284,6 +284,15 @@ function renderEditModeList(listToken, blocks, biRef, out) {
       // but would render as a phantom blank line inside the item.
       inner = marked.parser(ownTokens).trim();
     }
+    // The receiving half of list-md.js's SETEXT ESCAPE (see
+    // escapeSetextHazard() there): an empty list item that is the first child
+    // of a deeper nesting is written to disk as `- <U+200B>`, because a bare
+    // `-` on that line is a setext H2 underline for the parent's own text and
+    // destroys both blocks. The zero-width space is the serializer's, not the
+    // user's, so it is taken back off here — the surface renders EMPTY, which
+    // is what keeps the next keystroke from landing next to an invisible
+    // character and writing it back out inside the user's own text.
+    if (/^\u200b+$/.test(inner)) inner = '';
     const check = b.task
       ? `<span class="ed-li-check" data-checked="${b.checked ? 1 : 0}" role="checkbox" aria-checked="${!!b.checked}"></span>`
       : '';
@@ -1078,8 +1087,9 @@ ${itemsHtml}
   // (now reverted) "inset the row grip into the table" hack that ended up
   // covering the first cell's text. 56px of content padding plus moving the
   // gutter buttons out (⠿ to left:-36px, ＋ to left:-54px) separates them
-  // properly: the gutter pair occupies [contentLeft-54, contentLeft-18] and
-  // the 20px-wide row grip straddles contentLeft at
+  // properly: the gutter pair occupies [contentLeft-40, contentLeft-4]
+  // (v2.11.1; it was [contentLeft-54, contentLeft-18] until spec §4.2's own
+  // numbers were restored) and the 20px-wide row grip straddles contentLeft at
   // [contentLeft-10, contentLeft+10] — an 8px gap, and the grip's inner half
   // stays within the cell's own 14px padding, so it never touches cell text.
   // (The padding was 48px until §4.2's hit-test conflict 1 was fixed; see the
@@ -1133,7 +1143,11 @@ ${itemsHtml}
 
      8 more pixels of padding move the pair to [contentLeft-54,
      contentLeft-18] = [splitterRight+2, splitterRight+20], i.e. entirely
-     inside the content column with 2px of clearance. The 20px table row grip
+     inside the content column with 2px of clearance. (v2.11.1 pulled the pair
+     further in, to spec §4.2's own [contentLeft-40, contentLeft-4] — the
+     clearance is 16px at this padding rather than 2px. The padding stays at
+     56px: nothing asks for the text column to move, and this measurement is
+     the one the §4.2 conflict-1 guard is written against.) The 20px table row grip
      still straddles contentLeft at [contentLeft-10, contentLeft+10], so its
      8px gap to ⠿ is unchanged. Guarded by the elementFromPoint(splitter.right
      - 2, y) assertion §4.2 asks for, in
@@ -1210,8 +1224,66 @@ ${itemsHtml}
      reaches a negative viewport x and never covers the splitter. The 20px
      table row grip still straddles contentLeft at
      [contentLeft-10, contentLeft+10] - an 8px gap, unchanged. */
-  .ed-handle { left: -36px; top: 0; }
-  .ed-insert { left: -54px; top: 0; }`;
+  /* Stated ONCE, as tokens, because §4.2's three numbers are not independent:
+     the gutter is exactly two buttons wide plus the deliberate right-hand
+     breathing gap, and the hover zone below is exactly the gutter. Writing any
+     of them as a second literal is how the corridor comes back. */
+  :root {
+    --ed-gutter-btn: 18px;
+    --ed-gutter-gap: 4px;
+    --ed-gutter-w: calc(var(--ed-gutter-btn) * 2 + var(--ed-gutter-gap));
+  }
+  .ed-handle {
+    left: calc(-1 * (var(--ed-gutter-btn) + var(--ed-gutter-gap))); top: 0;
+    width: var(--ed-gutter-btn);
+  }
+  .ed-insert {
+    left: calc(-1 * var(--ed-gutter-w)); top: 0;
+    width: var(--ed-gutter-btn);
+  }
+  /* v2.11.1: the gutter's HOVER ZONE, and it is the reason the pair could move
+     back to spec §4.2's own numbers at all.
+
+     Both buttons are revealed by .ed-block:hover, and :hover is true only
+     over the block's border box or over one of the buttons themselves. At
+     -36/-54 that left the band [blockLeft-18, blockLeft) belonging to neither:
+     measured at 1400x900, elementFromPoint() returned main.content for
+     x 394..411, and a real pointer walking out of the text at 100 px/s held
+     the ⠿ at opacity 0 for 16 consecutive frames (~270 ms) — the cursor is
+     between the text and the ⠿ and the ⠿ is not there. Conforming to §4.2
+     ([contentLeft-40, contentLeft-4], the ＋ and ⠿ flush, 4px of breathing
+     room on the right) narrows that band to the 4px gap but does not close it:
+     with the pair moved and this rule taken back out, a 2px-per-frame walk
+     across the same row measured 0.06 / 0.49 / 0.53 at three of its 23 stops —
+     a flicker instead of a disappearance, but still the ⠿ dimming under the
+     cursor that is travelling to it. Geometry alone cannot close it, because §4.2's 4px gap is
+     deliberate (5.3 item 3a's elementFromPoint must land ON the ⠿).
+
+     Two more holes have the same shape and the same cure: the buttons are 20px
+     tall at top:0 while an li row is 24.75px, so the bottom ~4.75px of EVERY
+     row is an empty gutter; and a 61.5px heading's vertical centre is 20px
+     below the bottom of its own ⠿, so moving left from the middle of a heading
+     never reached anything at all.
+
+     One absolutely-positioned pseudo-element spanning the whole gutter for the
+     block's whole height makes :hover continuously true from the text out
+     past the ＋, at every Y. Its width is the --ed-gutter-w token the pair's
+     own offsets are built from, so the two cannot drift apart — if they do,
+     the corridor comes straight back.
+     .ed-block is already position:relative, and position: absolute keeps
+     this out of the li row's flex flow. It is deliberately NOT
+     pointer-events: none: that would stop it being hit-tested, which is the
+     entire mechanism. It therefore also changes what a click in the band
+     hits (main.content -> the block), which wireBlockSelection() in
+     lib/editor/client.js compensates for explicitly — see the
+     clientX-vs-block-rect guard just above its "clicked outside any block"
+     branch. (No backticks in this comment: it lives inside a JS template
+     literal.) */
+  .ed-block::before {
+    content: ""; position: absolute;
+    left: calc(-1 * var(--ed-gutter-w)); top: 0;
+    width: var(--ed-gutter-w); height: 100%;
+  }`;
 
   const html = `<!DOCTYPE html>
 <html lang="en">
@@ -2039,7 +2111,7 @@ ${itemsHtml}
   .ed-block:hover .ed-handle,
   .ed-handle:focus { opacity: 1; }
   .ed-handle:hover { background: rgba(0, 0, 0, 0.08); }
-  /* The ⠿ handle's menu: 轉換成 › / 複製 / 刪除 / MD 原始碼 (spec §3.7).
+  /* The ⠿ handle's menu: 轉換成 › / 建立副本 / 刪除 / MD 原始碼 (spec §3.7).
      Dark translucent panel, bordered rows — same visual language as
      .ed-seltb below.
 
@@ -2086,7 +2158,9 @@ ${itemsHtml}
      wording allows this ("left gutter, above or beside it").
 
      S1 Task 5 (D6): edit mode now overrides BOTH buttons to sit side by side
-     (＋ at left:-54px, ⠿ at left:-36px, both top:0) — see editModeLayoutCss.
+     (v2.11.1, spec §4.2's own numbers: ＋ at left:-40px, ⠿ at left:-22px,
+     both top:0, plus a .ed-block::before hover zone spanning the pair) — see
+     editModeLayoutCss.
      That became possible only once .content gained 48px of edit-mode padding;
      the stacked geometry declared here is what any NON-edit render would use,
      and those never emit .ed-block at all, so it is inert there. Kept rather

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helping-ai-workflow/md2doc",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "description": "Markdown → HTML / PDF renderer with WaveDrom, Mermaid, and Graphviz support",
   "keywords": [
     "markdown",