@helping-ai-workflow/md2doc 3.0.0 → 3.0.1

package/lib/editor/client.js

@@ -2009,6 +2009,30 @@
       '<path d="M6.6 7.2v4.2"/><path d="M9.4 7.2v4.2"/>',
     // MD 原始碼 — angle brackets: source, not prose.
     code: '<path d="M6 3.6L2 8l4 4.4"/><path d="M10 3.6L14 8l-4 4.4"/>',
+    // ── v3.0.1: one icon per 轉換成 target ────────────────────────────────
+    // Keys are CONVERT_TARGETS[].id verbatim; openConvertSubmenu() looks them
+    // up by that id, so a rename on either side must be made on both.
+    // 文字 — a paragraph pilcrow, drawn rather than typed so it inherits the
+    // same stroke weight as every sibling icon.
+    text: '<path d="M9 2.5H6.2a2.7 2.7 0 0 0 0 5.4H9"/><path d="M9 2.5v11"/><path d="M11.8 2.5v11"/>',
+    // 標題 1–6 — an "H" plus the level, as two strokes and a numeral bar set.
+    h1: '<path d="M3 3v10"/><path d="M8 3v10"/><path d="M3 8h5"/><path d="M11.5 6.5l1.5-1v7.5"/>',
+    h2: '<path d="M3 3v10"/><path d="M8 3v10"/><path d="M3 8h5"/><path d="M11 6.6a1.6 1.6 0 0 1 2.7 1.1c0 1.4-2.7 2.6-2.7 5.3h3"/>',
+    h3: '<path d="M3 3v10"/><path d="M8 3v10"/><path d="M3 8h5"/><path d="M11 5.8h2.7l-1.6 2.6a1.8 1.8 0 1 1-1.3 3"/>',
+    h4: '<path d="M3 3v10"/><path d="M8 3v10"/><path d="M3 8h5"/><path d="M13 5.8v7.2"/><path d="M13 10.7h-2.6l2.2-4.9"/>',
+    h5: '<path d="M3 3v10"/><path d="M8 3v10"/><path d="M3 8h5"/><path d="M13.5 5.8h-2.6v2.8a1.9 1.9 0 1 1-.5 3.6"/>',
+    h6: '<path d="M3 3v10"/><path d="M8 3v10"/><path d="M3 8h5"/><path d="M13.4 6.2a1.9 1.9 0 0 0-3 1.5v3.2a1.8 1.8 0 1 0 3.1-1.3 1.8 1.8 0 0 0-3.1 1.3"/>',
+    // 項目符號列表 — three dots with three rules.
+    ul: '<circle cx="3.2" cy="4.2" r="1"/><circle cx="3.2" cy="8" r="1"/><circle cx="3.2" cy="11.8" r="1"/>' +
+      '<path d="M6.4 4.2h7.4"/><path d="M6.4 8h7.4"/><path d="M6.4 11.8h7.4"/>',
+    // 編號列表 — the same three rules led by 1/2/3 strokes.
+    ol: '<path d="M2.2 3.4l1-.6v2.8"/><path d="M2 8.2a1 1 0 0 1 1.7.7c0 .9-1.7 1.6-1.7 2.4h1.9"/>' +
+      '<path d="M2.1 11.4h1.6l-1 1.1a1 1 0 1 1-.7 1.2"/>' +
+      '<path d="M6.4 4.2h7.4"/><path d="M6.4 8.6h7.4"/><path d="M6.4 12.9h7.4"/>',
+    // 待辦清單 — a checked box.
+    task: '<rect x="2.2" y="2.6" width="10.8" height="10.8" rx="2.4"/><path d="M5.2 8.2l2.1 2.1 3.8-4"/>',
+    // 引用 — a quote bar plus two shortened rules.
+    quote: '<path d="M3 3.4v9.2"/><path d="M6.4 5.4h7.2"/><path d="M6.4 8h7.2"/><path d="M6.4 10.6h4.6"/>',
   };
   function menuIconMarkup(name) {
     return '<svg class="ed-menu-icon" viewBox="0 0 16 16" width="16" height="16" ' +
@@ -2191,7 +2215,13 @@
       const b = document.createElement('button');
       b.type = 'button';
       b.className = 'ed-handle-menu-btn';
-      b.textContent = t.label;
+      // v3.0.1: the submenu carries icons too. Without them its labels start
+      // at the button's own padding while the parent menu's start past a 16px
+      // icon, so the two levels' text does not share a vertical line — the
+      // exact defect the user reported. `.ed-handle-menu-btn` is already a
+      // flex row with a gap, so an icon plus a text node is all it takes.
+      b.innerHTML = menuIconMarkup(t.id);
+      b.appendChild(document.createTextNode(t.label));
       b.setAttribute('aria-label', 'Convert to ' + t.id);
       b.addEventListener('click', (e) => {
         e.stopPropagation();
@@ -4186,7 +4216,16 @@
     // S1 removed the pre-per-li 'list' branch that lived here: blockmap has not
     // emitted type:'list' blocks since Phase 4, so no startBurst() call could
     // produce blockType === 'list' and the branch was already dead code.
-    const result = burst.blockType === 'table' ? tableMd.serializeTable(burst.editEl)
+    // v3.0.1: hand the serializer the table's CURRENT source lines so it can
+    // reuse the author's own column widths instead of flattening the whole
+    // table to minimal form over a one-cell edit. extractBlockSource() is the
+    // same helper the raw editor prefills from, so "what the file says" has
+    // exactly one definition.
+    const tableBlockRec = burst.blockType === 'table'
+      ? blocks.find((b) => b.id === burst.blockId) : null;
+    const result = burst.blockType === 'table'
+      ? tableMd.serializeTable(burst.editEl,
+          tableBlockRec ? extractBlockSource(lines, tableBlockRec) : null)
       : inlineMd.serializeInline(burst.editEl);
     if (result.unsupported.length > 0) {
       // Degrade-never-lose (same contract as Phase 2's openWysiwygEditor()
@@ -5468,16 +5507,29 @@
   function indentListItem(blockEl) {
     const self = liAttrs(blockEl);
     if (!self) return false;
-    // Rule (d): the first item of a LIST has nothing above it to nest under.
-    // Without this the §3.4 clamp would happily read the previous list's last
-    // item as "the previous block" and indent this one underneath it, merging
-    // two lists the user never asked to join. Pre-S1 this fell out of
-    // `previousElementSibling` being null inside the item's own <ul>.
-    if (self.listStart) return false;
     const all = allBlockEls();
     const i = all.indexOf(blockEl);
     if (i < 0) return false;
     const prev = liAttrs(all[i - 1]);
+    // Rule (d), narrowed (v3.0.1). The old rule was `if (self.listStart)
+    // return false` — the first item of a LIST has nothing above it to nest
+    // under. That over-refused: a bullet outdented to indent 0 directly
+    // BELOW an ordered item is a listStart (a ul following an ol) whose
+    // previous block is a perfectly good parent, and the user could never
+    // indent it back. The half that still has to be refused is the one the
+    // old rule was really aimed at: two list tokens the user kept apart with
+    // a BLANK LINE. Indenting the second one makes listRunOf() span both,
+    // and re-serializing that span swallows the blank line — a rewrite of
+    // lines nobody touched, which is the one thing this editor must never do.
+    // Contiguity is a fact about the FILE, so it is read off `blocks`, not
+    // guessed from the DOM.
+    if (self.listStart) {
+      if (!prev) return false;
+      const prevRec = blockRecOf(all[i - 1]);
+      const selfRec = blockRecOf(blockEl);
+      if (!prevRec || !selfRec) return false;
+      if (prevRec.endLine + 1 !== selfRec.startLine) return false;
+    }
     const max = prev ? prev.indent + 1 : 0;
     const next = Math.min(self.indent + 1, max);
     if (next === self.indent) return false;
@@ -5554,22 +5606,39 @@
 
   // How far ONE member may move, as a magnitude (0 or 1), never a signed
   // delta. `dir` is +1 (Tab) or -1 (Shift+Tab). The ceiling restates
-  // indentListItem()'s own single-item rule — the list-start clause included,
-  // so a set that opens a list cannot nest itself under the previous list's
-  // last item — and the floor is outdentListItem()'s (indent 0 cannot rise).
-  // Both read PRE-move indents, which is §3.4's global convention ("the
-  // operated block's indent" always means the value before the operation), and
-  // it is what makes the minimum below well-defined: every member is measured
-  // against the document as it stands, not against members already moved.
+  // indentListItem()'s own single-item rule, v3.0.1's narrowed list-start
+  // clause included: a listStart member still refuses UNLESS the block
+  // immediately before it (by file line, via blockRecOf — same contiguity
+  // check, same code shape as indentListItem()'s, kept in that shape
+  // deliberately so the two stay in visible agreement) is a contiguous list
+  // item, in which case it has real head-room like any other item. Before
+  // v3.0.1 this was unconditional (`if (self.listStart) return 0;`) —
+  // batch Tab on a listStart block was refused outright, matching
+  // indentListItem()'s then-unconditional refusal. Narrowing ONE of the two
+  // without the other silently reintroduces the single-item defect on the
+  // batch axis: a listStart item directly below a contiguous ordered item,
+  // selected as part of a batch, would stay refused even though the very
+  // same block indents fine on its own. The floor is outdentListItem()'s
+  // (indent 0 cannot rise), untouched by this narrowing. Both read PRE-move
+  // indents, which is §3.4's global convention ("the operated block's
+  // indent" always means the value before the operation), and it is what
+  // makes the minimum below well-defined: every member is measured against
+  // the document as it stands, not against members already moved.
   function memberIndentHeadroom(el, dir) {
     const self = liAttrs(el);
     if (!self) return 0;
     if (dir < 0) return self.indent > 0 ? 1 : 0;
-    if (self.listStart) return 0;
     const all = allBlockEls();
     const i = all.indexOf(el);
     if (i < 0) return 0;
     const prev = liAttrs(all[i - 1]);
+    if (self.listStart) {
+      if (!prev) return 0;
+      const prevRec = blockRecOf(all[i - 1]);
+      const selfRec = blockRecOf(el);
+      if (!prevRec || !selfRec) return 0;
+      if (prevRec.endLine + 1 !== selfRec.startLine) return 0;
+    }
     const max = prev ? prev.indent + 1 : 0;
     return Math.max(0, Math.min(1, max - self.indent));
   }
@@ -5623,7 +5692,30 @@
       // segment delta for the blocks below instead of N independent clamps, and
       // its rule 1 then walks the operated blocks in document order so each is
       // measured against the member above it that the same pass just settled.
-      applyIndentClamp(run, liEls, oldIndent);
+      //
+      // v3.0.1 (review round 1 follow-up): `run` above is batchRunOf()'s
+      // PRE-mutation snapshot — the exact same staleness handleLiKeydown()'s
+      // single-item Tab branch had before its own v3.0.1 fix (see that
+      // call's comment). For a single-member batch on a listStart item whose
+      // ceiling memberIndentHeadroom() has just narrowed (a bullet directly
+      // below a contiguous ordered item), the pre-mutation run is `[liEls[0]]`
+      // alone — batchRunOf() never walked backward past the list-start
+      // boundary, because before this fix nothing could ever cross it. With
+      // no anchor IN the span, applyIndentClamp()'s rule 1 has nothing to
+      // bound the indent the forEach above just wrote against, and clamps it
+      // straight back to 0 — silently undoing the write, MEASURED directly:
+      // narrowing memberIndentHeadroom() alone left the covering test RED.
+      // A FRESH listRunOf(liEls[0]) call here — taken after the write above —
+      // walks back from the NEW indent and finds the real parent, exactly
+      // like the post-mutation `liveRun = listRunOf(liEls[0])` a few lines
+      // below (the COMMIT span) already does; using the same fresh call for
+      // the clamp keeps the two consistent, same reasoning as
+      // handleLiKeydown()'s Tab branch. Provably identical to the old stale
+      // `run` for every case where no member was ever a list-start
+      // (listRunOf() slices by INDEX RANGE, and neither the range's
+      // start/end index nor the elements between them shift when only
+      // already-run-member indents change).
+      applyIndentClamp(listRunOf(liEls[0]), liEls, oldIndent);
     });
     // Re-derived AFTER the mutation, like the caret Tab's: an indent change can
     // move a block between runs.
@@ -5854,7 +5946,26 @@
       const oldIndent = Number(li.getAttribute('data-indent')) || 0;
       const changed = mutateListRun(() => {
         if (!(e.shiftKey ? outdentListItem(li) : indentListItem(li))) return false;
-        applyIndentClamp(run, li, oldIndent);
+        // v3.0.1: `run` above is a PRE-mutation snapshot, captured while `li`
+        // still had its OLD indent. That is fine for outdentListItem() — the
+        // clamp's model rereads every element's CURRENT data-indent off the
+        // DOM, so it self-corrects regardless of which elements the snapshot
+        // names — but indentListItem() can now move a rule-(d) list-start
+        // item (a bullet directly below an ordered item, say) whose own
+        // pre-mutation run is `[li]` alone: nothing shallower ever preceded
+        // it, because runBlocksOf() stops at a list-start by design. With no
+        // anchor IN the span, applyIndentClamp()'s rule 1 has nothing to
+        // bound the indent this call just wrote against, and clamps it
+        // straight back to 0 — silently undoing the write. A FRESH
+        // listRunOf(li) call here — taken after the write above — walks back
+        // from li's NEW indent and finds the real parent, exactly like the
+        // post-mutation `run = listRunOf(li)` a few lines below (the COMMIT
+        // span) already does; using the same fresh call for the clamp keeps
+        // the two consistent. Provably identical to the old stale `run` for
+        // every case where li was never a list-start (listRunOf() slices by
+        // INDEX RANGE, and neither the range's start/end index nor the
+        // elements between them shift when only li's own indent changes).
+        applyIndentClamp(listRunOf(li), li, oldIndent);
         return true;
       });
       if (!changed) return true;
@@ -6426,8 +6537,12 @@
   function tableIdentityOf(tableEl) {
     const headerRow = tableEl ? headerRowOf(tableEl) : null;
     if (!headerRow) return null;
-    return allRowsOf(tableEl).length + '
' +
-      Array.prototype.slice.call(headerRow.cells).map((c) => c.textContent).join('');
+    // The two delimiters are written as ESCAPES, not as literal control
+    // bytes. They used to be literal, which made grep classify this whole
+    // 9643-line file as binary and SILENTLY TRUNCATE its output — a real
+    // investigation was misled by it. The runtime value is identical.
+    return allRowsOf(tableEl).length + '\x01' +
+      Array.prototype.slice.call(headerRow.cells).map((c) => c.textContent).join('\x00');
   }
   async function ensureTableBurstOpen(tableEl) {
     if (currentBurst && currentBurst.blockType === 'table' && currentBurst.editEl === tableEl) return tableEl;
@@ -6907,19 +7022,20 @@
   // listener (wired near the bottom of this file) that already drives
   // updateTableInsertBubbles() — see its own comment for the coalescing
   // contract this reuses.
-  // Geometry, per axis (they are NOT mirror images — see below):
+  // Geometry, per axis (v3.0.1: they are mirror images again):
   //   COLUMN grip: its CENTRELINE coincides with the table's TOP border, so
   //     its hit rect straddles that border by half its own height on each
   //     side (P0-a).
-  //   ROW grip: its LEFT EDGE coincides with the table's LEFT border, so the
-  //     whole grip is INSIDE the table. This is spec §4.2 hit-test
-  //     conflict 2's ruling, landed in S4 T1.
-  //
-  // Why the row axis had to break the symmetry. The block's own gutter ⠿
-  // hangs outside the content box at [blockLeft-22, blockLeft-4], and a
-  // table block's own table starts AT blockLeft, so a row grip centred on
-  // the table's left border occupied [blockLeft-10, blockLeft+10] and
-  // overlapped the ⠿'s right 6px. Both are position: fixed / absolutely
+  //   ROW grip: its CENTRELINE coincides with the table's LEFT border, so
+  //     its hit rect straddles that border by half its own width on each
+  //     side — same shape as the column grip, restored in v3.0.1 (spec §4.2
+  //     hit-test conflict 2).
+  //
+  // History: why the row axis briefly broke the symmetry, and how that was
+  // undone. The block's own gutter ⠿ hangs outside the content box, and a
+  // table block's own table starts at that same left edge, so a row grip
+  // centred on the table's left border occupied [blockLeft-10, blockLeft+10]
+  // and overlapped the ⠿'s right 6px. Both are position: fixed / absolutely
   // positioned overlays and the grip is a document.body child at z-index 7,
   // so the grip won that hit test whenever it was showing — which is
   // whenever the pointer had recently been over a table cell. MEASURED on
@@ -6930,20 +7046,32 @@
   // 402..407. S4 makes the ⠿ a drag handle, so those 6px would have started
   // a table ROW drag instead of a block move.
   //
-  // An earlier revision (v2.10.1) already tried the inset and was reverted,
+  // S4 T1 (v2.12.0) fixed that by INSETTING the grip instead — its left edge
+  // on the table's left border, entirely inside the table, no more straddle.
+  // That broke the row/column symmetry (the column grip still straddles the
+  // table's top border, because nothing of the page's own chrome lives up
+  // there) and was reported as a v3.0.1 visual regression. An even earlier
+  // revision (v2.10.1) had already tried an inset like it and been reverted,
   // because a 20px grip inside a cell whose left padding is 14px sits on
-  // that cell's TEXT. That is fixed on the CSS side this time rather than by
-  // giving the grip back its outside half: lib/md2doc.js pads the first
-  // column to --ed-te-cell-pad-left (the grip's own width plus the gutter
-  // pair's breathing gap) in EDIT MODE ONLY. The ⠿ ↔ grip clearance that
-  // remains is exactly that same breathing-gap token — see the edit-mode
-  // :root block in lib/md2doc.js, which spells both tokens out; this file
-  // deliberately does not name them, because test/editor-client.test.js
-  // forbids the retired hover-gutter class name as a bare substring and the
-  // token names contain it. Neither edge is written down twice, so the two
-  // cannot drift apart again — drift is what produced this defect (the CSS
-  // comment claiming "an 8px gap" was describing v2.11.0's pair position,
-  // which v2.11.1 replaced).
+  // that cell's TEXT — S4 T1 avoided repeating that by widening the first
+  // column's own edit-mode padding to clear the inset grip.
+  //
+  // v3.0.1 undoes the inset rather than re-tuning it: the row grip goes back
+  // to straddling the border (this file's change, see updateTableEdgeGrips()
+  // below), and the ⠿/＋ pair itself moves further LEFT instead (a shift
+  // token declared alongside the gutter's own tokens in lib/md2doc.js) — the
+  // overlap is removed at its SOURCE, not by moving the grip out of the
+  // ⠿'s way. That also means the first column's edit-mode padding widening
+  // is gone: the grip's straddling half (10px) fits inside the column's
+  // default 14px padding on its own, so v2.10.1's original defect does not
+  // come back. Neither the ⠿'s right edge nor the grip's left edge is
+  // written down as a literal on either side of the gap between them — see
+  // the shift-token comment in lib/md2doc.js's edit-mode :root block, which
+  // this file deliberately does not name (test/editor-client.test.js forbids
+  // the retired hover-gutter class name as a bare substring and the token
+  // name contains it) — so the two cannot drift apart the way v2.11.0's pair
+  // position once did (the CSS comment claiming "an 8px gap" was describing
+  // that stale position, which v2.11.1 replaced).
   // test/editor-client-runtime.test.js asserts BOTH directions: every pixel
   // of a block's ⠿ answers that ⠿ (row grip hidden and showing), and the row
   // grip's own centre answers the row grip.
@@ -6962,6 +7090,19 @@
   // reported overlap corner AND verifies the z-index ordering directly —
   // re-verify it if either the grip's or bubble's z-index ever changes.
 
+  // --ed-te-grip-row-w, read once and cached. The token is the single source
+  // of truth for the grip's width (lib/md2doc.js declares it); parsing it here
+  // means the JS never carries a second copy of the number.
+  let gripRowWidthCache = null;
+  function gripRowWidthPx() {
+    if (gripRowWidthCache !== null) return gripRowWidthCache;
+    const raw = getComputedStyle(document.documentElement)
+      .getPropertyValue('--ed-te-grip-row-w');
+    const n = parseFloat(raw);
+    gripRowWidthCache = Number.isFinite(n) && n > 0 ? n : 20;
+    return gripRowWidthCache;
+  }
+
   function buildTableGrip(cls, ariaLabel) {
     const b = document.createElement('button');
     b.type = 'button';
@@ -7025,16 +7166,18 @@
   // gripCenter(), which jump straight to the grip's own coordinates) could
   // ever land on it; a real mouse gesture could not.
   //
-  // Current geometry (the two axes DIVERGED in S4 T1, §4.2 conflict 2): the
-  // COLUMN grip still straddles the table's TOP border, half above / half
-  // below, so the corridor-crossing bug described above still applies to it
-  // exactly as originally described and pointInColGripZone() still covers
-  // the outside-the-border corridor. The ROW grip is now entirely INSIDE the
-  // table (its left edge on the table's left border), so a pointer
-  // travelling from a cell to it never leaves the table and there is no
-  // corridor to cross — pointInRowGripZone() is the padded grip rect alone.
-  // See its own comment for why the old formula was deleted rather than
-  // left in place to evaluate to the empty set.
+  // Current geometry (v3.0.1 restored the row axis to mirror the column
+  // axis — see the "Notion-style row/column grip handles" section comment
+  // above for the S4 T1 detour into an inset row grip and how it was
+  // undone): BOTH grips straddle their own border again, the COLUMN grip
+  // half above / half below the table's TOP border and the ROW grip half
+  // outside / half inside the table's LEFT border. The corridor-crossing
+  // bug described above therefore applies to BOTH axes' straddling shape in
+  // principle, and pointInColGripZone() still covers the column's
+  // outside-the-border corridor exactly as before. pointInRowGripZone()
+  // deliberately does NOT get an equivalent corridor formula back, even
+  // though the straddle is back — see its own comment for why the padded
+  // grip rect alone is still sufficient.
   //
   // Review fix (Important, first pass over-permissive): the first version of
   // this fix kept a grip visible while the pointer was ANYWHERE within the
@@ -7047,30 +7190,28 @@
   // SPECIFIC shown grip's own anchor (pointInRowGripZone()/
   // pointInColGripZone() below) instead of the whole table.
   //
-  // What each keep-zone covers TODAY — and the two axes diverged when §4.2
-  // conflict 2 moved the row grip inside the table (S4 T1):
-  //   pointInColGripZone() still keeps the ORIGINAL corridor shape: the
-  //     union of (the column grip's own padded rect) and (the straight strip
-  //     between the grip's own TOP edge and the table's top border, x clamped
-  //     to the anchor COLUMN's own horizontal extent, padded). The column
-  //     grip still straddles the top border, so that corridor is still real.
-  //   pointInRowGripZone() is now the padded grip rect ALONE. Its corridor
-  //     was the strip between the grip's own LEFT edge and the table's LEFT
-  //     border; with the grip's left edge ON that border the strip is empty,
-  //     and §4.6 explicitly warns that leaving the formula in place would
-  //     make it (and the two scenarios downstream of it) silently vacuous
-  //     rather than red. It is deleted rather than left to read as if it did
-  //     something. Nothing is lost: the corridor existed because a pointer
-  //     travelling from a cell to a border-straddling grip had to leave the
-  //     table on the way, and a grip that is entirely inside the table has no
-  //     such approach — the pointer goes cell -> grip, and the
-  //     `target.closest('.ed-te-grip-row')` early return at the top of
-  //     updateTableEdgeGrips() covers the moment it arrives. The observable
-  //     change is that leaving the table on the left now hides the row grip
-  //     immediately, at the anchor row's own height as well as at any other
-  //     row's; the scenario named below asserts both halves, because "hidden
-  //     at another row's height" alone is true of any geometry once the
-  //     corridor is gone.
+  // What each keep-zone covers TODAY:
+  //   pointInColGripZone() keeps the ORIGINAL corridor shape: the union of
+  //     (the column grip's own padded rect) and (the straight strip between
+  //     the grip's own TOP edge and the table's top border, x clamped to the
+  //     anchor COLUMN's own horizontal extent, padded). The column grip
+  //     straddles the top border, so that corridor is real.
+  //   pointInRowGripZone() is the padded grip rect ALONE, no corridor term —
+  //     kept that way through the v3.0.1 straddle restoration on purpose,
+  //     not left behind by accident. A pointer travelling from inside a body
+  //     cell to the row grip's own centre (which sits exactly on the
+  //     table's left border) never has to leave the table's horizontal
+  //     extent on the way there, so the padded rect alone already covers
+  //     every REAL (non-teleporting) approach this file's own test suite
+  //     exercises — see "table grips: the row grip straddles the table's
+  //     left border again…" in test/editor-client-runtime.test.js. That is
+  //     narrower than the column axis's guarantee (nothing approaches the
+  //     row grip from further out along the table's own left edge the way a
+  //     pointer can approach the column grip from above it), which is why
+  //     the two functions are allowed to stay asymmetric even though the
+  //     grips' shapes are not. If a future report finds a real pointer path
+  //     that does need a corridor term here, that is a new, separate defect
+  //     — not evidence this reasoning was wrong when it was written.
   // A pointer outside either grip's own zone is a genuine exit and still
   // hides the grip via hideTableGrips(), same as before. Neither fix touches
   // either grip's size or z-index, so the click-priority guarantee (bubble
@@ -7090,16 +7231,32 @@
   function pointInRowGripZone(x, y) {
     if (rowGrip.hidden || !gripRowTableEl || !gripRowEl ||
       !document.body.contains(gripRowEl) || !document.body.contains(gripRowTableEl)) return false;
-    // §4.2 衝突 2（S4 T1）之後 row grip 整個落在表格內側，左緣就壓在表格
-    // 左邊界上，所以舊的走廊公式 `x >= gr.left && x <= tableRect.left` 塌成
-    // 空集合。§4.6 已經預告過這件事：留著它不會變紅，只會變成空測。這裡
-    // 直接刪掉，keep-zone 只剩 grip 自己的 padded rect。
-    // 走廊本來只為了一件事存在——指標從儲存格走向一個跨在邊界上的 grip
-    // 時必定會先離開表格；grip 內移之後那條路徑整段都在表格內（先是
-    // 儲存格，接著是 grip 自己，由 updateTableEdgeGrips() 開頭那個
-    // `target.closest('.ed-te-grip-row')` 早退接手），所以沒有走廊可走。
-    // 對使用者可見的差別是：從左側離開表格會立刻收掉 row grip，錨定那一
-    // 列的高度也不例外。
+    // v3.0.1 恢復跨界：row grip 的中心線重新落在表格左邊界上（不再是
+    // S4 T1 那個左緣頂在邊界上、整個縮進表格內側的做法）。與 ⠿ 的重疊
+    // 改在源頭解決——往左再位移的是頁面 gutter 的 ⠿/＋ 那一對按鈕本身
+    // （多移動一個位移 token，宣告在 lib/md2doc.js 的編輯模式 :root 區
+    // 塊，此檔案依慣例不直接引用其名稱），不是移動 grip。
+    //
+    // 走廊公式沒有跟著補回來，是刻意維持的範圍決定，不是漏掉：
+    // TE_GRIP_ZONE_PAD_PX=4 的 padded rect 涵蓋 [tableLeft-14,
+    // tableLeft+14]（grip 本身 20px 寬、跨在邊界上是 [tableLeft-10,
+    // tableLeft+10]，外加 4px 緩衝）。指標從儲存格內側走向 grip 中心
+    // （正好落在 tableLeft）的整段路徑，x 一律 >= tableLeft，從未離開
+    // 表格的水平範圍，所以「儲存格 -> grip」這條測試套件唯一驗證過的
+    // 真實（非瞬移）路徑，本來就不需要走廊公式。哪天真的量到一條需要
+    // 走廊的真實路徑（例如從表格左側、gutter 那一側靠近），那是新的、
+    // 獨立的缺陷，不代表這裡當初的推論錯了。
+    //
+    // 誠實記一筆巧合，不要誤讀成保證：⠿ 的右緣恰好落在 tableLeft-14，
+    // 與這個 padded rect 的左緣相觸、不重疊——這是 TE_GRIP_ZONE_PAD_PX
+    // 這個寫死的 4，與 lib/md2doc.js 那個 4px 呼吸間距 token 兩個各自
+    // 獨立宣告出來的巧合，不是誰推導誰的保證。任一邊數值改動，觸點都
+    // 可能變成 1px 縫隙或重疊，沒有任何型別檢查會抓到。這是既有狀態，
+    // 不是本次修正引入或修掉的東西。
+    //
+    // 對使用者可見的差別：離開表格左側不再等於立刻收掉 row grip——padded
+    // rect 本身就已經探出表格邊界 14px，所以指標要離開這整個 padded rect
+    // （水平或垂直）才會真的收掉，錨定那一列的高度也不例外。
     return pointInPaddedRect(x, y, rowGrip.getBoundingClientRect(), TE_GRIP_ZONE_PAD_PX);
   }
 
@@ -7167,10 +7324,11 @@
     // Row grip: every row, including the header — the first row of a
     // markdown table IS the header, so any row must be draggable to the
     // top to become it. ONE position rule for all of them (user acceptance:
-    // 「grip 位置都一樣」) — its LEFT EDGE on the table's left border, i.e.
-    // entirely inside the table (spec §4.2 hit-test conflict 2, landed
-    // S4 T1 — see the geometry note above buildTableGrip() for the
-    // measurement that forced it), vertically centred on its own row; no
+    // 「grip 位置都一樣」) — its CENTRELINE on the table's left border, i.e.
+    // straddling it half outside / half inside the table, restored in
+    // 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 —
@@ -7183,16 +7341,18 @@
       // Fallback height matches .ed-te-grip-row's own CSS height exactly
       // (28) — offsetHeight reads 0 while `hidden` (display: none) is still
       // true on the FIRST show of a hover session, before the
-      // `hidden = false` assignment below takes effect. There is no width
-      // fallback any more, and that is the point: the left edge is the
-      // table's own border, so the grip's WIDTH is not an input to its
-      // position at all. It used to be (`tableRect.left - gw / 2`), which
-      // meant the CSS width and this literal `20` had to agree for the
-      // gutter clearance to hold — exactly the drift §4.2 conflict 2 is
-      // about. The width now lives in one place only, the
-      // --ed-te-grip-row-w token in lib/md2doc.js.
+      // `hidden = false` assignment below takes effect.
       const gh = rowGrip.offsetHeight || 28;
-      rowGrip.style.left = tableRect.left + 'px';
+      // v3.0.1: back to STRADDLING the table's left border (the S4 T1 inset
+      // was a workaround for the ⠿ hit-test overlap; the ⠿/＋ pair has
+      // since moved further left via a CSS shift token in lib/md2doc.js,
+      // which removes the overlap at its source). The width is read from the
+      // token rather than written as a literal here: offsetWidth reads 0
+      // while `hidden` is still true on the first show of a hover session,
+      // and a hard-coded fallback is exactly the CSS/JS drift the token
+      // exists to prevent.
+      const gw = rowGrip.offsetWidth || gripRowWidthPx();
+      rowGrip.style.left = (tableRect.left - gw / 2) + 'px';
       rowGrip.style.top = (r.top + r.height / 2 - gh / 2) + 'px';
       rowGrip.hidden = false;
     } else {

package/lib/editor/table-md.js

@@ -29,10 +29,38 @@
   // nothing to do with text alignment. Reading them as alignment would be a
   // bug; they are deliberately never consulted below.
   //
-  // ── Emission form (spec §4 / task-5 brief) ─────────────────────────────
-  // '| a | b |' rows (single-space padding); '|---|' separator row — no
-  // padding around the dashes, ':' alignment variants (':---' / '---:' /
-  // ':---:'), dashes never stretched to content width; literal '|' inside
+  // ── Emission form (spec §4 / task-5 brief, amended by v3.0.1) ──────────
+  // There are TWO emission forms, and exactly one gate selects between them:
+  // whether serializeTable() was handed an `originalMd` it could turn into a
+  // usable width source (columnWidthsOf() parsed it, AND the greedy
+  // header-TEXT walk in serializeTable() matched EVERY original column, in
+  // order — the all-or-nothing gate). No second argument, an unparseable or
+  // ragged original, a renamed header, a dropped column: all of them land on
+  // form A.
+  //
+  //   A. MINIMAL form (pre-v3.0.1, unchanged, and still what
+  //      `serializeTable(tableEl)` with no second argument emits — byte for
+  //      byte): '| a | b |' rows with single-space padding; a '|---|'
+  //      separator row with no padding around the dashes, ':' alignment
+  //      variants (':---' / '---:' / ':---:'), dashes never stretched to
+  //      content width, always at least 3 of them.
+  //
+  //   B. WIDTH-PRESERVING form (v3.0.1 欄寬保留): every row of a column,
+  //      header and body alike, is padded out to that column's preserved
+  //      width, and the separator's dash run IS stretched to the same width
+  //      — with NO 3-dash floor, because a legal hand-aligned '|:-:|' must
+  //      not be widened (see sepCellFor() for that floor's exact scope). A
+  //      preserved width only exists for a column whose original fields were
+  //      the same width on every row AND wider than 3; a matched column that
+  //      fails that test still reuses its ORIGINAL separator field's width
+  //      rather than collapsing to the minimal 3. On top of that, F1: when a
+  //      matched column's original separator field already expresses the
+  //      column's current alignment and is already exactly the target width,
+  //      that field is re-emitted VERBATIM — padding and all — so the padded
+  //      separators Prettier and VS Code emit ('| ----- | --- |') survive a
+  //      no-op instead of being rebuilt flush ('|-------|-----|').
+  //
+  // Independent of the form: a literal '|' inside
   // a cell -> '&#124;'; a cell newline is the literal '<br>' inline-md.js's
   // serializeInline() already emits for both a real <br> node and a
   // contenteditable <div> line-split boundary — AND (final-review Finding 1
@@ -121,6 +149,116 @@
     return false;
   }
 
+  // ── v3.0.1 欄寬保留 ────────────────────────────────────────────────────
+  // A cell FIELD is the text between two '|' delimiters, PADDING INCLUDED:
+  // in '| a   | b |' the fields are ' a   ' and ' b '. A column only counts
+  // as a deliberately hand-aligned width source when its field is the SAME
+  // width on EVERY row of the original (header, separator, every body row)
+  // AND that width is greater than 3 — see columnWidthsOf() below for why
+  // both conditions are required (C2, 2026-09-02 review round 1: a uniform
+  // width of 3 is indistinguishable from this serializer's own minimal
+  // form, which is exactly 3 on every row by construction).
+  //
+  // A raw '|' never appears inside a cell in source THIS serializer produced
+  // (it emits '&#124;'), but a hand-written table may use the '\|' escape, so
+  // the split must not break on an escaped delimiter.
+  function splitFields(line) {
+    const t = line.trim();
+    if (t.charAt(0) !== '|' || t.charAt(t.length - 1) !== '|' || t.length < 2) return null;
+    const inner = t.slice(1, -1);
+    const out = [];
+    let cur = '';
+    for (let i = 0; i < inner.length; i++) {
+      const c = inner.charAt(i);
+      if (c === '\\' && inner.charAt(i + 1) === '|') { cur += '\\|'; i += 1; continue; }
+      if (c === '|') { out.push(cur); cur = ''; continue; }
+      cur += c;
+    }
+    out.push(cur);
+    return out;
+  }
+
+  // `{ widths, headerFields, sepFields }` describing the ORIGINAL table, or
+  // null when `originalMd` is absent or is not a table this can read. null
+  // means "no width source" and every caller below then emits minimal form
+  // — the pre-v3.0.1 behaviour, unchanged. `headerFields` (each original
+  // header field, trimmed) is what serializeTable() below uses to line a
+  // CURRENT column back up with the original column it corresponds to — see
+  // the comment at its call site for why index alone is not enough.
+  // `sepFields` (each original SEPARATOR field VERBATIM — padding, colons and
+  // all; always captured, independent of the `uniform`/`> 3` gate below)
+  // serves the separator emission site twice: its LENGTH is the fallback
+  // width for a matched column whose header/body rows aren't uniform (I1,
+  // 2026-09-02 review round 1), and the field ITSELF is re-emitted unchanged
+  // when nothing about that column's separator actually changed (F1,
+  // 2026-09-02 final review) — see sepFieldAlign() and the emission site.
+  //
+  // A column only counts as a width source when its field is the SAME width
+  // on EVERY row (header, separator, every body row) — that is what a
+  // deliberately hand-aligned column looks like — AND that width is > 3. A
+  // column whose original fields are NOT all equal was never hand-aligned to
+  // begin with: it's v3.0.0's un-padded minimal form, where each row's field
+  // is only as wide as that row's own content happens to be (e.g. header
+  // field 6, a body field 7, another body field 5 — three different
+  // numbers, no alignment to preserve). The `> 3` half of the gate catches
+  // the case that slips past the uniform check alone: a minimal-form table
+  // (single-char cells, say) reports the SAME width — exactly 3 — on every
+  // row, because ' a ' and '---' are both 3 characters; that is what THIS
+  // serializer's own minimal form always looks like, not evidence of a
+  // deliberate alignment (C2, review round 1). Without the `> 3` half, an
+  // ordinary minimal-form table would misread itself as "already aligned"
+  // and start re-widening on every edit — the header, the separator, AND
+  // every untouched row — even though v3.0.0 left all three byte-identical.
+  // Reporting `undefined` for such a column — rather than the width seen —
+  // means every caller's `widths[i] || 0` / `row[i] === undefined` checks
+  // fall through to independent per-row minimal form for it, exactly as if
+  // the column had no original at all.
+  function columnWidthsOf(originalMd) {
+    if (typeof originalMd !== 'string' || originalMd === '') return null;
+    const rows = originalMd.split('\n').filter((l) => l.trim() !== '');
+    if (rows.length < 2) return null;
+    const first = splitFields(rows[0]);
+    if (!first) return null;
+    const widths = first.map((f) => f.length);
+    const uniform = widths.map(() => true);
+    let sepFields = null;
+    for (let r = 1; r < rows.length; r++) {
+      const fields = splitFields(rows[r]);
+      // A ragged original is not a width source — bail rather than guess.
+      if (!fields || fields.length !== widths.length) return null;
+      if (r === 1) sepFields = fields.slice();
+      for (let c = 0; c < fields.length; c++) {
+        if (fields[c].length !== widths[c]) uniform[c] = false;
+      }
+    }
+    for (let c = 0; c < widths.length; c++) {
+      if (!uniform[c] || widths[c] <= 3) widths[c] = undefined;
+    }
+    return { widths, headerFields: first.map((f) => f.trim()), sepFields };
+  }
+
+  // ' content ' right-padded out to `width`. NEVER truncates: a cell whose
+  // content grew past the original column simply widens that column, and a
+  // deliberately blank hand-aligned cell (e.g. `|     |` kept wide on
+  // purpose) is reproduced at its full original width, never shrunk down to
+  // its own natural 2 chars — padding is a MINIMUM, not a maximum;
+  // truncating here would delete the user's alignment (or their text).
+  //
+  // (2026-09-02 review round 1, C2: an earlier version special-cased an
+  // EMPTY cell to always emit the natural 2-char field, to stop a freshly
+  // hover-inserted row/column from being padded out to its column's width.
+  // That was a misdiagnosis — the actual cause was columnWidthsOf() treating
+  // a uniform width of 3 (== this serializer's own minimal form) as a
+  // hand-aligned width source, so an ordinary just-inserted minimal-form
+  // column looked "aligned" and got synced. Fixing that at the source (the
+  // `> 3` gate above) made the empty-cell special case both unnecessary AND
+  // actively wrong — it silently discarded a genuinely blank, intentionally
+  // padded cell's width in an aligned table. Removed.)
+  function padField(content, width) {
+    const field = ' ' + content + ' ';
+    return field.length >= width ? field : field + ' '.repeat(width - field.length);
+  }
+
   function cellAlign(cell) {
     const style = cell.getAttribute('style');
     if (!style) return null;
@@ -128,24 +266,65 @@
     return m ? m[1] : null;
   }
 
-  function sepCellFor(align) {
-    if (align === 'left') return ':---';
-    if (align === 'right') return '---:';
-    if (align === 'center') return ':---:';
-    return '---';
+  // The alignment an ORIGINAL separator field already expresses, in the same
+  // vocabulary cellAlign() above returns ('left' / 'right' / 'center' /
+  // null), so the two can be compared directly at the emission site.
+  // Returns `undefined` — which cellAlign() can never return — for anything
+  // that is not a bare separator field, so a field this can't fully account
+  // for can never be re-emitted verbatim. F1 (2026-09-02 final review).
+  function sepFieldAlign(field) {
+    const t = field.trim();
+    if (!/^:?-+:?$/.test(t)) return undefined;
+    const l = t.charAt(0) === ':';
+    const r = t.charAt(t.length - 1) === ':';
+    if (l && r) return 'center';
+    if (l) return 'left';
+    if (r) return 'right';
+    return null;
+  }
+
+  // The dash run is stretched to `width`, minus whatever the colons consume.
+  // The 3-dash floor belongs ONLY to the no-width path (`w === 0`): that is
+  // GFM's own minimum, and it's also exactly the minimal form ('---' /
+  // ':---' / '---:' / ':---:') a width of 0 produces — what makes "no
+  // original" and "minimal-form original" the same answer. A KNOWN width
+  // (`w > 0`) must NOT be floored up to 3: a narrow hand-aligned separator
+  // like '|:--:|' (width 4) or '|:-:|' (width 3) is legal GFM (marked lexes
+  // it as one table token with `align === 'center'`), and flooring it to
+  // '|:---:|' rewrites a line the user never touched — C1 (2026-09-02
+  // review round 1): every center-aligned column narrower than 5, and every
+  // left/right-aligned column narrower than 4, silently widened on an
+  // otherwise-unchanged table, which made commitEdit() write the file and
+  // push an undo entry on a plain click-in/click-away. Floor of 1 instead:
+  // a dash run can't go negative once the colon(s) are subtracted, but it's
+  // otherwise free to reproduce whatever width the original actually had.
+  function sepCellFor(align, width) {
+    const w = typeof width === 'number' ? width : 0;
+    const floor = w > 0 ? 1 : 3;
+    if (align === 'left') return ':' + '-'.repeat(Math.max(floor, w - 1));
+    if (align === 'right') return '-'.repeat(Math.max(floor, w - 1)) + ':';
+    if (align === 'center') return ':' + '-'.repeat(Math.max(floor, w - 2)) + ':';
+    return '-'.repeat(Math.max(floor, w));
+  }
+
+  // The cell's markdown content, WITHOUT padding. Rendered exactly once per
+  // cell (never twice — inlineMd.serializeInline() would double-report
+  // `unsupported` for the same cell), so width measurement and emission
+  // below both read from these same strings.
+  function cellContentOf(cell, unsupported) {
+    if (cellHasCodePipe(cell)) unsupported.push('CODE');
+    const res = inlineMd.serializeInline(cell);
+    res.unsupported.forEach((u) => unsupported.push(u));
+    return escapeNewlines(escapePipes(res.md));
   }
 
-  function serializeRow(cells, unsupported) {
-    const parts = cells.map((cell) => {
-      if (cellHasCodePipe(cell)) unsupported.push('CODE');
-      const res = inlineMd.serializeInline(cell);
-      res.unsupported.forEach((u) => unsupported.push(u));
-      return escapeNewlines(escapePipes(res.md));
-    });
-    return '| ' + parts.join(' | ') + ' |';
+  function serializeRow(contents, widths) {
+    const parts = contents.map((content, i) =>
+      padField(content, widths ? (widths[i] || 0) : 0));
+    return '|' + parts.join('|') + '|';
   }
 
-  function serializeTable(tableEl) {
+  function serializeTable(tableEl, originalMd) {
     const unsupported = [];
     const thead = firstChildNamed(tableEl, 'THEAD');
     const tbody = firstChildNamed(tableEl, 'TBODY');
@@ -165,14 +344,190 @@
       return { md: '', unsupported: ['TABLE_RAGGED'] };
     }
 
+    // Render every cell's content up front (same order the pre-v3.0.1 code
+    // walked: header first, then each body row left-to-right), so the width
+    // pass below and the emission pass after it share one rendering.
+    const headerContents = headerCells.map((c) => cellContentOf(c, unsupported));
+    const bodyContentRows = bodyRows.map((tr) =>
+      elementChildren(tr).filter(isCell).map((c) => cellContentOf(c, unsupported)));
+
+    // Read the ORIGINAL widths first, then line each CURRENT header column
+    // up with the original column it corresponds to BY TEXT, not by raw
+    // index. A column inserted in the MIDDLE (insertColumn() in client.js)
+    // shifts every later column's index by one without changing what that
+    // column actually is — matching by index alone would hand the shifted
+    // column a stale neighbour's width, and the freshly-inserted empty
+    // column would inherit whatever width used to sit at its new index (a
+    // plain-index version of this walk is byte-identical to this one for a
+    // trailing/mid-table INSERT — padField()'s natural fallback already
+    // covers the inserted column either way — but it is NOT for a column
+    // MOVE: test/editor-client-runtime.test.js:7876-7927 drags "Detail"
+    // from the last position to the first and requires ALL THREE widths
+    // dropped even though "Name" and "Note" still sit at index-shifted but
+    // TEXT-unchanged positions; only text-matching, combined with the
+    // all-or-nothing gate below, gets that right). A mismatch that is
+    // simply a RENAMED header (or a dragged ROW promoting a different row
+    // to "header" — the per-column-alignment-survives-header-change
+    // scenario) is walked the exact same way as any other mismatch: it
+    // doesn't advance `j`, so — per the all-or-nothing gate below — it
+    // discards the width source for the WHOLE table, not just that one
+    // column. That reflow-on-rename is TODAY'S shipped, pre-existing
+    // behaviour (v3.0.0 already reflows the whole table on any edit; a
+    // rename doing the same is not a regression) — deliberately NOT
+    // "fixed" here per the 2026-09-02 review round-1 ruling: detecting
+    // rename-vs-permutation is design work that doesn't belong in a patch
+    // release. See test/table-width.test.js's "renamed header" case, which
+    // pins this so the next change to it is deliberate.
+    const original = columnWidthsOf(originalMd);
+    let widths = null;
+    // Set for a column that falls off the END of the original header list
+    // (every original column has already been matched by the time this one
+    // is reached) — a genuinely NEW, appended column, e.g. test case 6's
+    // 'City'. Its separator still tracks its OWN header's natural width
+    // below. This exists to reconcile the brief's OWN case 6: the brief's
+    // Step 5 code unconditionally used `widths[i] || 0` for the separator
+    // (which is 0, i.e. the bare 3-dash minimal, for any unmatched column),
+    // but the brief's own expected string for case 6 has 'City' getting a
+    // 6-dash separator — 'City''s own rendered width, not 3 dashes. No
+    // pre-existing test forces this; it exists purely to make the brief's
+    // Step 5 code and the brief's own case 6 expectation agree with each
+    // other. Any OTHER mismatch (a renamed header, or a row-drag promotion)
+    // gets no special separator treatment: it falls all the way back to the
+    // 3-dash minimal, same as `widths[i]` itself already falls back to
+    // natural per-row padding for it — moot in practice, since the
+    // all-or-nothing gate below discards `widths` entirely for those cases
+    // anyway, so this array is never even consulted for them.
+    const sepFallbackNatural = new Array(headerContents.length).fill(false);
+    // The ORIGINAL separator row's own field, VERBATIM, for each MATCHED
+    // column. Used two ways at the emission site below:
+    //
+    //   • its LENGTH is the fallback width for a matched column whose
+    //     header/body rows are not themselves uniform (`original.widths[j]`
+    //     is `undefined` there — see columnWidthsOf()). I1 (review round 1):
+    //     without this, such a column's header/body rows fell back to their
+    //     own natural content width (which happens to reproduce the original
+    //     bytes when nothing changed), but the separator fell back to the
+    //     bare 3-dash minimal — rewriting a separator line the user never
+    //     touched the moment ANY other cell in the table was edited.
+    //   • the FIELD ITSELF is re-emitted unchanged when the column's
+    //     separator did not actually change (F1, final review) — see the
+    //     verbatim gate at the emission site.
+    const matchedSepFields = new Array(headerContents.length);
+    if (original) {
+      const matched = new Array(headerContents.length);
+      let j = 0;
+      for (let i = 0; i < headerContents.length; i++) {
+        if (j < original.headerFields.length &&
+            headerContents[i].trim() === original.headerFields[j].trim()) {
+          matched[i] = original.widths[j];
+          matchedSepFields[i] = original.sepFields[j];
+          j++;
+        } else {
+          matched[i] = undefined;
+          if (j >= original.headerFields.length) sepFallbackNatural[i] = true;
+        }
+      }
+      // Only trust this walk as a width source AT ALL if it found EVERY
+      // original column, in order, somewhere in the current header row (j
+      // reached the end). A PARTIAL match — some columns matched, some
+      // didn't — means the table's column identity changed in a way this
+      // can't safely map: a column DRAG that reorders existing columns
+      // (rather than just adding one) still finds two of three headers
+      // byte-identical to their originals via this same greedy walk, but
+      // "a column move must carry its alignment with it" requires ALL
+      // THREE widths dropped, not just the moved one — a per-column guess
+      // here would silently keep stale padding on a column that only
+      // happens to still have the same text. So a partial match discards
+      // the width source for the WHOLE table, same as no original at all.
+      if (j === original.headerFields.length) {
+        widths = matched;
+        // A matched column is then widened, for every row of that column
+        // at once (header + separator + every body row), to whatever the
+        // grown content now needs — the padding floor rises but never
+        // falls, and never truncates (test case 5): "a cell whose content
+        // grew past the original column widens that COLUMN", not just its
+        // own line. An unmatched column's width stays `undefined` here —
+        // comparing a number against `undefined` is always false, so this
+        // loop leaves it alone and padField()'s `|| 0` fallback below
+        // gives it independent per-row minimal form instead.
+        const allRows = [headerContents].concat(bodyContentRows);
+        for (let i = 0; i < widths.length; i++) {
+          let needed = widths[i];
+          allRows.forEach((row) => {
+            if (row[i] === undefined) return;
+            const natural = row[i].length + 2; // 1-space padding, both sides
+            if (natural > needed) needed = natural;
+          });
+          widths[i] = needed;
+        }
+      }
+    }
+
     const lines = [];
-    lines.push(serializeRow(headerCells, unsupported));
-    lines.push('|' + headerCells.map((c) => sepCellFor(cellAlign(c))).join('|') + '|');
+    lines.push(serializeRow(headerContents, widths));
+    lines.push('|' + headerCells.map((c, i) => {
+      // Preference order for a column's separator width:
+      //   1. widths[i] — this column is a full hand-aligned width source
+      //      (matched, uniform, and > 3). Same width the header/body rows
+      //      already use.
+      //   2. matchedSepFields[i].length — this column WAS matched to an
+      //      original column, just not a uniform-width one (I1: reproduces
+      //      the ORIGINAL separator's own field width instead of collapsing
+      //      to the bare 3-dash minimal on an edit elsewhere in the table).
+      //   3. headerContents[i].length + 2, but ONLY for a column that fell
+      //      off the END of the original header list (sepFallbackNatural —
+      //      see above): a genuinely new, appended column still gets a
+      //      separator matching its own header's natural width (case 6:
+      //      'City' has no original width, but its separator is 6 dashes),
+      //      unlike the header/body rows above, whose padField() `|| 0`
+      //      deliberately leaves such a column unsynced.
+      //   4. 0 (the plain 3-dash minimal) — no original table at all
+      //      (`widths` itself is null: cases 1 and 7 stay byte-identical to
+      //      the pre-v3.0.1 minimal form), or a mismatch that is neither a
+      //      matched-but-non-uniform column nor a trailing new one (a
+      //      renamed header, or a row-drag promotion) — moot in practice,
+      //      since the all-or-nothing gate above already discarded
+      //      `widths` entirely for those cases.
+      const origField = matchedSepFields[i];
+      const w = widths
+        ? (widths[i] !== undefined ? widths[i]
+            : origField !== undefined ? origField.length
+            : (sepFallbackNatural[i] ? headerContents[i].length + 2 : 0))
+        : 0;
+      const align = cellAlign(c);
+      // F1 (2026-09-02 final review, Critical): once the width is settled,
+      // prefer the ORIGINAL field's own BYTES over rebuilding them. Every
+      // preference above only ever agreed on the WIDTH of the separator
+      // field; sepCellFor() then rebuilt its contents as a dash run flush
+      // against both delimiters. For the padded separator row Prettier,
+      // prettier-plugin-markdown and VS Code's table formatter all emit —
+      // '| ----- | --- |', the most common machine-aligned markdown table
+      // in the wild — that is the same width but different bytes, so a pure
+      // no-op (click into the table, click away) came back as
+      // '|-------|-----|'. commitRangeEdit() short-circuits only on a
+      // byte-identical result, so that was a REAL op: an undo entry pushed,
+      // `lines` replaced, and the next save writing a line the user never
+      // touched.
+      //
+      // Re-emit the original field verbatim only when BOTH hold, so this can
+      // never smuggle a stale separator past a genuine change:
+      //   (a) the field already expresses the alignment this column now has
+      //       (sepFieldAlign() returns `undefined` for anything that isn't a
+      //       plain separator field, which cellAlign() can never equal, so an
+      //       unparseable field always falls through); and
+      //   (b) the target width `w` is exactly that field's own length — any
+      //       width GROWTH (a cell that outgrew its column, cases 5 and 12)
+      //       lands here with w > origField.length and falls through.
+      // Everything that falls through takes today's sepCellFor() path,
+      // unchanged.
+      if (widths && origField !== undefined &&
+          origField.length === w && sepFieldAlign(origField) === align) {
+        return origField;
+      }
+      return sepCellFor(align, w);
+    }).join('|') + '|');
 
-    bodyRows.forEach((tr) => {
-      const cells = elementChildren(tr).filter(isCell);
-      lines.push(serializeRow(cells, unsupported));
-    });
+    bodyContentRows.forEach((contents) => lines.push(serializeRow(contents, widths)));
 
     return { md: lines.join('\n'), unsupported };
   }

package/lib/md2doc.js

@@ -1086,21 +1086,29 @@ ${itemsHtml}
   // [contentLeft-54, contentLeft-18] until spec §4.2's own numbers were
   // restored), clear of .sidebar-splitter — see the .content rule below.
   //
-  // GEOMETRY, AS MEASURED (S4 T1; the previous version of this comment
-  // claimed "an 8px gap" between the gutter and the table row grip, a number
-  // left over from the v2.11.0 pair position that v2.11.1 invalidated — the
-  // real gap was MINUS 6px, i.e. an overlap):
+  // GEOMETRY, AS MEASURED (v2.12.0/S4 T1; the previous version of this
+  // comment claimed "an 8px gap" between the gutter and the table row grip, a
+  // number left over from the v2.11.0 pair position that v2.11.1
+  // invalidated — the real gap was MINUS 6px, i.e. an overlap):
   //   ⠿          [contentLeft-22, contentLeft-4]   (--ed-gutter-btn wide)
-  //   row grip   [contentLeft,    contentLeft+20]  (--ed-te-grip-row-w wide)
-  // The grip used to be centred on the table's left border at
-  // [contentLeft-10, contentLeft+10], which overlapped the ⠿'s right 6px and
-  // — being position: fixed, z-index 7, on document.body — won the hit test
-  // there. spec §4.2 conflict 2's ruling (grip entirely inside the table)
-  // is landed in lib/editor/client.js's updateTableEdgeGrips(); the
+  //   row grip   [contentLeft-10,  contentLeft+10]  (--ed-te-grip-row-w wide,
+  //              centred on the table's left border)
+  // The grip straddling the table's left border overlapped the ⠿'s right 6px
+  // and — being position: fixed, z-index 7, on document.body — won the hit
+  // test there. v2.12.0/S4 T1's fix moved the grip entirely inside the table
+  // instead (its left edge on the border), which fixed the overlap but
+  // broke the row/column symmetry the user expected (the column grip still
+  // straddles the table's TOP border) — reported as a v3.0.1 regression.
+  // v3.0.1 fixes it at the source instead: the ⠿/＋ pair itself moves
+  // further LEFT by --ed-gutter-shift below, which removes the overlap
+  // without moving the grip at all, so the grip can straddle the border
+  // again (see updateTableEdgeGrips() in lib/editor/client.js). The
   // clearance that remains is exactly --ed-gutter-gap, because the ⠿'s right
-  // edge and the grip's left edge are both derived from it. The grip is kept
-  // off the first cell's TEXT by --ed-te-cell-pad-left below, not by the
-  // 14px default padding, which is narrower than the grip.
+  // edge and the grip's left edge are both derived from it. The grip's
+  // straddling half (10px) sits well inside the first cell's default 14px
+  // left padding, so no extra edit-mode padding is needed any more — the
+  // v2.10.1-era --ed-te-cell-pad-left token this comment used to describe is
+  // gone.
   // (The padding was 48px until §4.2's hit-test conflict 1 was fixed; see the
   // .content rule in editModeLayoutCss below for why it is 56px now.)
   // S1 Task 5: the ordered-list ordinal is drawn by a CSS counter, and the
@@ -1156,12 +1164,14 @@ ${itemsHtml}
      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 table row grip no
-     longer reaches this far left at all: §4.2 conflict 2 moved it inside the
-     table to [contentLeft, contentLeft+20] (S4 T1), so nothing but the gutter
-     pair itself occupies [contentLeft-40, contentLeft-4]. Guarded by the
-     elementFromPoint(splitter.right - 2, y) assertion §4.2 asks for, in
-     test/editor-client-runtime.test.js. */
+     the one the §4.2 conflict-1 guard is written against.) v3.0.1 shifts the
+     pair a further --ed-gutter-shift (10px) left, to [contentLeft-50,
+     contentLeft-14], so the table row grip can straddle the table's own left
+     border again instead of sitting inside it — see the --ed-gutter-shift
+     comment above .ed-handle below. That still leaves 6px of clearance from
+     splitterRight (contentLeft-56), so the conflict-1 guard still holds.
+     Guarded by the elementFromPoint(splitter.right - 2, y) assertion §4.2
+     asks for, in test/editor-client-runtime.test.js. */
   .content { padding-left: 56px; }
 
   /* S1: every block is one full-width row, whatever its type or depth. The
@@ -1231,38 +1241,41 @@ ${itemsHtml}
      [contentLeft-54, contentLeft-18], which with 56px of padding sits wholly
      inside the content column (2px clear of .sidebar-splitter's right edge —
      see the padding rule's own comment for the measurement), so ＋ never
-     reaches a negative viewport x and never covers the splitter. The table
-     row grip is at [contentLeft, contentLeft+20] since §4.2 conflict 2
-     landed (S4 T1), so the clearance from the ⠿'s right edge is exactly
-     --ed-gutter-gap and cannot drift: both edges are derived from it. */
+     reaches a negative viewport x and never covers the splitter. As of
+     v3.0.1 the table row grip straddles the table's left border again
+     (centred on it, [tableLeft-10, tableLeft+10] — see updateTableEdgeGrips()
+     in lib/editor/client.js), and the pair itself has moved left by
+     --ed-gutter-shift below so the clearance from the ⠿'s right edge is
+     still exactly --ed-gutter-gap and cannot drift: both edges are derived
+     from it. */
   /* 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. */
+     breathing gap, and the hover zone below is exactly the gutter plus
+     whatever --ed-gutter-shift moved the pair by. 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));
-    /* spec §4.2 hit-test conflict 2, landed S4 T1. The table row grip now
-       sits ENTIRELY inside the table (its LEFT edge on the table's left
-       border — see updateTableEdgeGrips() in lib/editor/client.js), which
-       leaves the ⠿'s right edge and the grip's left edge exactly
-       --ed-gutter-gap apart: the 4px breathing gap §4.2 already keeps on the
-       right of the gutter pair IS the separation. Nothing new is written
-       down, so nothing new can drift.
-       The consequence is this token: the grip is 20px wide and the first
-       column's default padding is 14px, so an inset grip would sit on that
-       cell's TEXT — the v2.10.1 user-acceptance defect that got the first
-       attempt at this ruling reverted. The first column is padded past the
-       grip instead, by the grip's own width plus that same gap. */
-    --ed-te-cell-pad-left: calc(var(--ed-te-grip-row-w) + var(--ed-gutter-gap));
   }
+  /* v3.0.1: the pair moves LEFT by --ed-gutter-shift so the table row grip
+     can straddle the table's left border again (see updateTableEdgeGrips()
+     in lib/editor/client.js) while still keeping --ed-gutter-gap between the
+     ⠿'s right edge and the grip's left edge. Written as a token because the
+     two rules below and the acceptance test all derive from it. Measured at
+     1400x900 (README.md, first table): pre-shift ⠿=[390,408] ＋=[372,390]
+     tableLeft=412; a 10px shift lands ⠿=[380,398] ＋=[362,380], grip
+     (straddling, 20px wide, centred on tableLeft) = [402,422], leaving
+     exactly --ed-gutter-gap (4px) between the ⠿'s right edge (398) and the
+     grip's left edge (402), and ＋'s left edge (362) stays well clear of 0. */
+  :root { --ed-gutter-shift: 10px; }
   .ed-handle {
-    left: calc(-1 * (var(--ed-gutter-btn) + var(--ed-gutter-gap))); top: 0;
+    left: calc(-1 * (var(--ed-gutter-btn) + var(--ed-gutter-gap) + var(--ed-gutter-shift)));
+    top: 0;
     width: var(--ed-gutter-btn);
   }
   .ed-insert {
-    left: calc(-1 * var(--ed-gutter-w)); top: 0;
+    left: calc(-1 * (var(--ed-gutter-w) + var(--ed-gutter-shift))); top: 0;
     width: var(--ed-gutter-btn);
   }
   /* v2.11.1: the gutter's HOVER ZONE, and it is the reason the pair could move
@@ -1291,9 +1304,17 @@ ${itemsHtml}
 
      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.
+     past the ＋, at every Y. Its span is derived from the SAME two tokens the
+     pair's own offsets are: --ed-gutter-w (the pair's own width, the gutter
+     proper) plus --ed-gutter-shift (how far v3.0.1 moved the pair left to
+     clear the straddling table row grip). Both edges therefore track the
+     pair automatically — the zone's left edge is exactly the ＋'s left edge
+     and its right edge is the block's, with no literal repeated anywhere —
+     so the two cannot drift apart. If they ever do, the corridor comes
+     straight back: v3.0.1 shifted the pair to [blockLeft-50, blockLeft-14]
+     while this rule still read the un-shifted --ed-gutter-w alone, leaving
+     it spanning [blockLeft-40, blockLeft] — 10px short on the left of the
+     very buttons it exists to keep reachable.
      .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
@@ -1305,18 +1326,8 @@ ${itemsHtml}
      literal.) */
   .ed-block::before {
     content: ""; position: absolute;
-    left: calc(-1 * var(--ed-gutter-w)); top: 0;
-    width: var(--ed-gutter-w); height: 100%;
-  }
-
-  /* §4.2 conflict 2's other half: the row grip lives inside the first column
-     now, so that column's cells must be padded past it. EDIT MODE ONLY —
-     reader HTML and PDF output keep the shared 7px 14px and stay
-     byte-identical. Only the LEFT padding changes, and only on the first
-     cell of each row; every other cell is untouched. */
-  .ed-block[data-block-type="table"] th:first-child,
-  .ed-block[data-block-type="table"] td:first-child {
-    padding-left: var(--ed-te-cell-pad-left);
+    left: calc(-1 * (var(--ed-gutter-w) + var(--ed-gutter-shift))); top: 0;
+    width: calc(var(--ed-gutter-w) + var(--ed-gutter-shift)); height: 100%;
   }`;
 
   const html = `<!DOCTYPE html>
@@ -2196,7 +2207,11 @@ ${itemsHtml}
     box-shadow: 0 2px 8px rgba(0, 0, 0, 0.25);
   }
   .ed-handle-menu-btn {
-    min-width: 132px; height: 26px; padding: 0 10px;
+    /* v3.0.1: the icon sits FLUSH LEFT and the label sits one space-width
+       after it (user request: 「符號靠左對齊，文字跟符號間距一個空格」).
+       The right padding is untouched — it is what keeps the 轉換成 row's
+       chevron off the panel edge. */
+    min-width: 132px; height: 26px; padding: 0 10px 0 6px;
     border: 1px solid rgba(255, 255, 255, 0.25); border-radius: 6px;
     background: rgba(255, 255, 255, 0.08); color: inherit;
     font: inherit; font-size: 12px; line-height: 1;
@@ -2207,8 +2222,10 @@ ${itemsHtml}
        width, so S2's one-left-edge / monotonic-top invariants are untouched.
        The submenu's own buttons carry this class and no icon; a lone text node
        is an anonymous flex item at flex-start, i.e. exactly where text-align
-       put it. */
-    display: flex; align-items: center; gap: 8px;
+       put it.
+       v3.0.1: gap dropped from 8px to 4px — one space-width at this 12px
+       font size — now that every row (both menu levels) carries an icon. */
+    display: flex; align-items: center; gap: 4px;
   }
   /* Notion's own sizing. The stroke colour is NOT set here on purpose: the
      markup carries stroke="currentColor" (lib/editor/client.js), so the icon
@@ -2216,8 +2233,20 @@ ${itemsHtml}
      retheme for free. A hex here would break that silently. (No backticks in
      this comment: it lives inside a JS template literal.)
      flex: 0 0 auto because a 16px-wide flex item next to a nowrap label
-     would otherwise be the thing that shrinks. */
-  .ed-menu-icon { flex: 0 0 auto; width: 16px; height: 16px; }
+     would otherwise be the thing that shrinks.
+     v3.0.1: the selector is ".ed-handle-menu-btn .ed-menu-icon", not the
+     bare class — the gutter menu is appended INTO a ".ed-block"
+     (lib/editor/client.js's blockEl.appendChild(gutterMenu)), which is a
+     descendant of <main class="content">, and ".content svg" above
+     carries "margin: 0 auto" at specificity (0,1,1) (one class, one
+     type). The bare ".ed-menu-icon" is only (0,1,0) and LOSES that fight
+     regardless of source order, so every icon picked up centering
+     auto-margins instead of sitting flush left — measured on this branch
+     as an icon offset that swung with label length (11px-40px) instead
+     of a constant one. Scoping under ".ed-handle-menu-btn" raises this
+     to (0,2,0), which wins on class count alone. (No backticks in this
+     comment: it lives inside a JS template literal.) */
+  .ed-handle-menu-btn .ed-menu-icon { flex: 0 0 auto; width: 16px; height: 16px; margin: 0; }
   /* The 轉換成 submenu carries BOTH classes, so it inherits every rule above
      and only overrides the horizontal offset. It is a CHILD of the menu, and
      the menu is itself position:absolute, so the menu's own padding box is
@@ -2361,18 +2390,23 @@ ${itemsHtml}
      affordance) with two real, adequately-sized (>=18x24px) click/drag
      targets. '.ed-te-grip-row' is a vertical 6-dot handle shown at the LEFT
      EDGE of the hovered row -- every row, the HEADER included (spec 3.10:
-     the header is draggable too), sitting ENTIRELY INSIDE the table with its
-     LEFT edge on the table's left border (spec 4.2 hit-test conflict 2,
-     landed in S4 T1). The two axes are therefore NOT mirror images any more:
-     '.ed-te-grip-col' still straddles the table's TOP border, because nothing
-     of the page's own chrome lives up there. The row axis cannot: MEASURED on
-     v2.12.0 at 1400x900, the straddling grip occupied [tableLeft-10,
-     tableLeft+10] while the block's own '.ed-handle' occupied [blockLeft-22,
-     blockLeft-4] with tableLeft == blockLeft, so the grip (position: fixed,
-     z-index 7, on document.body) won the hit test for the RIGHT 6px of every
-     ⠿ whose Y band it reached. The first column's own padding is widened in
-     the edit-mode-only layout chunk near the end of this stylesheet so the
-     inset grip still never reaches cell TEXT; '.ed-te-grip-col' is a horizontal 6-dot
+     the header is draggable too), STRADDLING the table's left border,
+     centred on it (spec 4.2 hit-test conflict 2). v2.12.0/S4 T1 tried moving
+     it entirely inside the table instead (left edge on the border) to stop it
+     winning the hit test against the block's own ⠿ — MEASURED at 1400x900,
+     the straddling grip occupied [tableLeft-10, tableLeft+10] while
+     '.ed-handle' occupied [blockLeft-22, blockLeft-4] with tableLeft ==
+     blockLeft, so the grip (position: fixed, z-index 7, on document.body)
+     won the hit test for the RIGHT 6px of every ⠿ whose Y band it reached —
+     but that broke the row/column symmetry the user expected ('.ed-te-grip-col'
+     still straddles the table's TOP border, because nothing of the page's
+     own chrome lives up there), and was reported as a regression. v3.0.1
+     restores the straddle and instead moves the ⠿/＋ pair itself further left
+     by --ed-gutter-shift, which removes the overlap at its source (see the
+     edit-mode-only layout chunk near the end of this stylesheet); the row
+     grip's straddling half sits well inside the first cell's default 14px
+     padding, so no extra padding token is needed either.
+     '.ed-te-grip-col' is a horizontal 6-dot
      handle shown just ABOVE the hovered column (every column). Dots are plain <span>s laid out via CSS grid with
      place-content: center, so the dot cluster stays compact/centered
      regardless of the button's own (larger, hit-target-sized) box — no
@@ -2391,12 +2425,12 @@ ${itemsHtml}
   .ed-te-grip:hover { background: rgba(0, 0, 0, 0.06); }
   .ed-te-grip-dot { width: 3px; height: 3px; border-radius: 50%; background: #9ca3af; }
   .ed-te-grip:hover .ed-te-grip-dot { background: #6b7280; }
-  /* spec §4.2 hit-test conflict 2 (S4 T1): the row grip's width is a TOKEN
-     because two other numbers are derived from it — lib/editor/client.js pins
-     the grip's LEFT edge to the table's left border (so the whole grip is
-     inside the first column and shares no pixel with the block gutter's ⠿),
-     and the edit-mode first-column padding must be wide enough to host it
-     without covering cell text. Written once here, derived twice below. */
+  /* spec §4.2 hit-test conflict 2: the row grip's width is a TOKEN because
+     lib/editor/client.js's updateTableEdgeGrips() reads it (via
+     gripRowWidthPx()) to CENTRE the grip on the table's left border —
+     tableRect.left - gw / 2. Written once here, read once there, so the CSS
+     width and the JS position can never drift apart the way they did when
+     the position was a hard-coded literal 20. */
   :root { --ed-te-grip-row-w: 20px; }
   .ed-te-grip-row {
     width: var(--ed-te-grip-row-w); height: 28px; cursor: grab; z-index: 7;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helping-ai-workflow/md2doc",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Markdown → HTML / PDF renderer with WaveDrom, Mermaid, and Graphviz support",
   "keywords": [
     "markdown",
@@ -36,7 +36,7 @@
   },
   "scripts": {
     "preinstall": "node scripts/preinstall.js",
-    "test": "node test/md2doc.test.js && node test/blockmap.test.js && node test/images.test.js && node test/scroll-anchor.test.js && node test/lightbox.test.js && node test/lightbox-anno.test.js && node test/lightbox-anno-style.test.js && node test/reader-panels.test.js && node test/cli.test.js && node test/code-operator.test.js && node test/convert-md.test.js && node test/render-api.test.js && node test/lineops.test.js && node test/indent-clamp.test.js && node test/selection.test.js && node test/editmode-render.test.js && node test/editmode-wavedrom-reinit.test.js && node test/editor-server.test.js && node test/cli-edit.test.js && node test/open-viewer.test.js && node test/editor-client.test.js && node test/editor-client-runtime.test.js && node test/roundtrip.test.js && node test/byte-stability.test.js && node test/editor-server-throw.test.js && node test/editor-reader-rebind.test.js && node test/inline-md.test.js && node test/table-md.test.js && node test/gate-compat.test.js && node test/history.test.js && node test/list-md.test.js"
+    "test": "node test/md2doc.test.js && node test/blockmap.test.js && node test/images.test.js && node test/scroll-anchor.test.js && node test/lightbox.test.js && node test/lightbox-anno.test.js && node test/lightbox-anno-style.test.js && node test/reader-panels.test.js && node test/cli.test.js && node test/code-operator.test.js && node test/convert-md.test.js && node test/render-api.test.js && node test/lineops.test.js && node test/indent-clamp.test.js && node test/selection.test.js && node test/editmode-render.test.js && node test/editmode-wavedrom-reinit.test.js && node test/editor-server.test.js && node test/cli-edit.test.js && node test/open-viewer.test.js && node test/editor-client.test.js && node test/editor-client-runtime.test.js && node test/roundtrip.test.js && node test/byte-stability.test.js && node test/editor-server-throw.test.js && node test/editor-reader-rebind.test.js && node test/inline-md.test.js && node test/table-md.test.js && node test/gate-compat.test.js && node test/history.test.js && node test/list-md.test.js && node test/table-width.test.js"
   },
   "repository": {
     "type": "git",