@helping-ai-workflow/md2doc 3.17.5 → 3.17.6

package/lib/editor/inline-md.js

@@ -126,13 +126,19 @@
   // (verified round-trip-identical either way), so we always pad once a
   // fence is needed — simpler, and preserves the original single-backtick
   // test's exact padded form.
-  function serializeCode(node) {
+  //
+  // `opts.codePipe` (v3.17.6, table cells only): what a '|' in the code text
+  // is written as. table-md.js passes a placeholder here and turns it into
+  // `\|` after its own whole-cell '|' pass, which must not see it. The
+  // fence is measured on the real text; the placeholder holds no backtick.
+  function serializeCode(node, opts) {
     const raw = node.textContent;
     const runs = raw.match(/`+/g);
     const longestRun = runs ? Math.max.apply(null, runs.map((r) => r.length)) : 0;
-    if (longestRun === 0) return '`' + raw + '`';
+    const body = opts && opts.codePipe !== undefined ? raw.split('|').join(opts.codePipe) : raw;
+    if (longestRun === 0) return '`' + body + '`';
     const fence = new Array(longestRun + 2).join('`');
-    return fence + ' ' + raw + ' ' + fence;
+    return fence + ' ' + body + ' ' + fence;
   }
 
   // IMPORTANT 3 (degrade-never-lose): the citation form only round-trips
@@ -148,7 +154,7 @@
     return inner.indexOf(']') === -1;
   }
 
-  function serializeAnchor(node, unsupported) {
+  function serializeAnchor(node, unsupported, opts) {
     const href = node.getAttribute('href');
     // A raw HTML anchor (`<a id="ref-x"></a>`, NO href attribute) is not a
     // markdown link: emitting '[label]()' for it erased the anchor on the
@@ -167,7 +173,7 @@
       unsupported.push('A');
       return '';
     }
-    const label = walkChildren(node.childNodes, unsupported).md;
+    const label = walkChildren(node.childNodes, unsupported, opts).md;
     return '[' + label + '](' + (href || '') + ')';
   }
 
@@ -385,7 +391,7 @@
     if (typeof node.getAttribute !== 'function') return false;
     return (' ' + (node.getAttribute('class') || '') + ' ').indexOf(' search-hit ') !== -1;
   }
-  function walkChildren(nodes, unsupported) {
+  function walkChildren(nodes, unsupported, opts) {
     let out = '';
     let firstSegment = true;
     let lastMarkTag = null;
@@ -403,7 +409,7 @@
       if (name === 'DIV') {
         let added = '';
         if (!firstSegment) added += '<br>';
-        const inner = walkChildren(node.childNodes, unsupported);
+        const inner = walkChildren(node.childNodes, unsupported, opts);
         added += inner.md;
         out = appendPiece(out, added);
         if (added.length) lastMarkTag = inner.md.length ? inner.lastMarkTag : null;
@@ -413,7 +419,7 @@
       if (name === 'MARK' && markIsSearchHit(node)) {
         // v3.14.0 T9: the reader's search paints its hits as this element and
         // it is transient, so it serializes as what it wraps.
-        const inner = walkChildren(node.childNodes, unsupported);
+        const inner = walkChildren(node.childNodes, unsupported, opts);
         out = appendPiece(out, inner.md);
         if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         firstSegment = false;
@@ -423,7 +429,7 @@
         if (spanHasAttributes(node)) {
           unsupported.push(name);
         } else {
-          const inner = walkChildren(node.childNodes, unsupported);
+          const inner = walkChildren(node.childNodes, unsupported, opts);
           out = appendPiece(out, inner.md);
           if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         }
@@ -433,7 +439,7 @@
       if (name === 'STRONG' || name === 'B' || name === 'EM' || name === 'I') {
         const tag = (name === 'STRONG' || name === 'B') ? 'STRONG' : 'EM';
         const delim = tag === 'STRONG' ? '**' : '*';
-        const e = splitEdges(walkChildren(node.childNodes, unsupported).md);
+        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts).md);
         if (e.core) {
           // a hoisted leading space already separates two same-tag runs
           const guard = !e.lead && lastMarkTag === tag ? '<!-- -->' : '';
@@ -452,7 +458,7 @@
         // accepted on input (some contenteditable/paste paths produce it)
         // but the toolbar/serializer always speak DEL, matching what marked
         // itself emits.
-        const e = splitEdges(walkChildren(node.childNodes, unsupported).md);
+        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts).md);
         out = appendPiece(out, e.core ? e.lead + '~~' + e.core + '~~' + e.trail : e.lead + e.trail);
         if (e.core || e.lead || e.trail) lastMarkTag = null;
         firstSegment = false;
@@ -469,19 +475,19 @@
         // backtick, literal `<u>` typed as plain text is already escaped by
         // the `<` -> `&lt;` rule above, so it can never collide with a real
         // toolbar-made underline.
-        out = appendPiece(out, '<u>' + walkChildren(node.childNodes, unsupported).md + '</u>');
+        out = appendPiece(out, '<u>' + walkChildren(node.childNodes, unsupported, opts).md + '</u>');
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'CODE') {
-        out = appendPiece(out, serializeCode(node));
+        out = appendPiece(out, serializeCode(node, opts));
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'A') {
-        out = appendPiece(out, serializeAnchor(node, unsupported));
+        out = appendPiece(out, serializeAnchor(node, unsupported, opts));
         lastMarkTag = null;
         firstSegment = false;
         continue;
@@ -530,9 +536,11 @@
     return { md: out, lastMarkTag };
   }
 
-  function serializeInline(rootEl) {
+  // `opts` is optional; its one field, `codePipe`, is described at
+  // serializeCode(). Every caller but table-md.js passes nothing.
+  function serializeInline(rootEl, opts) {
     const unsupported = [];
-    const md = walkChildren(rootEl.childNodes, unsupported).md;
+    const md = walkChildren(rootEl.childNodes, unsupported, opts).md;
     return { md, unsupported };
   }
 

package/lib/editor/table-md.js

@@ -70,8 +70,8 @@
   // it has rows. No trailing whitespace on any emitted line (every row/
   // separator line is built as '|'-delimited fields, so it always ends in
   // '|', never in whitespace, by construction). A '|' inside a <code> span
-  // has no faithful gate-safe emission — see cellHasCodePipe() below —
-  // and reports 'CODE' unsupported instead of corrupting it.
+  // is written as '\|' instead (v3.17.6) — see codePipesOf() below; the one
+  // code text that has no table spelling reports 'CODE' unsupported.
   //
   // Constrained (same as inline-md.js, and for the same reason: the node
   // test drives this with the hand-rolled element stub from
@@ -123,32 +123,63 @@
     return s.replace(/\r\n|\r|\n/g, '<br>');
   }
 
-  // Finding 4: a '|' inside a <code> span has no faithful gate-safe
-  // emission — escapePipes() above runs on the WHOLE cell's serialized md
-  // and can't tell a code span's content from plain text, so naively
-  // applying it would corrupt the code span (turning `` `a|b` `` into the
-  // broken `` `a&#124;b` ``, which never decodes back inside a code span).
-  // `\|` (some other renderers' escape) is the gate's documented trap, so
-  // there's no safe escape at all here — degrade-never-lose: detect a CODE
-  // element anywhere in the cell whose textContent contains '|' and report
-  // it unsupported instead, same signal an IMG/SPAN/etc. already uses to
-  // degrade the whole table to raw-edit (see canWysiwygForTable() in
-  // client.js). Recurses through the cell's element children looking for
-  // CODE — constrained to childNodes/nodeType/nodeName like the rest of
-  // this file (no querySelector, per the node-test stub).
-  function cellHasCodePipe(node) {
+  // A '|' inside a <code> span (v3.17.6; Finding 4 of 2026-08-25 refused
+  // every one). escapePipes() above cannot be used on it: '&#124;' is never
+  // decoded inside a code span, so `` `a|b` `` would come back as `a&#124;b`.
+  // GFM's own spelling is '\|': the table tokenizer drops that backslash when
+  // it splits the row into cells, before the cell is parsed inline, so the
+  // code span shows a bare '|'. It is also what paperwork asks for. Its
+  // quality gate (G-MD-TABLE-PIPE,
+  // `scan_table_rows_for_unescaped_pipe_in_backtick` in scripts/gate/shared.py,
+  // 10.4.0) hard-FAILs an unescaped pipe inside a backtick span of a table
+  // row and gives '\|' as the fix. The paperwork-workspace-rtk design-docs
+  // are written that way, and those tables used to fall back to raw-edit.
+  //
+  // Correction, recorded because the old comment here said otherwise: it
+  // called '\|' "the gate's documented trap". Nothing in paperwork 10.4.0
+  // backs that. The only trap note about an escaped pipe there is a docstring
+  // in scripts/gate/hwe1.py (`_hwe1_requirement_units`): that helper splits
+  // hwe1 requirement rows with a plain split("|"), so it would cut such a
+  // cell in two, and the docstring itself says no gate reads that cell text
+  // today. It is a hazard for whoever extends that helper. It is not a rule
+  // against the form, and design-doc gates do not use that helper.
+  //
+  // One code text still has no spelling. marked's splitCells() treats a pipe
+  // as escaped when an ODD run of backslashes precedes it, then deletes one
+  // backslash. Code text with an even run before its '|' (none, two, …) is
+  // written with one more backslash and reads back exactly. With an odd run,
+  // that extra backslash makes the run even and the pipe becomes a cell
+  // boundary. That case reports 'CODE' unsupported, and the whole table falls
+  // back to raw-edit as before (canWysiwygForTable() in client.js).
+  //
+  // Returns { pipes, unwritable } over every CODE element in the cell. It
+  // recurses through elements that are not CODE and does not descend into
+  // CODE, because serializeCode() writes a CODE element's textContent whole.
+  // It sticks to childNodes/nodeType/nodeName like the rest of this file (no
+  // querySelector, per the node-test stub).
+  const ODD_BACKSLASH_PIPE = /(?:^|[^\\])(?:\\\\)*\\\|/;
+  function codePipesOf(node, acc) {
+    const out = acc || { pipes: 0, unwritable: false };
     const kids = elementChildren(node);
     for (let i = 0; i < kids.length; i++) {
       const k = kids[i];
       if (k.nodeName === 'CODE') {
-        if (k.textContent.indexOf('|') !== -1) return true;
-      } else if (cellHasCodePipe(k)) {
-        return true;
+        const t = k.textContent;
+        out.pipes += t.split('|').length - 1;
+        if (ODD_BACKSLASH_PIPE.test(t)) out.unwritable = true;
+      } else {
+        codePipesOf(k, out);
       }
     }
-    return false;
+    return out;
   }
 
+  // The placeholder serializeCode() writes for a code '|' while the cell's
+  // markdown goes through escapePipes(). A private-use character, so real
+  // text almost never holds it. If one does, the count check in
+  // cellContentOf() catches it and the cell degrades rather than guessing.
+  const CODE_PIPE_MARK = '\uE000';
+
   // ── 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
@@ -159,8 +190,8 @@
   // 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
+  // Source THIS serializer produced holds '\|' only inside code spans (plain
+  // text gets '&#124;'), and a hand-written table may use '\|' anywhere, so
   // the split must not break on an escaped delimiter.
   function splitFields(line) {
     const t = line.trim();
@@ -312,10 +343,12 @@
   // `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);
+    const code = codePipesOf(cell);
+    const res = inlineMd.serializeInline(cell, { codePipe: CODE_PIPE_MARK });
     res.unsupported.forEach((u) => unsupported.push(u));
-    return escapeNewlines(escapePipes(res.md));
+    const parts = escapeNewlines(escapePipes(res.md)).split(CODE_PIPE_MARK);
+    if (code.unwritable || parts.length - 1 !== code.pipes) unsupported.push('CODE');
+    return parts.join('\\|');
   }
 
   function serializeRow(contents, widths) {

package/package.json

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