@helping-ai-workflow/md2doc 2.8.0 → 2.10.0

package/lib/editor/history.js

@@ -0,0 +1,94 @@
+'use strict';
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.md2docHistory = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+
+  function createBurstHistory(captureFn, options = {}) {
+    const debounceMs = options?.debounceMs ?? 400;
+    const getNow = options?.now ?? (() => Date.now());
+
+    let stack = [];
+    let redoTail = [];
+    let lastNoteTime = null;
+    let isPendingSnap = false;
+
+    return {
+      start() {
+        // captureFn exceptions intentionally bubble to caller
+        stack = [captureFn()];
+        redoTail = [];
+        lastNoteTime = null;
+        isPendingSnap = false;
+      },
+
+      snap(reason) {
+        // reason is currently unused metadata (for future per-reason hooks)
+        // captureFn exceptions intentionally bubble to caller
+        const current = captureFn();
+        const top = stack[stack.length - 1];
+
+        if (current !== top) {
+          stack.push(current);
+          redoTail = [];
+        }
+
+        isPendingSnap = false;
+      },
+
+      noteTyping() {
+        const nowTime = getNow();
+
+        if (isPendingSnap && lastNoteTime !== null && nowTime - lastNoteTime >= debounceMs) {
+          // Debounce interval has elapsed, snap the pending capture
+          this.snap('typing');
+        }
+
+        // Mark/update pending snapshot
+        isPendingSnap = true;
+        lastNoteTime = nowTime;
+      },
+
+      flushTyping() {
+        if (isPendingSnap) {
+          this.snap('typing');
+        }
+      },
+
+      undo() {
+        // First flush any pending typing debounce
+        this.flushTyping();
+
+        // Then step back
+        if (stack.length <= 1) return null;
+
+        redoTail.push(stack.pop());
+        return stack[stack.length - 1];
+      },
+
+      redo() {
+        if (redoTail.length === 0) return null;
+
+        stack.push(redoTail.pop());
+        return stack[stack.length - 1];
+      },
+
+      atBottom() {
+        return stack.length === 1;
+      },
+
+      size() {
+        return stack.length;
+      },
+
+      dispose() {
+        stack = [];
+        redoTail = [];
+        isPendingSnap = false;
+        lastNoteTime = null;
+      }
+    };
+  }
+
+  return { createBurstHistory };
+});

package/lib/editor/inline-md.js

@@ -0,0 +1,220 @@
+'use strict';
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.md2docInlineMd = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+
+  // Escaping rules (verbatim from task-2 brief, plus review fix 2026-08-25,
+  // plus the strikethrough/underline fix below):
+  //  - backslash / backtick / asterisk / brackets escaped always
+  //  - underscore escaped ONLY at a word boundary (snake_case stays clean)
+  //  - literal `<` becomes `&lt;` (HTML-safe, keeps <br> etc. unambiguous)
+  //  - tilde escaped UNCONDITIONALLY (every `~`, not just doubled runs) —
+  //    since DEL/S now round-trips through GFM `~~...~~` (see walkChildren
+  //    below), a literal `~~` typed by the user (no strikethrough intent at
+  //    all) would otherwise silently turn into real strikethrough the next
+  //    time the source is re-rendered. Escaping every single `~` is the
+  //    simplest deterministic rule that can't under-escape a run of any
+  //    length; marked un-escapes `\~` back to a literal `~` on parse either
+  //    way, so this is lossless for genuinely single tildes too.
+  // `]` mirrors `[` (CRITICAL 2 fix): escaping only `[` leaves an unbalanced
+  // literal `]` that breaks bracket pairing in the enclosing link/citation
+  // syntax — e.g. an <a> whose label is itself "[text]" would otherwise
+  // parse as a stray "[[text]](<a...>...)" instead of one working link.
+  function isWordChar(ch) {
+    return ch !== undefined && /\w/.test(ch);
+  }
+
+  function escapeText(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      if (c === '\\') { out += '\\\\'; continue; }
+      if (c === '`') { out += '\\`'; continue; }
+      if (c === '*') { out += '\\*'; continue; }
+      if (c === '[') { out += '\\['; continue; }
+      if (c === ']') { out += '\\]'; continue; }
+      if (c === '<') { out += '&lt;'; continue; }
+      if (c === '~') { out += '\\~'; continue; }
+      if (c === '_') {
+        const prev = s[i - 1];
+        const next = s[i + 1];
+        out += (isWordChar(prev) && isWordChar(next)) ? '_' : '\\_';
+        continue;
+      }
+      out += c;
+    }
+    return out;
+  }
+
+  // Real contenteditable output wraps plain runs in attribute-less <span>s
+  // (Chrome/Firefox formatting artifacts). Those are transparent. A <span>
+  // carrying any of these attributes is a real style/class/behavior carrier
+  // we don't support yet, so it is reported via `unsupported` instead of
+  // unwrapped. Widened (review fix 2026-08-25, IMPORTANT 4) past style/class
+  // to the realistic contenteditable/extension attribute set: browsers and
+  // editing extensions (spellcheck UI, Grammarly, TinyMCE-style paste) stamp
+  // these onto spans that carry real, non-plain-text intent.
+  const SPAN_ATTR_PROBE = [
+    'style', 'class', 'id', 'data-mce-style', 'data-mce-bogus',
+    'dir', 'contenteditable', 'spellcheck', 'lang', 'title',
+    'data-gramm', 'data-gramm_editor', 'data-enable-grammarly',
+  ];
+
+  function spanHasAttributes(node) {
+    for (let i = 0; i < SPAN_ATTR_PROBE.length; i++) {
+      const v = node.getAttribute(SPAN_ATTR_PROBE[i]);
+      // Deliberate: an attribute present but set to '' (e.g. class="") is
+      // treated the same as absent — it carries no actual style/behavior
+      // intent, so it shouldn't disqualify the span from being transparent.
+      if (v !== null && v !== undefined && v !== '') return true;
+    }
+    return false;
+  }
+
+  // CommonMark code-span fence: the fence must be longer than the longest
+  // run of consecutive backticks inside the content, or the fence closes
+  // early on that run (CRITICAL 1 fix, verified against marked.parseInline:
+  // a fixed 2-backtick fence corrupts content containing "``"). Padding is
+  // *required* whenever the content touches the fence boundary with a
+  // backtick (verified: unpadded "```x``" fails to parse as code at all);
+  // for interior-only backtick runs padding is optional but harmless
+  // (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) {
+    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 fence = new Array(longestRun + 2).join('`');
+    return fence + ' ' + raw + ' ' + fence;
+  }
+
+  // IMPORTANT 3 (degrade-never-lose): the citation form only round-trips
+  // through md2doc's own citation regex ([^\]\n]+) when the anchor's body
+  // is a single plain-text run with no embedded `]`. Nested formatting
+  // (childNodes isn't exactly one text node) or a body containing `]`
+  // between the outer brackets would either silently flatten real content
+  // or emit citation syntax md2doc can't re-parse — so those degrade to
+  // unsupported instead of emitting best-effort-but-broken markdown.
+  function isCitationEligible(node, text) {
+    if (node.childNodes.length !== 1 || node.childNodes[0].nodeType !== 3) return false;
+    const inner = text.slice(1, -1);
+    return inner.indexOf(']') === -1;
+  }
+
+  function serializeAnchor(node, unsupported) {
+    const href = node.getAttribute('href');
+    const text = node.textContent;
+    // citation: <a href="#slug">[body]</a> -> [[body]]
+    if (href && href.charAt(0) === '#' && /^\[.*\]$/.test(text)) {
+      if (isCitationEligible(node, text)) {
+        return '[[' + text.slice(1, -1) + ']]';
+      }
+      unsupported.push('A');
+      return '';
+    }
+    const label = walkChildren(node.childNodes, unsupported);
+    return '[' + label + '](' + (href || '') + ')';
+  }
+
+  // Walk a sibling list. A top-level <div> is a contenteditable line-break
+  // artifact (browsers split lines with <div> rather than <br>), so each
+  // <div> boundary after the first emits a <br> and its children are
+  // spliced inline, never nested further.
+  function walkChildren(nodes, unsupported) {
+    let out = '';
+    let firstSegment = true;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.nodeType === 3) {
+        out += escapeText(node.textContent);
+        firstSegment = false;
+        continue;
+      }
+      if (node.nodeType !== 1) continue;
+      const name = node.nodeName;
+      if (name === 'DIV') {
+        if (!firstSegment) out += '<br>';
+        out += walkChildren(node.childNodes, unsupported);
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'SPAN') {
+        if (spanHasAttributes(node)) {
+          unsupported.push(name);
+        } else {
+          out += walkChildren(node.childNodes, unsupported);
+        }
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'STRONG' || name === 'B') {
+        out += '**' + walkChildren(node.childNodes, unsupported) + '**';
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'EM' || name === 'I') {
+        out += '*' + walkChildren(node.childNodes, unsupported) + '*';
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'DEL' || name === 'S') {
+        // GFM strikethrough — verified marked (gfm: true, the renderer's own
+        // setOptions()) round-trips `~~x~~` to `<del>x</del>`; `<s>` is
+        // accepted on input (some contenteditable/paste paths produce it)
+        // but the toolbar/serializer always speak DEL, matching what marked
+        // itself emits.
+        out += '~~' + walkChildren(node.childNodes, unsupported) + '~~';
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'U') {
+        // Underline has no Markdown/GFM syntax at all, so this emits literal
+        // inline HTML by design — marked passes raw inline `<u>...</u>`
+        // straight through untouched (verified), which is exactly what we
+        // want: the rendered output shows an underline, and re-opening the
+        // WYSIWYG editor sees the same <u> element back (server-rendered
+        // HTML round-trips through the DOM parser the same way STRONG/EM/
+        // DEL do). No escaping concern the other marks have: unlike `~`/`*`/
+        // 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 += '<u>' + walkChildren(node.childNodes, unsupported) + '</u>';
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'CODE') {
+        out += serializeCode(node);
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'A') {
+        out += serializeAnchor(node, unsupported);
+        firstSegment = false;
+        continue;
+      }
+      if (name === 'BR') {
+        out += '<br>';
+        firstSegment = false;
+        continue;
+      }
+      unsupported.push(name);
+      firstSegment = false;
+    }
+    return out;
+  }
+
+  function serializeInline(rootEl) {
+    const unsupported = [];
+    const md = walkChildren(rootEl.childNodes, unsupported);
+    return { md, unsupported };
+  }
+
+  function canWysiwyg(rootEl) {
+    return serializeInline(rootEl).unsupported.length === 0;
+  }
+
+  return { serializeInline, canWysiwyg, escapeText };
+});

package/lib/editor/lineops.js

@@ -0,0 +1,71 @@
+'use strict';
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.md2docLineOps = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+
+  function replaceLines(lines, startLine, endLine, newLines) {
+    const out = lines.slice(0, startLine - 1)
+      .concat(newLines, lines.slice(endLine));
+    return { lines: out, delta: newLines.length - (endLine - startLine + 1) };
+  }
+
+  function insertLines(lines, afterLine, newLines) {
+    const out = lines.slice(0, afterLine).concat(newLines, lines.slice(afterLine));
+    return { lines: out, delta: newLines.length };
+  }
+
+  function shiftBlocks(blocks, editedId, delta) {
+    return blocks.map((b) =>
+      b.id > editedId
+        ? Object.assign({}, b, { startLine: b.startLine + delta, endLine: b.endLine + delta })
+        : b
+    );
+  }
+
+  function UndoStack() {
+    this._done = [];
+    this._undone = [];
+    this._savedDepth = 0;
+  }
+  UndoStack.prototype.push = function (op) {
+    this._done.push(op);
+    this._undone.length = 0;
+  };
+  UndoStack.prototype.undo = function (lines) {
+    const op = this._done.pop();
+    if (!op) return null;
+    this._undone.push(op);
+    const span = { startLine: op.startLine, endLine: op.startLine + op.after.length - 1 };
+    return { lines: replaceLines(lines, span.startLine, span.endLine, op.before).lines, op };
+  };
+  UndoStack.prototype.redo = function (lines) {
+    const op = this._undone.pop();
+    if (!op) return null;
+    this._done.push(op);
+    return { lines: replaceLines(lines, op.startLine, op.endLine, op.after).lines, op };
+  };
+  // §10-gap fix (review): pops the top of the stack and reverses it
+  // directly on `lines`, exactly like undo() — but, UNLIKE undo(), never
+  // pushes the popped op onto `_undone`. There is nothing to "redo" back
+  // to: as far as the stack's history is concerned this op never
+  // happened. Used to collapse an insert-then-immediately-abandon
+  // (never edited) block insertion to a true no-op — the file AND the
+  // undo stack both end up byte-identical to their pre-insert state,
+  // not merely "one undo away from it". Returns null if the stack is
+  // empty — same contract as undo()/redo().
+  UndoStack.prototype.discardTop = function (lines) {
+    const op = this._done.pop();
+    if (!op) return null;
+    const span = { startLine: op.startLine, endLine: op.startLine + op.after.length - 1 };
+    return { lines: replaceLines(lines, span.startLine, span.endLine, op.before).lines, op };
+  };
+  Object.defineProperty(UndoStack.prototype, 'dirtyDepth', {
+    get() { return this._done.length - this._savedDepth; },
+  });
+  UndoStack.prototype.markSaved = function () {
+    this._savedDepth = this._done.length;
+  };
+
+  return { replaceLines, insertLines, shiftBlocks, UndoStack };
+});

package/lib/editor/list-md.js

@@ -0,0 +1,258 @@
+'use strict';
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('./inline-md.js'));
+  } else {
+    root.md2docListMd = factory(root.md2docInlineMd);
+  }
+})(typeof self !== 'undefined' ? self : this, function (inlineMd) {
+
+  // list-md.js — list DOM -> minimal-form markdown (Phase-3 Task 3).
+  //
+  // ── Renderer finding (verified against lib/md2doc.js BEFORE writing
+  //    serializeList below — required by the task brief) ─────────────────
+  // lib/md2doc.js does NOT override renderer.list — only renderer.listitem,
+  // and that override (~line 638) is text-collection-only (appendSectionText)
+  // then delegates to marked's own baseListitem. So the actual list HTML
+  // shape below is marked's stock output (verified directly against
+  // marked.parse() with the same { gfm: true, breaks: false } options
+  // md2doc.js sets at ~line 703):
+  //
+  //   TIGHT (no blank line between source items):
+  //     <ul>\n<li>item two<ul>\n<li>nested a</li>\n...</ul>\n</li>\n...</ul>
+  //   A nested <ul>/<ol> is a trailing CHILD of the parent <li>, placed
+  //   AFTER that <li>'s own text/inline nodes — never a sibling of <li>
+  //   inside the outer list, and never wrapped in another <li>.
+  //
+  //   LOOSE (blank line between source items):
+  //     <li><p>item one</p>\n</li>
+  //     <li><p>item two</p>\n<ul>\n<li>nested a</li>\n</ul>\n</li>
+  //   marked wraps EACH item's own text in a <p>; a nested list (if any)
+  //   still comes after that <p>, still inside the same <li>.
+  //
+  //   TASK LIST: <li><input disabled type="checkbox"> todo</li> — the
+  //   checkbox is a plain, unhandled element as far as inline-md.js's
+  //   walkChildren() is concerned, so passing it through already reports
+  //   'INPUT' via that function's default unsupported-name branch — no
+  //   special-case needed here.
+  //
+  //   Both shapes also carry INSIGNIFICANT whitespace-only text nodes
+  //   (bare "\n") between a closing </p> or </ul> tag and the enclosing
+  //   closing </li> tag — an artifact of marked's own pretty-printed HTML
+  //   once it round-trips through a real DOM parser (innerHTML/DOMParser).
+  //   These are dropped before classifying an item's content (see
+  //   isBlankText() below) — keeping them would (a) miscount a loose
+  //   item's content node as 2 nodes instead of 1 (P + trailing "\n"),
+  //   breaking the loose-item detection, and (b) leak a literal "\n" into
+  //   the emitted line via inline-md's escapeText(), which does not treat
+  //   "\n" specially, splitting one list-item line into two physical
+  //   lines — a direct violation of the gate's one-line-per-item
+  //   contract. Dropping them loses no real content: they carry no
+  //   visible text. A stray NON-blank text node in either position (some
+  //   other DOM-construction path, not marked's own output) is a
+  //   different case — see "stray text" note below — and is flagged
+  //   unsupported rather than silently dropped or silently kept.
+  //
+  // ── Loose-list decision (task brief requires this be documented) ──────
+  // Loose (<p>-wrapped) items are reported UNSUPPORTED ('P') rather than
+  // serialized faithfully as blank-line-separated markdown. Reasoning:
+  //   1. Faithful round-trip needs a blank line between EVERY item at
+  //      the loose list's level, while nested tight sub-lists at deeper
+  //      indents must NOT get blank lines — the emission rule ("no blank
+  //      lines inside the emitted block UNLESS loose-list support
+  //      requires them") already flags this as the risky path.
+  //   2. The gate-compat contract (see test/gate-compat.test.js's sibling
+  //      table-md.js invariants, and this task's own list gate-compat
+  //      cases) is line-based: every list line matches
+  //      /^ *(-|\d+\.) / (indent is ancestor-marker-width accumulated, see
+  //      "INDENT" note below — not a fixed multiple of 2), and no test
+  //      elsewhere in this codebase tolerates a blank line inside a
+  //      structural emission.
+  //   3. Degrade-never-lose is the established pattern in inline-md.js
+  //      (SPAN with attributes, non-single-text-node citation anchors)
+  //      and table-md.js (CODE span containing '|'): when a DOM shape
+  //      cannot be represented losslessly under the emission contract,
+  //      flag it unsupported and let the caller fall back to raw-edit
+  //      instead of emitting best-effort-but-corrupting markdown.
+  // The item's own text is still serialized (best-effort, for debugging/
+  // visibility) even when flagged 'P' — same as table-md.js still returns
+  // `md` alongside a non-empty `unsupported` array. Callers must check
+  // `unsupported.length === 0` before trusting `md`, exactly as with
+  // inline-md.js / table-md.js.
+  //
+  // ── Emission form ───────────────────────────────────────────────────
+  // UL item: '- <inline>'; OL item: '<n>. <inline>' with n renumbered
+  // 1..n regardless of any source `start` attribute (a WYSIWYG editor
+  // must renumber after item insert/delete/reorder, so preserving a
+  // stale `start` would be actively wrong).
+  //
+  // INDENT (controller ruling, supersedes a fixed "2-space per depth"):
+  // a nested list's indent is the ACCUMULATED WIDTH of every ancestor
+  // item's own emitted marker, not a flat '  '.repeat(depth). A '- '
+  // marker is 2 columns; '1. ' is 3; '10. ' is 4 — CommonMark (and
+  // marked's own lexer) only keeps a sub-list attached to its parent
+  // list_item when the sub-list's indent is AT LEAST the parent marker's
+  // width. Verified directly against marked.lexer(): 2-space indent under
+  // an OL item (marker '1. ', 3 columns) de-nests on re-parse — the
+  // nested list comes back as a SEPARATE top-level list token, and two
+  // sibling OL items whose nested lists both mis-indent this way collapse
+  // into one merged list on re-lex. 3-space (or more) indent under that
+  // same '1. ' item keeps the nested list correctly attached as a child
+  // of item.tokens. See serializeListNode()'s `indentPrefix` parameter
+  // below and test/list-md.test.js's round-trip cases (ol>li>ul, ol>li>ol,
+  // 3-deep mixed, and the two-digit '10. '-width case).
+  //
+  // Nested lists are emitted as additional lines AFTER their parent
+  // item's own line. No trailing whitespace on any line (each line is
+  // explicitly trimmed of trailing space/tab); no leading whitespace
+  // either beyond the accumulated indent — a dropped unsupported leading
+  // element (e.g. a task-list checkbox <input>, which inline-md.js's
+  // walkChildren() already flags via its default unhandled-element
+  // branch without emitting anything for it) would otherwise leave a
+  // stray double space between the marker and the item's remaining text;
+  // itemMd's own leading whitespace is trimmed for exactly this reason.
+  //
+  // Constrained (same as inline-md.js / table-md.js, and for the same
+  // reason — the node test drives this with the hand-rolled element stub
+  // from test/inline-md.test.js / test/table-md.test.js) to childNodes /
+  // nodeType / nodeName / textContent / getAttribute — NO
+  // querySelector/querySelectorAll.
+
+  function allChildNodes(node) {
+    const out = [];
+    for (let i = 0; i < node.childNodes.length; i++) out.push(node.childNodes[i]);
+    return out;
+  }
+
+  // Matches ONLY the marked-pretty-print whitespace artifact (a text node
+  // that is pure whitespace AND contains a newline) — never a bare space
+  // (or run of spaces) with no newline, which is meaningful inline
+  // spacing a real contenteditable DOM can legitimately place directly
+  // between two inline nodes inside a tight <li> (no <p> wrapper). See
+  // header note above: the artifact marked actually emits is always
+  // exactly "\n", never a plain " ".
+  function isBlankText(node) {
+    return node.nodeType === 3 && /\n/.test(node.textContent) && /^\s*$/.test(node.textContent);
+  }
+
+  function isListNode(node) {
+    return node.nodeType === 1 && (node.nodeName === 'UL' || node.nodeName === 'OL');
+  }
+
+  // Serializes one UL/OL node (and everything nested under it) at the
+  // given accumulated indent prefix (a literal string of spaces — the
+  // sum of every ancestor item's own marker width, see header "INDENT"
+  // note). Returns an array of already-trimmed, already-indented
+  // physical lines. Mutates `unsupported` and `unsupportedByLi` in place
+  // (same aggregation pattern as table-md.js's serializeRow).
+  function serializeListNode(listEl, indentPrefix, unsupported, unsupportedByLi) {
+    const ordered = listEl.nodeName === 'OL';
+    const lines = [];
+    let n = 1;
+
+    allChildNodes(listEl).forEach((kid) => {
+      if (kid.nodeType === 3) {
+        // A stray text node directly under UL/OL (i.e. NOT inside an <li>)
+        // is either marked's own insignificant "\n" pretty-print artifact
+        // (dropped, see header) or genuine stray content from some other
+        // DOM-construction path — the latter can't be represented as a
+        // list line at all, so it is flagged rather than silently eaten.
+        if (!isBlankText(kid)) unsupported.push('TEXT');
+        return;
+      }
+      if (kid.nodeType !== 1) return; // any other exotic node type: ignore
+      if (kid.nodeName !== 'LI') {
+        unsupported.push(kid.nodeName);
+        return;
+      }
+
+      let checkAttr = null; // non-null once a .ed-li-check span is seen
+      const nestedLists = [];
+      const contentNodes = [];
+
+      // classifyLiChild: the per-child classify body, extracted so it can be
+      // shared between the direct <li> children loop and the .ed-li-text
+      // unwrap below — avoids duplicating isListNode/isBlankText branches.
+      const classifyLiChild = (c) => {
+        if (isListNode(c)) {
+          nestedLists.push(c);
+        } else if (isBlankText(c)) {
+          // dropped: insignificant whitespace-only artifact, see header
+        } else {
+          contentNodes.push(c);
+        }
+      };
+
+      allChildNodes(kid).forEach((c) => {
+        if (c.nodeType === 1 && c.nodeName === 'SPAN' && c.getAttribute('class') === 'ed-li-check') {
+          // Task 4 DOM shape: checkbox state lives on data-checked; consume
+          // the span here so it never reaches inline-md as unsupported content.
+          checkAttr = c.getAttribute('data-checked') === '1';
+        } else if (c.nodeType === 1 && c.nodeName === 'DIV' && c.getAttribute('class') === 'ed-li-text') {
+          // Task 4 DOM shape: inline content is wrapped in a .ed-li-text div.
+          // Unwrap by splicing its children into the SAME contentNodes list —
+          // NOT a separate variable — so the loose-item detection below
+          // (contentNodes.length === 1 && P) still fires correctly for a
+          // .ed-li-text that contains a single <p> (RULING F-M).
+          allChildNodes(c).forEach(classifyLiChild);
+        } else {
+          // Pre-Task-4 bare shape (tight/loose marked output, or plain li('text')
+          // fixtures) — unchanged behaviour, additive branch only.
+          classifyLiChild(c);
+        }
+      });
+
+      let inlineChildNodes = contentNodes;
+      if (contentNodes.length === 1 && contentNodes[0].nodeType === 1 && contentNodes[0].nodeName === 'P') {
+        unsupported.push('P'); // loose list item — see header decision
+        inlineChildNodes = allChildNodes(contentNodes[0]);
+      }
+
+      const { md: rawItemMd, unsupported: innerUnsupported } =
+        inlineMd.serializeInline({ childNodes: inlineChildNodes });
+
+      // Per-li attribution: record inline-serializer unsupported names keyed by
+      // this li's data-block-id (may be null for provisional lis that have not
+      // been assigned a blockId yet).
+      if (innerUnsupported.length > 0) {
+        unsupportedByLi.push({
+          blockId: kid.getAttribute('data-block-id'),
+          names: innerUnsupported.slice(),
+        });
+      }
+      innerUnsupported.forEach((u) => unsupported.push(u));
+
+      // strip leading whitespace left behind by a dropped leading element
+      // (e.g. a checkbox <input>) — see header note.
+      const itemMd = rawItemMd.replace(/^[ \t]+/, '');
+
+      // Two-part marker: bullet (ordered ordinal or plain '- ') and an
+      // optional checkbox prefix. The two parts are independent so that
+      // an ordered task list ('1. [ ] todo') gets BOTH — the brief's
+      // single-expression marker silently deletes checkbox on ordered
+      // task lists (RULING F-N).
+      const bullet = ordered ? (n + '. ') : '- ';
+      const marker = checkAttr === null ? bullet : bullet + (checkAttr ? '[x] ' : '[ ] ');
+      n++;
+      lines.push((indentPrefix + marker + itemMd).replace(/[ \t]+$/, ''));
+
+      // childIndentPrefix derives from marker.length — task item '- [ ] '
+      // (6 chars) gives a 6-space nested indent for free, no extra logic.
+      const childIndentPrefix = indentPrefix + new Array(marker.length + 1).join(' ');
+      nestedLists.forEach((nl) => {
+        serializeListNode(nl, childIndentPrefix, unsupported, unsupportedByLi).forEach((l) => lines.push(l));
+      });
+    });
+
+    return lines;
+  }
+
+  function serializeList(listEl) {
+    const unsupported = [];
+    const unsupportedByLi = [];
+    const lines = serializeListNode(listEl, '', unsupported, unsupportedByLi);
+    return { md: lines.join('\n'), unsupported, unsupportedByLi };
+  }
+
+  return { serializeList };
+});