@helping-ai-workflow/md2doc 3.0.1 → 3.0.2

package/lib/editor/client.js

@@ -1667,6 +1667,57 @@
   // function did by returning early.
   function computeIndentClamp(spanEls, opBlockEl, opOldIndent, opts) {
     if (!indentClamp || !spanEls || !spanEls.length) return null;
+    // v3.0.2 — the structural answer to the stale-`run` pattern that v3.0.1
+    // point-fixed at three call sites, and that both reviewers asked to have
+    // fixed at the call convention instead. There are FIVE call sites, not
+    // three (3483 batch delete, 3812 convert, 5778 batch Tab/Shift+Tab, 6028
+    // caret Tab/Shift+Tab — both indent directions share ONE call site each,
+    // batch vs. caret, not one call site per direction — and the drop's
+    // compute at 8516), and every one of them hands over a `listRunOf()`
+    // result in document order. Two ways that goes stale, both of which
+    // produced a confident wrong number rather than a refusal: a member
+    // DETACHED (getAttribute still answers on a detached node) and a span
+    // still attached but no longer in the run's document order (indexOf()
+    // then reports an opIndex for a layout that no longer exists, so §3.4
+    // rule 2's scope starts in the wrong place). Re-deriving the span here
+    // instead of checking it was rejected: it would quietly change the
+    // contract from "clamp this span" to "clamp the run containing this
+    // op", and the drop is the one caller subtle enough that taking that
+    // expressiveness away is not free.
+    //
+    // It does NOT throw. This file's defensive style (safeRerenderAll at
+    // ~990) is that the editor must not die on one path's failure. But the
+    // refusal is NOT free either: at the drop (8516) a null clamp feeds
+    // spanIndentsAreAnchored() the RAW reordered indents, and that refuses
+    // 1425 of 4067 legal drops where the clamped answer refuses only 14 (the
+    // clamp rescues the other 1411; the measured numbers are recorded at
+    // line ~371). So a false positive here costs the user up to 1411 legal
+    // batch drags, replaced by a banner —
+    // which is why the assert is worth this cost even though the batch-
+    // delete, convert and drop sites each have a scenario whose correct
+    // answer needs a real reclamp (a wrongly-firing assert breaks them
+    // visibly), while neither Tab call site (5778 batch, 6028 caret) has a
+    // scenario that reclamps a TRAILING sibling — see
+    // test/editor-client-runtime.test.js for the per-site detail.
+    const fresh = listRunOf(spanEls[0]);
+    if (fresh.length !== spanEls.length ||
+        fresh.some((el, i) => el !== spanEls[i])) {
+      // Minor 5: the length pair alone is silent on the reordered-but-same-
+      // length case (the ONLY case where an index is diagnostic — a length
+      // mismatch is already self-explanatory), so report the first index at
+      // which the two runs disagree too.
+      const minLen = Math.min(fresh.length, spanEls.length);
+      let badIndex = -1;
+      for (let i = 0; i < minLen; i++) {
+        if (fresh[i] !== spanEls[i]) { badIndex = i; break; }
+      }
+      if (badIndex < 0 && fresh.length !== spanEls.length) badIndex = minLen;
+      console.error('computeIndentClamp: stale span — the run has ' + fresh.length +
+        ' members, the caller passed ' + spanEls.length +
+        ', first differing at index ' + badIndex +
+        '; refusing rather than clamping against a layout that no longer exists');
+      return null;
+    }
     const opEls = Array.isArray(opBlockEl) ? opBlockEl : [opBlockEl];
     const opIndex = [];
     for (let k = 0; k < opEls.length; k++) {
@@ -4491,6 +4542,15 @@
   window.__edTestForceRerender = function () { return rerenderAll(); };
   window.__edTestTruncateTo = function (n) { lines = lines.slice(0, n); };
 
+  // v3.0.2: computeIndentClamp() lives past this file's node early-exit
+  // (module.exports at line ~509 ships the pure core only) and nothing on
+  // window reaches it, so the stale-span assert added to it in v3.0.2 had
+  // no way to be tested at all. This is the seventh __edTest seam and the
+  // only production surface that change adds.
+  window.__edTestClampProbe = function (spanEls, opBlockEl, opOldIndent, opts) {
+    return computeIndentClamp(spanEls, opBlockEl, opOldIndent, opts);
+  };
+
   // ── S3 Task 4: the entry and exit GESTURES ─────────────────────────────
   // §4.4 entries: (a) press inside a block and drag across its boundary;
   // (b) Shift+Click; (c) Shift+↑↓. Exits: Escape (Task 3's keydown prologue)
@@ -7139,6 +7199,40 @@
   let gripColTableEl = null;
   let gripColIndex = null;
 
+  // v3.0.2 — the gutter keep-alive for the table row grip. Held in its own
+  // module-level reference, NOT read back off `gripRowTableEl`, because
+  // hideTableGrips() below nulls that at its own line 7246-7248: a teardown
+  // that went looking for the block through it would find null exactly when
+  // it needs to clear the class, and rerenderAll()'s hideTableGrips() call
+  // reaches it with the table already detached.
+  let gutterKeepEl = null;
+
+  function setGutterKeep(blockEl) {
+    const next = blockEl || null;
+    if (gutterKeepEl === next) return;
+    if (gutterKeepEl) gutterKeepEl.classList.remove('ed-keep-lit');
+    gutterKeepEl = next;
+    if (gutterKeepEl) gutterKeepEl.classList.add('ed-keep-lit');
+  }
+
+  function clearGutterKeep() { setGutterKeep(null); }
+
+  // The block whose gutter the CURRENTLY SHOWN row grip is covering, or null
+  // when there is nothing to keep lit. Two conditions, both load-bearing:
+  //
+  //   • gripRowTableEl / gripRowEl may be null while a grip is nonetheless
+  //     visible — a header-only table takes the else branch at 7466-7470 and
+  //     nulls both, then the column grip is shown unconditionally just
+  //     below. Both callers of this function are reached in that state.
+  //   • only the HEADER row's grip shares a Y with the ⠿. Keeping the
+  //     gutter lit for a body row's grip would light the ⠿ in a place the
+  //     defect never occurred — a behaviour change beyond the fix.
+  function headerGripBlock() {
+    if (!gripRowTableEl || !gripRowEl) return null;
+    if (gripRowEl !== headerRowOf(gripRowTableEl)) return null;
+    return gripRowTableEl.closest('.ed-block');
+  }
+
   function hideTableGrips() {
     rowGrip.hidden = true;
     colGrip.hidden = true;
@@ -7153,6 +7247,7 @@
     gripRowEl = null;
     gripColTableEl = null;
     gripColIndex = null;
+    clearGutterKeep();
   }
 
   // Bug fix (user acceptance) — history: grips were originally BOTH
@@ -7298,7 +7393,15 @@
     // whatever was last shown untouched instead; hideTableGrips() (called
     // from table-leave, burst-end, and drag-start elsewhere) already covers
     // every path that actually needs to clear it.
-    if (target && target.closest && (target.closest('.ed-te-grip-row') || target.closest('.ed-te-grip-col'))) return;
+    if (target && target.closest && (target.closest('.ed-te-grip-row') || target.closest('.ed-te-grip-col'))) {
+      // v3.0.2: only the ROW grip is the one that covers the ⠿'s approach.
+      // Testing the hit rather than reusing the branch condition matters —
+      // the column grip sits above the table's top border, nowhere near the
+      // ⠿, and lighting the gutter from there is the behaviour change this
+      // fix is scoped to avoid.
+      setGutterKeep(target.closest('.ed-te-grip-row') ? headerGripBlock() : null);
+      return;
+    }
     const blockEl = target && target.closest && target.closest('.ed-block[data-block-type="table"]');
     const tableEl = blockEl ? blockContentEl(blockEl) : null;
     const cellEl = (tableEl && target && target.closest) ? target.closest('th, td') : null;
@@ -7311,10 +7414,15 @@
       // comment for why not the whole table). Keep that grip up while still
       // in its zone; only actually hide once the pointer has left both
       // zones entirely.
-      if (pointInRowGripZone(x, y) || pointInColGripZone(x, y)) return;
+      const inRowZone = pointInRowGripZone(x, y);
+      if (inRowZone || pointInColGripZone(x, y)) {
+        setGutterKeep(inRowZone ? headerGripBlock() : null);
+        return;
+      }
       hideTableGrips();
       return;
     }
+    clearGutterKeep();
 
     const tableRect = tableEl.getBoundingClientRect();
     const rowEl = cellEl.parentElement;

package/lib/editor/table-md.js

@@ -365,19 +365,18 @@
     // 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.
+    // all-or-nothing gate below, gets that right).
+    //
+    // v3.0.2 superseded the 2026-09-02 review round-1 ruling that a renamed
+    // header or a deleted column must discard the whole table's width memory:
+    // the forward scan below skips an original column that no longer appears,
+    // and only a genuine column REORDER still takes the whole-table refusal.
+    // What is still NOT handled — deliberately — is a table with DUPLICATE
+    // header names: the scan pairs by TEXT, so after a delete a survivor can
+    // inherit the same-named other column's width. Telling the instances
+    // apart needs identity matching, which is a larger change than this
+    // patch release carries. See test/table-width.test.js cases 14, 15, 20,
+    // 21, 23 and 24, which pin every branch of the above.
     const original = columnWidthsOf(originalMd);
     let widths = null;
     // Set for a column that falls off the END of the original header list
@@ -415,31 +414,51 @@
     const matchedSepFields = new Array(headerContents.length);
     if (original) {
       const matched = new Array(headerContents.length);
+      // v3.0.2: a FORWARD SCAN, not the pre-v3.0.2 lockstep compare. The
+      // lockstep version left `j` parked on the first original column that
+      // did not match, so it could never recover from one mismatch — and
+      // "some original column was never consumed" is the signature of a
+      // DELETE and a RENAME just as much as of the column REORDER the gate
+      // below actually exists to refuse. Scanning forward lets a delete or
+      // a rename skip the original it no longer has, and moves the refusal
+      // into an explicit test (`moved`) instead of a side effect of `j`.
+      const unmatchedNames = [];
       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++;
+        const name = headerContents[i].trim();
+        let k = -1;
+        for (let q = j; q < original.headerFields.length; q++) {
+          if (original.headerFields[q].trim() === name) { k = q; break; }
+        }
+        if (k >= 0) {
+          matched[i] = original.widths[k];
+          matchedSepFields[i] = original.sepFields[k];
+          j = k + 1;
         } else {
           matched[i] = undefined;
+          // The EMPTY name is exempt from the reorder test below, and the
+          // exemption is load-bearing, not defensive: insertColumn()
+          // (lib/editor/client.js:6448-6465) creates a th (or td) with no
+          // content at all — the element itself at line 6451 — so every
+          // inserted column is named ''. A table that
+          // already holds one blank header would therefore see the new
+          // column's '' "found elsewhere in the original" and take the
+          // whole-table refusal — a straight regression against v3.0.1 on
+          // the ordinary insert-a-column-twice flow.
+          if (name !== '') unmatchedNames.push(name);
           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) {
+      // A column that could not find itself in what remains of the original,
+      // yet whose name IS somewhere in the original, has MOVED relative to
+      // the others. That is the one shape a per-column width guess gets
+      // silently wrong ("a column move must carry its alignment with it"),
+      // so it still discards the width source for the WHOLE table. A name
+      // that is absent from the original entirely is an insert or a rename:
+      // nothing stale to carry, so its neighbours keep their widths.
+      const moved = unmatchedNames.some((n) =>
+        original.headerFields.some((f) => f.trim() === n));
+      if (!moved) {
         widths = matched;
         // A matched column is then widened, for every row of that column
         // at once (header + separator + every body row), to whatever the
@@ -485,9 +504,22 @@
       //      (`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.
+      //      renamed header, or a row-drag promotion). Since v3.0.2 the
+      //      gate above no longer discards `widths` for a rename, so this
+      //      branch is now the live path for a renamed column: its header
+      //      and body rows take padField()'s `|| 0` natural width and its
+      //      separator takes the bare 3-dash minimal. A row-drag promotion
+      //      ONLY leaves every column unmatched — and so only produces the
+      //      same all-undefined `widths`, byte-for-byte the `null` output,
+      //      because every preference above falls through to this 0 — when
+      //      none of the promoted row's cells collides with an ORIGINAL
+      //      header name. A collision re-enters the by-text match above (the
+      //      `k >= 0` branch), so that column inherits the OLD column's
+      //      width and the row emits half-aligned rather than fully minimal
+      //      (measured: promoting a 'Note' / 'zzz' row past an original
+      //      'Name | Note' header keeps column 0 at the original Note
+      //      column's width while column 1 falls to 3-dash minimal). The two
+      //      promotion scenarios this suite covers are both collision-free.
       const origField = matchedSepFields[i];
       const w = widths
         ? (widths[i] !== undefined ? widths[i]

package/lib/md2doc.js

@@ -2185,6 +2185,17 @@ ${itemsHtml}
   }
   .ed-block:hover .ed-handle,
   .ed-handle:focus { opacity: 1; }
+  /* v3.0.2: a table's row grip is a document.body child at z-index 7 that
+     straddles the table's left border, and a table block's ⠿ sits at the
+     header row's own Y — so a pointer travelling left toward the ⠿ crosses
+     the grip, elementFromPoint stops returning the block, and :hover above
+     goes false mid-approach. The grip cannot move (it must be a body child
+     to stay put while the table scrolls), so lib/editor/client.js holds the
+     gutter lit with this class for the duration instead. It does NOT
+     restore :hover, so .ed-block:hover's own outline still blinks there —
+     a recorded, unfixed residue. */
+  .ed-block.ed-keep-lit .ed-handle,
+  .ed-block.ed-keep-lit .ed-insert { opacity: 1; }
   .ed-handle:hover { background: rgba(0, 0, 0, 0.08); }
   /* The ⠿ handle's menu: 轉換成 › / 建立副本 / 刪除 / MD 原始碼 (spec §3.7),
      each led by a 16px currentColor icon (v2.12.0; drawn in

package/package.json

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