@helping-ai-workflow/md2doc 3.17.5 → 3.17.7

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,14 @@
     return inner.indexOf(']') === -1;
   }
 
-  function serializeAnchor(node, unsupported) {
+  // The test serializeAnchor() uses to write `[[body]]` (v3.17.7: shared
+  // with serializeInline()'s read-back check).
+  function isCitationNode(node) {
+    const href = typeof node.getAttribute === 'function' ? node.getAttribute('href') : null;
+    const text = node.textContent;
+    return !!href && href.charAt(0) === '#' && /^\[.*\]$/.test(text) && isCitationEligible(node, text);
+  }
+  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 +180,7 @@
       unsupported.push('A');
       return '';
     }
-    const label = walkChildren(node.childNodes, unsupported).md;
+    const label = walkChildren(node.childNodes, unsupported, opts).md;
     return '[' + label + '](' + (href || '') + ')';
   }
 
@@ -385,10 +398,16 @@
     if (typeof node.getAttribute !== 'function') return false;
     return (' ' + (node.getAttribute('class') || '') + ' ').indexOf(' search-hit ') !== -1;
   }
-  function walkChildren(nodes, unsupported) {
+  // `ctx` (v3.17.7) says how a STRONG / EM nested inside another STRONG / EM
+  // is spelled; see serializeInline(). Absent means the plain `*` spelling.
+  // `touching` (v3.17.7) is the mark tag that ends right before these
+  // nodes, for a transparent wrapper whose first child may need the
+  // same-tag guard against it.
+  function walkChildren(nodes, unsupported, opts, ctx, touching) {
+    const c = ctx || PLAIN;
     let out = '';
     let firstSegment = true;
-    let lastMarkTag = null;
+    let lastMarkTag = touching || null;
     for (let i = 0; i < nodes.length; i++) {
       const node = nodes[i];
       if (node.nodeType === 3) {
@@ -403,7 +422,7 @@
       if (name === 'DIV') {
         let added = '';
         if (!firstSegment) added += '<br>';
-        const inner = walkChildren(node.childNodes, unsupported);
+        const inner = walkChildren(node.childNodes, unsupported, opts, c);
         added += inner.md;
         out = appendPiece(out, added);
         if (added.length) lastMarkTag = inner.md.length ? inner.lastMarkTag : null;
@@ -413,7 +432,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, c, lastMarkTag);
         out = appendPiece(out, inner.md);
         if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         firstSegment = false;
@@ -423,7 +442,7 @@
         if (spanHasAttributes(node)) {
           unsupported.push(name);
         } else {
-          const inner = walkChildren(node.childNodes, unsupported);
+          const inner = walkChildren(node.childNodes, unsupported, opts, c, lastMarkTag);
           out = appendPiece(out, inner.md);
           if (inner.md.length) lastMarkTag = inner.lastMarkTag;
         }
@@ -432,12 +451,12 @@
       }
       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, c.inner).md);
         if (e.core) {
           // a hoisted leading space already separates two same-tag runs
           const guard = !e.lead && lastMarkTag === tag ? '<!-- -->' : '';
-          out = appendPiece(out, e.lead + guard + delim + e.core + delim + e.trail);
+          const delim = c.delims[tag];
+          out = appendPiece(out, e.lead + guard + c.before + delim + e.core + delim + c.after + e.trail);
           lastMarkTag = e.trail ? null : tag;
         } else if (e.lead || e.trail) {
           out = appendPiece(out, e.lead + e.trail);
@@ -452,9 +471,15 @@
         // 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);
-        out = appendPiece(out, e.core ? e.lead + '~~' + e.core + '~~' + e.trail : e.lead + e.trail);
-        if (e.core || e.lead || e.trail) lastMarkTag = null;
+        //
+        // v3.17.7 N2: two strikethroughs side by side get the same guard as
+        // two bolds. `~~a~~~~b~~` reads as ONE del holding `a~~~~b` (measured
+        // on 71fedaa: strike `two` right after `~~one~~` wrote exactly that).
+        const e = splitEdges(walkChildren(node.childNodes, unsupported, opts, c).md);
+        const guard = e.core && !e.lead && lastMarkTag === 'DEL' ? '<!-- -->' : '';
+        out = appendPiece(out, e.core ? e.lead + guard + '~~' + e.core + '~~' + e.trail : e.lead + e.trail);
+        if (e.core) lastMarkTag = e.trail ? null : 'DEL';
+        else if (e.lead || e.trail) lastMarkTag = null;
         firstSegment = false;
         continue;
       }
@@ -469,19 +494,23 @@
         // 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, c).md + '</u>');
         lastMarkTag = null;
         firstSegment = false;
         continue;
       }
       if (name === 'CODE') {
-        out = appendPiece(out, serializeCode(node));
-        lastMarkTag = null;
+        // v3.17.7 N3: two code spans side by side are one span to a reader
+        // (`` `one``two` `` is the code "one``two"), so they get a guard too.
+        // serializeCode() never writes an empty span, so this always fires
+        // between two real ones.
+        out = appendPiece(out, (lastMarkTag === 'CODE' ? '<!-- -->' : '') + serializeCode(node, opts));
+        lastMarkTag = 'CODE';
         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,11 +559,227 @@
     return { md: out, lastMarkTag };
   }
 
-  function serializeInline(rootEl) {
+  // ── v3.17.7 N1: check the bytes with the reader's own parser ─────────────
+  //
+  // A STRONG / EM nested inside another STRONG / EM is written `*` / `**`
+  // like any other, and most of the time marked reads that back. Not always:
+  // marked's emphasis scan (emStrong in marked 14) walks from an opening run
+  // to its closer counting the `*` runs in between, and a run with word
+  // characters on both sides is a "mid" run it may skip under the rule of 3.
+  // Whether a nested mark survives therefore depends on the characters
+  // around its runs. Measured on 71fedaa, each from a toolbar gesture:
+  //   `*`c`**i**tal*`                -> the em is lost, its stars show
+  //   `*~~a**a**~~*`                 -> `~~` is invisible to that scan
+  //   `前面「引號<!-- -->*」**粗**後面，中文*。`
+  // while `*a**i**tal*` and `***ital* bold**` read fine. The rules are
+  // marked's, so marked decides: serializeInline() writes the bytes as
+  // before, parses them, and compares the marks on every character with the
+  // DOM it was given. Only when they differ does it try other spellings for
+  // the nested marks, in this order, keeping the first that reads back:
+  //   1. `__` / `_` for every STRONG / EM inside another (those runs are
+  //      not `*`, so the outer scan does not count them);
+  //   2. the same with `<!-- -->` on both sides of each such mark (a run
+  //      next to `<` is no longer flanked by a word character), then each of
+  //      those guards dropped again if the bytes still read back without it.
+  // If neither reads back the original bytes are kept: what this release
+  // wrote before. Bytes that already read back are never touched, so no
+  // file written by an earlier release changes by being opened and saved.
+  // A fuzz over random strong / em / del / code trees (inline-md.test.js;
+  // 7725 of 20000 read back wrong on 71fedaa) needed nothing beyond step 2.
+  //
+  // A repaired spelling never keeps `<!--` at the start of a line: marked
+  // reads a line-start `<!--` as an HTML block and ends the paragraph there
+  // (v3.17.5 C1), and parseInline() cannot see that. It does not have to:
+  // the only guards step 2 adds sit before an opening run or after a
+  // closing one, and after a newline the character before an opening run
+  // is whitespace, which already does what the guard's `>` does (no
+  // right-flanking, opening allowed). So a step-2 guard at a line start is
+  // dropped before anything is parsed, whether or not the drop pass below
+  // runs (re-review: with the pass skipped past 16 guards, one survived
+  // after a hard break and the reader cut the paragraph there). The walk
+  // itself never writes one (needsFlankSeparator() sees `\n` as a non-word
+  // character).
+  //
+  // The parser is a private `new Marked()` with gfm on and nothing else, in
+  // node and in the editor page alike (server.js injects marked's UMD build
+  // before this file). The reader's own instance carries the md2doc
+  // renderer, whose text hook writes into the render's search index, and
+  // its sub / sup / KaTeX extensions only see `~` / `^` / `$`, which this
+  // comparison is not about. No parser (a page without marked) means no
+  // check: the bytes are written as before.
+  const GUARD = '<!-- -->';
+  const STAR = { STRONG: '**', EM: '*' };
+  const UNDERSCORE = { STRONG: '__', EM: '_' };
+  // PLAIN.inner is PLAIN: the spelling every release before this one used.
+  const PLAIN = { delims: STAR, before: '', after: '', inner: null };
+  PLAIN.inner = PLAIN;
+  function spelling(before) {
+    const nested = { delims: UNDERSCORE, before, after: before, inner: null };
+    nested.inner = nested;
+    return { delims: STAR, before: '', after: '', inner: nested };
+  }
+  const NESTED_UNDERSCORE = spelling('');
+  // One character stands in for each step-2 guard until it is decided, so
+  // only those guards are ever dropped, never one the walk wrote itself. It
+  // must be punctuation to needsFlankSeparator(), as the `<` it stands for
+  // is: with a word-like stand-in the walk skips a guard the real bytes need
+  // (measured: `ital**<!-- -->_…` lost the `<!-- -->` before its `**`).
+  // U+2E3B THREE-EM DASH (\p{Pd}); a block whose text holds one skips step 2.
+  const PENDING = '\u2E3B';
+  const NESTED_GUARDED = spelling(PENDING);
+
+  let inlineParser; // undefined: not looked up yet; null: none available
+  function getInlineParser() {
+    if (inlineParser !== undefined) return inlineParser;
+    inlineParser = null;
+    try {
+      let lib = null;
+      if (typeof module === 'object' && module.exports && typeof require === 'function') lib = require('marked');
+      else if (typeof self !== 'undefined' && self.marked) lib = self.marked;
+      if (lib && typeof lib.Marked === 'function') {
+        const m = new lib.Marked({ gfm: true, breaks: false });
+        inlineParser = (s) => m.parseInline(s);
+      }
+    } catch (e) {
+      inlineParser = null;
+    }
+    return inlineParser;
+  }
+  // Tests swap the parser: a function, null to switch the check off, or
+  // nothing to go back to the lookup above.
+  function setInlineParser(fn) {
+    inlineParser = typeof fn === 'function' ? fn : (fn === null ? null : undefined);
+  }
+
+  // One entry per non-space character: the character and the sorted set of
+  // S(trong) / E(m) / D(el) around it. A code span is one entry holding its
+  // text without whitespace (a reader strips one space at each end, and
+  // spacing is not what this check is about). Whitespace is left out
+  // (splitEdges() moves it across a delimiter on purpose), and so are line
+  // breaks, link targets and <u>. A citation is written `[[body]]`, which
+  // this private parser (no md2doc extension) reads as that literal text,
+  // so its DOM side counts the outer brackets too: without them the two
+  // sides never agreed and any block holding a citation was never repaired
+  // (final review).
+  const MARK_LETTER = { STRONG: 'S', B: 'S', EM: 'E', I: 'E', DEL: 'D', S: 'D' };
+  const SPACE = /\s/;
+  function domMarks(nodes, marks, out) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.nodeType === 3) {
+        for (const ch of node.textContent) if (!SPACE.test(ch)) out.push(ch + '[' + marks + ']');
+        continue;
+      }
+      if (node.nodeType !== 1) continue;
+      if (node.nodeName === 'CODE') { out.push('`' + node.textContent.replace(/\s+/g, '') + '[' + marks + ']'); continue; }
+      if (node.nodeName === 'A' && isCitationNode(node)) {
+        for (const ch of '[' + node.textContent + ']') if (!SPACE.test(ch)) out.push(ch + '[' + marks + ']');
+        continue;
+      }
+      const k = MARK_LETTER[node.nodeName];
+      const inner = k && marks.indexOf(k) === -1 ? (marks + k).split('').sort().join('') : marks;
+      domMarks(node.childNodes, inner, out);
+    }
+    return out;
+  }
+  const HTML_TAG_MARK = { strong: 'S', em: 'E', del: 'D' };
+  const HTML_ENTITY = { amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" };
+  function htmlMarks(html) {
+    const out = [];
+    const open = [];
+    let code = null;
+    const re = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][a-zA-Z0-9]*)\b[^>]*>|&(amp|lt|gt|quot|#39);|([^<&]+|[<&])/g;
+    const current = () => open.slice().sort().filter((k, i, a) => a.indexOf(k) === i).join('');
+    let m;
+    while ((m = re.exec(html))) {
+      if (m[0].startsWith('<!--')) continue;
+      if (m[2]) {
+        const tag = m[2].toLowerCase();
+        if (tag === 'code') {
+          if (m[1]) { out.push('`' + (code || '').replace(/\s+/g, '') + '[' + current() + ']'); code = null; } else code = '';
+          continue;
+        }
+        const k = HTML_TAG_MARK[tag];
+        if (!k) continue;
+        if (m[1]) { const at = open.lastIndexOf(k); if (at !== -1) open.splice(at, 1); } else open.push(k);
+        continue;
+      }
+      const t = m[3] ? HTML_ENTITY[m[3]] : m[4];
+      if (code !== null) { code += t; continue; }
+      for (const ch of t) if (!SPACE.test(ch)) out.push(ch + '[' + current() + ']');
+    }
+    return out;
+  }
+
+  // `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;
+    // The spellings below only differ where a STRONG / EM sits inside another
+    // one, so a block without that is written as walked, unparsed: no cost
+    // on the per-keystroke shortcut check or for callers that only want
+    // `unsupported`.
+    if (unsupported.length || !hasNestedStar(rootEl.childNodes, false)) return { md, unsupported };
+    const parse = getInlineParser();
+    if (!parse) return { md, unsupported };
+    const want = domMarks(rootEl.childNodes, '', []).join('|');
+    // table-md.js writes a code `|` as its placeholder; the cell shows `|`
+    // (GFM drops the `\` of `\|` before the cell is parsed inline).
+    const pipe = opts && opts.codePipe;
+    const readsBack = (s) => {
+      try {
+        return htmlMarks(parse(pipe ? s.split(pipe).join('|') : s)).join('|') === want;
+      } catch (e) {
+        return false;
+      }
+    };
+    if (readsBack(md)) return { md, unsupported };
+    const one = walkChildren(rootEl.childNodes, [], opts, NESTED_UNDERSCORE).md;
+    if (readsBack(one)) return { md: one, unsupported };
+    if (domText(rootEl.childNodes).indexOf(PENDING) === -1) {
+      const parts = walkChildren(rootEl.childNodes, [], opts, NESTED_GUARDED).md.split(PENDING);
+      // guard k sits right after parts[k]; none is kept at a line start
+      let before = '';
+      const keep = parts.slice(1).map((_, k) => {
+        before += parts[k];
+        return !/(^|\n)[ \t]*$/.test(before);
+      });
+      const build = () => parts.reduce((acc, part, i) =>
+        (i ? acc + (keep[i - 1] ? GUARD : '') : '') + part, '');
+      if (readsBack(build())) {
+        // Each drop is one more parse of the whole block. Past a handful of
+        // guards keep them all: correct bytes, a few extra `<!-- -->`
+        // (final review measured 400 repaired marks at 3.4 s otherwise).
+        for (let i = 0; i < keep.length && keep.length <= MAX_GUARDS_TO_DROP; i++) {
+          if (!keep[i]) continue;
+          keep[i] = false;
+          if (!readsBack(build())) keep[i] = true;
+        }
+        return { md: build(), unsupported };
+      }
+    }
     return { md, unsupported };
   }
+  const MAX_GUARDS_TO_DROP = 16;
+  const STAR_TAGS = { STRONG: 1, B: 1, EM: 1, I: 1 };
+  // Whether a STRONG / EM sits inside another one, through any wrapper the
+  // walk spells with the context it was given (not CODE, not a link label).
+  function hasNestedStar(nodes, inStar) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.nodeType !== 1 || node.nodeName === 'CODE' || node.nodeName === 'A') continue;
+      const star = STAR_TAGS[node.nodeName] === 1;
+      if (star && inStar) return true;
+      if (hasNestedStar(node.childNodes, inStar || star)) return true;
+    }
+    return false;
+  }
+  function domText(nodes) {
+    let s = '';
+    for (let i = 0; i < nodes.length; i++) s += nodes[i].textContent || '';
+    return s;
+  }
 
   function canWysiwyg(rootEl) {
     return serializeInline(rootEl).unsupported.length === 0;
@@ -698,5 +943,5 @@
     return out;
   }
 
-  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder };
+  return { serializeInline, canWysiwyg, escapeText, escapeBlockStarts, normalizeHref, isPastedUrl, parseImageParagraph, rewriteImage, setNamedReferenceDecoder, setInlineParser };
 });

package/lib/editor/paste-md.js

@@ -215,8 +215,47 @@ function isHeadingRow(tr) {
 // against the header. Escape any `|` that isn't already an escaped `\|`
 // (the latter can arrive when a nested table's own already-escaped cell
 // content is flattened into its parent cell, see cellMarkdown below).
+//
+// v3.17.7 F2: "already escaped" means an ODD run of backslashes before the
+// `|`, which is how marked's splitCells() decides it (the parity rule
+// v3.17.6 wrote down in table-md.js). The old test was one backslash, any
+// run: text `a \| b` (turndown writes its backslash as `\\`) came out
+// `a \\| b`, an even run, and the cell was cut in two (measured on 71fedaa).
 function escapePipes(s) {
-  return String(s).replace(/(?<!\\)\|/g, '\\|');
+  return String(s).replace(/(\\*)\|/g, function (m, run) {
+    return run.length % 2 ? m : run + '\\|';
+  });
+}
+
+// v3.17.7 F2: code whose text has an odd backslash run before a `|` has no
+// spelling in a GFM table cell. The backslash that keeps the pipe in the
+// cell is the one GFM deletes before the code span is read, so the code
+// shows one backslash fewer (or, with one backslash more, the run turns even
+// and the pipe ends the cell); table-md.js refuses the same code (v3.17.6).
+// Paste cannot refuse, so such a span is written as text with EVERY ASCII
+// punctuation character backslash-escaped (CommonMark allows that for all
+// of them): then nothing in it is read as markup -- not `<!--`, not an
+// entity, not md2doc's `^sup^` / `~sub~` / `$math$`. turndown's own
+// escape() leaves those alone (final review: `a<!-- \| -->` lost its text,
+// `^2^` became superscript). The `|` comes out `\|`, an odd run, which
+// escapePipes() then leaves as it is. Every character arrives; only the
+// code style does not.
+var ODD_BACKSLASH_PIPE = /(?:^|[^\\])(?:\\\\)*\\\|/;
+function addUnspellableCellCodeRule(service) {
+  service.addRule('unspellableCellCode', {
+    filter: function (node) {
+      if (node.nodeName !== 'CODE') return false;
+      if (node.parentNode && node.parentNode.nodeName === 'PRE') return false;
+      if (!ODD_BACKSLASH_PIPE.test(node.textContent || '')) return false;
+      for (var p = node.parentNode; p; p = p.parentNode) {
+        if (p.nodeName === 'TD' || p.nodeName === 'TH') return true;
+      }
+      return false;
+    },
+    replacement: function (content, node) {
+      return (node.textContent || '').replace(/[!-\/:-@\[-`{-~]/g, '\\$&');
+    }
+  });
 }
 
 // Only the ROWS THIS TABLE OWNS -- direct <tr> children, and <tr> children
@@ -345,6 +384,7 @@ function htmlToMarkdown(html) {
   addStrikethroughRule(service);
   addFlankingEmphasisRules(service);
   addTableRules(service);
+  addUnspellableCellCodeRule(service);
   return service.turndown(html == null ? '' : String(html));
 }
 

package/lib/editor/server.js

@@ -8,6 +8,12 @@ const { renderMarkdown, buildKatexStyleTag, diagramEnginePaths } = require('../m
 const { createDotPreview } = require('./dot-preview.js');
 
 const LINEOPS_SRC = fs.readFileSync(path.join(__dirname, 'lineops.js'), 'utf8');
+// v3.17.7: marked's browser build (the package's exported `marked.min.js`,
+// UMD, defines the global `marked`), so inline-md.js can parse the bytes it
+// is about to save and check that the reader shows the marks the editor held
+// (serializeInline()). Injected before inline-md.js; inline-md.js looks the
+// global up at its first serialize, so the order is for reading, not load.
+const MARKED_SRC = fs.readFileSync(require.resolve('marked/marked.min.js'), 'utf8');
 const INLINE_MD_SRC = fs.readFileSync(path.join(__dirname, 'inline-md.js'), 'utf8');
 const TABLE_MD_SRC = fs.readFileSync(path.join(__dirname, 'table-md.js'), 'utf8');
 // Task 4 (Phase 3): list-md.js's browser factory reads `root.md2docInlineMd`
@@ -776,6 +782,7 @@ async function createEditorServer({
         const inject =
           `<script>window.__ED__ = ${payload.replace(/</g, '\\u003c')}</script>\n` +
           `<script>${LINEOPS_SRC}</script>\n` +
+          `<script>${MARKED_SRC}</script>\n` +
           `<script>${INLINE_MD_SRC}</script>\n` +
           `<script>${TABLE_MD_SRC}</script>\n` +
           `<script>${LIST_MD_SRC}</script>\n` +

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.7",
   "description": "Markdown → HTML / PDF renderer with WaveDrom, Mermaid, Graphviz, and draw.io support",
   "keywords": [
     "markdown",