@markup-carve/pandoc-carve 0.1.8 → 0.1.9

package/dist/cli.js

@@ -234,8 +234,21 @@ async function importToCarve(args) {
         }
         json = result.stdout;
     }
-    const { pandocToCarve } = await import('./index.js');
-    const { carve, warnings, diagnostics } = pandocToCarve(json);
+    const { pandocToCarve, PandocImportLimitError } = await import('./index.js');
+    let converted;
+    try {
+        converted = pandocToCarve(json);
+    }
+    catch (error) {
+        if (!(error instanceof PandocImportLimitError))
+            throw error;
+        if (args.diagnosticsFile !== undefined) {
+            report(args, [error.message], [error.diagnostic], 'pandoc-json');
+            process.exit(1);
+        }
+        throw error;
+    }
+    const { carve, warnings, diagnostics } = converted;
     const reportDiagnostics = args.from === 'json' ? diagnostics : [
         ...diagnostics,
         {
@@ -315,7 +328,7 @@ function diagnosticsForIncludes(warnings, suppressed, root) {
 const NORMALIZED_INCLUDE_RULES = new Set([
     'include-footnote-rename',
     'include-heading-clamp',
-    'include-heading-id-rename',
+    'include-id-rename',
 ]);
 function displayIncludeFile(file, root, fallback) {
     if (!file || !root)

package/dist/convert.js

@@ -15,7 +15,7 @@ import { diagnostic, migrationReport } from './diagnostics.js';
 import { provenanceAttr } from './provenance.js';
 import { blankDeniedDestination, probeScheme } from './url-scheme.js';
 import { isDangerousAttrName, renderedAttrValue } from './attribute-sanitize.js';
-import { SMART_PUNCTUATION_GLYPHS } from '@markup-carve/carve';
+import { SMART_PUNCTUATION_GLYPHS, fromAstJson, resolve } from '@markup-carve/carve';
 function warn(ctx, msg, details, sourceLocation) {
     ctx.warnings.push(msg);
     ctx.diagnostics.push(diagnostic('carve-to-pandoc', msg, details, sourceLocation));
@@ -89,12 +89,74 @@ function smallCapsOrSpan(a, xs) {
         return caps;
     return P.Span([id, rest, kvs], [caps]);
 }
-/** Carve's heading slug: case-preserving, GitHub-style. */
+/**
+ * Fallback heading slug, for a tree the engine's own resolver refuses. Mirrors
+ * the engine's rule: NFC, invisible controls dropped, each run of non-
+ * alphanumeric ASCII one `-`, an `s-` prefix before a leading digit.
+ */
 function slugify(text) {
-    return text
-        .trim()
-        .replace(/[^\p{L}\p{N}\s_-]/gu, '')
-        .replace(/\s+/g, '-');
+    const s = text
+        .normalize('NFC')
+        .replace(/[\u202a-\u202e\u2066-\u2069\u200b-\u200d\u2060\ufeff\u00ad]/gu, '')
+        .replace(/[^0-9A-Za-z\u{80}-\u{10FFFF}]+/gu, '-')
+        .replace(/^-+|-+$/g, '');
+    if (s === '')
+        return 's';
+    return /^\p{N}/u.test(s) ? `s-${s}` : s;
+}
+const HEADING_TAG = 'data-pandoc-carve-heading';
+/**
+ * The id the engine's `resolve()` gives every heading, keyed by the node.
+ *
+ * Asking the resolver rather than re-deriving: it owns the slug rule, the
+ * dedup suffix and the id namespace shared with explicit ids on other
+ * elements. Each heading in a copy is tagged so the answer maps back even
+ * though ingest moves footnote bodies around. Empty when the resolver refuses
+ * the tree; pass 1 then falls back to {@link slugify}.
+ */
+function resolvedHeadingIds(ast) {
+    const byTag = [];
+    const copy = (value) => {
+        if (Array.isArray(value))
+            return value.map(copy);
+        if (!value || typeof value !== 'object')
+            return value;
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = copy(v);
+        if (value.type === 'heading') {
+            const attrs = (out.attrs ?? {});
+            out.attrs = { ...attrs, keyValues: { ...(attrs.keyValues ?? {}), [HEADING_TAG]: String(byTag.length) } };
+            byTag.push(value);
+        }
+        return out;
+    };
+    const ids = new Map();
+    try {
+        const tagged = copy(ast);
+        if (byTag.length === 0)
+            return ids;
+        const resolved = resolve(fromAstJson(tagged));
+        const stack = [resolved];
+        while (stack.length) {
+            const value = stack.pop();
+            if (Array.isArray(value))
+                stack.push(...value);
+            else if (value && typeof value === 'object') {
+                const node = value;
+                const attrs = node.attrs;
+                const tag = node.type === 'heading' ? attrs?.keyValues?.[HEADING_TAG] : undefined;
+                const original = tag === undefined ? undefined : byTag[Number(tag)];
+                if (original && attrs?.id)
+                    ids.set(original, attrs.id);
+                stack.push(...Object.values(node));
+            }
+        }
+    }
+    catch {
+        ids.clear();
+    }
+    return ids;
 }
 function plainText(nodes) {
     let out = '';
@@ -134,7 +196,41 @@ function hasLabel(n) {
  * exactly; a flattened caption Para would be indistinguishable from a title.
  */
 function labelCaption(ctx, n) {
-    return !ctx.roundtrip && hasLabel(n) ? [P.Para([P.Strong(textInlines(n.label))])] : [];
+    return !ctx.roundtrip && hasLabel(n) ? [P.Para([P.Strong(labelInlines(ctx, n.label))])] : [];
+}
+/**
+ * A container label is an inline run (`CARVE-P9-041`), held as text on the
+ * node. It is parsed as a paragraph behind an escaped `.`, which no inline
+ * construct can absorb and which keeps a leading `#` or `-` from opening a
+ * block; the `.` is then taken back off.
+ */
+function labelInlines(ctx, label) {
+    if (!ctx.parseBlocks || /[\r\n]/.test(label))
+        return textInlines(label);
+    let parsed;
+    try {
+        parsed = ctx.parseBlocks(`\\.${label}`);
+    }
+    catch {
+        return textInlines(label);
+    }
+    const para = parsed.length === 1 && parsed[0]?.type === 'paragraph' ? parsed[0] : undefined;
+    const nodes = [...(para?.children ?? [])];
+    const first = nodes[0];
+    if (first?.type === 'text' && String(first.value ?? '').startsWith('.')) {
+        const rest = String(first.value).slice(1);
+        if (rest)
+            nodes[0] = { ...first, value: rest };
+        else
+            nodes.shift();
+    }
+    else if (first?.type === 'escaped_text' && first.value === '.') {
+        nodes.shift();
+    }
+    else {
+        return textInlines(label);
+    }
+    return inlines(ctx, nodes);
 }
 /**
  * Roundtrip-only kv that carries the grouping `[label]` for exact re-import.
@@ -143,7 +239,8 @@ function labelCaption(ctx, n) {
  * that the reverse importer would mistake for this internal marker.
  */
 function labelKv(ctx, n) {
-    return ctx.roundtrip && hasLabel(n) ? [['carve.label', n.label]] : [];
+    // An empty label still renders (an empty caption line), so it crosses too.
+    return ctx.roundtrip && typeof n.label === 'string' ? [['carve.label', n.label]] : [];
 }
 // Glyphs for the smart-typography kinds that do not carry one on the node.
 // A quote's glyph is locale-dependent and is chosen during parsing, so the node
@@ -395,8 +492,8 @@ function kids(ctx, n) {
  * this package's deliverable.
  *
  * One break, because that is what the clause adds. A payload that ends mid-line
- * publishes no break and keeps none here. `raw_block` is untouched: the same
- * clause says raw blocks keep their existing encoding.
+ * publishes no break and keeps none here. `raw_block.content` follows the same
+ * rule since spec #2916, and pandoc's `RawBlock` carries no final break either.
  */
 function codePayload(ctx, content, n) {
     if (!content.endsWith('\n'))
@@ -408,7 +505,8 @@ function codePayload(ctx, content, n) {
     // returns `""` for both a blank-line payload and an empty fence - but this
     // is the only place that still knows the difference, so it says so.
     if (payload === '') {
-        warn(ctx, "code block: a blank-only payload reaches pandoc as an empty one - pandoc's CodeBlock cannot hold the difference", { construct: 'code_block' }, n.pos);
+        const raw = n.type === 'raw_block';
+        warn(ctx, `${raw ? 'raw block' : 'code block'}: a blank-only payload reaches pandoc as an empty one - pandoc's ${raw ? 'RawBlock' : 'CodeBlock'} cannot hold the difference`, { construct: raw ? 'raw_block' : 'code_block' }, n.pos);
     }
     return payload;
 }
@@ -468,7 +566,8 @@ function collapsedHeadingRef(ctx, n) {
 }
 /** The key a collapsed reference and a heading's text meet on (PART 9R R1). */
 function headingTextKey(text) {
-    return text.replace(/[ \t\n\f\r]+/g, ' ').replace(/^ | $/g, '').normalize('NFC');
+    // A tab is key content, not a separator (corpus 565).
+    return text.replace(/[ \n\r]+/g, ' ').replace(/^ | $/g, '').normalize('NFC');
 }
 function unresolvedReference(ctx, n, kind) {
     if (n.ref === undefined)
@@ -494,7 +593,74 @@ function unresolvedReference(ctx, n, kind) {
     });
     return out;
 }
+/**
+ * A Note, with any note referenced from inside it lifted out to follow it.
+ *
+ * Pandoc's notes do not nest - its writers drop a Note inside a Note - so a
+ * reference in a note body becomes a sibling note right after the outer one,
+ * and a diagnostic says the reference moved. A roundtrip conversion keeps the
+ * nesting: the reverse direction reads it back, and pandoc's JSON carries it.
+ */
+function liftedNote(ctx, body) {
+    if (ctx.roundtrip) {
+        const note = P.Note(body());
+        ctx.noteCount++;
+        return [note];
+    }
+    if (ctx.noteDepth > 0) {
+        warn(ctx, 'footnote: a note referenced inside a note is lifted to follow it - pandoc\'s notes do not nest');
+    }
+    const outer = ctx.liftedNotes;
+    ctx.liftedNotes = [];
+    ctx.noteDepth++;
+    let content;
+    let lifted;
+    try {
+        content = body();
+    }
+    finally {
+        ctx.noteDepth--;
+        lifted = ctx.liftedNotes;
+        ctx.liftedNotes = outer;
+    }
+    ctx.noteCount++;
+    const notes = [P.Note(content), ...lifted];
+    if (ctx.noteDepth > 0) {
+        ctx.liftedNotes.push(...notes);
+        return [];
+    }
+    return notes;
+}
+/** Pandoc reads an empty title as no title, so an authored `""` cannot cross. */
+function emptyTitle(ctx, n, kind) {
+    if (n.title === '') {
+        warn(ctx, `${kind}: an empty title is dropped - pandoc reads an empty title as none`, { construct: kind }, n.pos);
+    }
+}
+/**
+ * Inline nodes whose pandoc constructor has no Attr slot (or, for the classed
+ * Span stand-ins, whose slot the bridge's own class fills), so an attribute run
+ * on them is dropped - said once per node rather than silently.
+ */
+const NO_ATTR_SLOT = {
+    emphasis: 'Emph',
+    strong: 'Strong',
+    underline: 'Underline',
+    strike: 'Strikeout',
+    subscript: 'Subscript',
+    superscript: 'Superscript',
+    highlight: 'Span .mark',
+    insert: 'Span .insertion',
+    delete: 'Span .deletion',
+    substitution: 'Span .substitution',
+    footnote_ref: 'Note',
+    inline_footnote: 'Note',
+};
 function inline(ctx, n) {
+    const slotless = NO_ATTR_SLOT[n.type];
+    if (slotless && hasAttrs(n.attrs)) {
+        warn(ctx, `attribute: the attributes on a ${n.type} are dropped - pandoc's ${slotless} has no slot for them`, { construct: n.type }, n.pos);
+    }
     switch (n.type) {
         case 'text':
             return textInlines(String(n.value ?? ''));
@@ -504,6 +670,9 @@ function inline(ctx, n) {
             return [P.SoftBreak];
         case 'hard_break':
             return [P.LineBreak];
+        case 'cell_wrap':
+            // A table continuation-line join; the contract renders it as one space.
+            return [P.Space];
         case 'emphasis':
             return [P.Emph(kids(ctx, n))];
         case 'strong':
@@ -570,6 +739,7 @@ function inline(ctx, n) {
             const unresolved = unresolvedReference(ctx, n, 'link');
             if (unresolved)
                 return unresolved;
+            emptyTitle(ctx, n, 'link');
             return [
                 P.Link(toAttr(ctx, n.attrs), inLink(ctx, n), [
                     safeDestination(ctx, String(n.href ?? ''), 'link'),
@@ -605,6 +775,7 @@ function inline(ctx, n) {
             const unresolved = unresolvedReference(ctx, n, 'image');
             if (unresolved)
                 return unresolved;
+            emptyTitle(ctx, n, 'image');
             return [
                 P.Image(toAttr(ctx, n.attrs), textInlines(String(n.alt ?? '')), [
                     safeDestination(ctx, String(n.src ?? ''), 'image'),
@@ -658,8 +829,14 @@ function inline(ctx, n) {
                     ctx.inCrossref = false;
                 }
             }
-            warn(ctx, `crossref: unresolved target "${target}" - emitting target text`);
-            return [P.Link(P.attr(undefined, ['crossref', 'unresolved']), [P.Str(target)], [`#${target}`, ''])];
+            // The engine renders an unresolved crossref as its literal source.
+            // Roundtrip keeps the classed link so the reverse direction restores
+            // the crossref rather than an escaped `</\#id>`.
+            warn(ctx, `crossref: unresolved target "${target}" - emitting the literal source`);
+            if (ctx.roundtrip) {
+                return [P.Link(P.attr(undefined, ['crossref', 'unresolved']), textInlines(`</#${target}>`), [`#${target}`, ''])];
+            }
+            return textInlines(`</#${target}>`);
         }
         // The wire has two nodes here, split so that a profile can deny one
         // without the other (markup-carve/carve#405): `footnote_ref` (`[^a]`)
@@ -672,9 +849,7 @@ function inline(ctx, n) {
             // a citation inside the note carries that note's number rather than
             // the next one - which is what pandoc's markdown reader produces.
             if (Array.isArray(n.inline)) {
-                const note = P.Note([P.Para(inlines(ctx, n.inline))]);
-                ctx.noteCount++;
-                return [note];
+                return liftedNote(ctx, () => [P.Para(inlines(ctx, n.inline))]);
             }
             const id = String(n.label ?? n.id ?? '');
             const def = ctx.footnoteDefs[id];
@@ -701,9 +876,21 @@ function inline(ctx, n) {
                 warn(ctx, `footnote: missing definition for [^${id}] - emitting the literal source`);
                 return textInlines(`[^${id}]`);
             }
-            const note = P.Note(blocks(ctx, def));
-            ctx.noteCount++;
-            return [note];
+            if (ctx.openNotes.has(id)) {
+                warn(ctx, `footnote: a cyclic reference to [^${id}] inside its own note is dropped - pandoc's notes do not nest`);
+                return [];
+            }
+            if (ctx.citedNotes.has(id)) {
+                warn(ctx, `footnote: [^${id}] is referenced more than once - pandoc's Note has no identity, so each reference carries its own copy`, { reference: `[^${id}]` }, n.pos);
+            }
+            ctx.citedNotes.add(id);
+            ctx.openNotes.add(id);
+            try {
+                return liftedNote(ctx, () => blocks(ctx, def));
+            }
+            finally {
+                ctx.openNotes.delete(id);
+            }
         }
         case 'math':
             // PANDOC'S `Math` IS `Math MathType Text` - two children and no
@@ -969,22 +1156,32 @@ function block(ctx, n) {
  */
 function lineBlock(ctx, n) {
     const lines = [];
+    let emptyLine = false;
     const stanzas = n.children ?? [];
     stanzas.forEach((stanza, i) => {
         if (i > 0)
             lines.push([]);
         const kids = stanza.children ?? [stanza];
         let current = [];
+        let broke = false;
         for (const kid of kids) {
             if (kid.type === 'hard_break' || kid.type === 'soft_break') {
+                if (current.length === 0 && broke)
+                    emptyLine = true;
                 lines.push(inlines(ctx, current));
                 current = [];
+                broke = true;
                 continue;
             }
             current.push(kid);
         }
+        if (current.length === 0 && broke)
+            emptyLine = true;
         lines.push(inlines(ctx, current));
     });
+    if (emptyLine) {
+        warn(ctx, 'line block: a hard break that leaves an empty line becomes an empty entry, which pandoc cannot tell from a stanza break', { construct: 'line_block' }, n.pos);
+    }
     return P.LineBlock(lines);
 }
 function blockInner(ctx, n) {
@@ -994,18 +1191,21 @@ function blockInner(ctx, n) {
             return [ctx.tight ? P.Plain(xs) : P.Para(xs)];
         }
         case 'heading':
-            return [P.Header(Number(n.level ?? 1), toAttr(ctx, n.attrs), kids(ctx, n))];
+            return [P.Header(Number(n.level ?? 1), toAttr(ctx, { ...(n.attrs ?? {}), id: ctx.headingIds.get(n) ?? n.attrs?.id }), kids(ctx, n))];
         case 'block_quote':
             return [P.BlockQuote(untight(ctx, () => blocks(ctx, n.children)))];
         case 'code_block': {
             const lang = n.lang ? [String(n.lang)] : [];
             const [id, classes, kvs] = toAttr(ctx, n.attrs);
+            if (lang.length === 0 && classes.length > 0) {
+                warn(ctx, `code block: a class without a language is read as the language by pandoc's writers - "${classes[0]}"`, { construct: 'code_block', class: classes[0] }, n.pos);
+            }
             return [
                 P.CodeBlock(P.attr(id, [...lang, ...classes], kvs), codePayload(ctx, String(n.content ?? ''), n)),
             ];
         }
         case 'raw_block':
-            return [P.RawBlock(String(n.format ?? ''), String(n.content ?? ''))];
+            return [P.RawBlock(String(n.format ?? ''), codePayload(ctx, String(n.content ?? ''), n))];
         case 'citation_definition':
             return [citationDefinition(ctx, n)];
         case 'thematic_break':
@@ -1153,15 +1353,27 @@ function list(ctx, n) {
                 ? [...kvs, ['carve-list-item', 'true'],
                     ...(carried ? [[TASK_STATE_KEY, state]] : [])]
                 : kvs;
-            itemBlocks = [P.Div([id, classes, marked], itemBlocks)];
+            const lead = itemBlocks[0];
+            if (typeof item.checked === 'boolean' && lead && (lead.t === 'Plain' || lead.t === 'Para')) {
+                // Pandoc reads a task only from a ballot that OPENS the item's
+                // first block, so a wrapping Div would hide it. The item's
+                // attributes ride on a Span after the ballot instead.
+                const [ballot, space, ...rest] = lead.c;
+                itemBlocks = [
+                    { t: lead.t, c: [ballot, space, P.Span([id, classes, marked], rest)] },
+                    ...itemBlocks.slice(1),
+                ];
+            }
+            else {
+                itemBlocks = [P.Div([id, classes, marked], itemBlocks)];
+            }
         }
         return itemBlocks;
     });
     if (n.ordered) {
         const style = OL_TYPE[String(n.olType ?? '')] ?? 'Decimal';
-        // `delim` lands in the Carve AST with carve-js PR 342; older parsers
-        // simply leave it undefined and we emit pandoc's default.
-        const delim = n.delim === ')' ? 'OneParen' : n.delim === '.' ? 'Period' : 'DefaultDelim';
+        // AST contract 1.1 omits the default `.` delimiter, so absence means Period.
+        const delim = n.delim === ')' ? 'OneParen' : 'Period';
         return P.OrderedList(Number(n.start ?? 1), style, converted, delim);
     }
     return P.BulletList(converted);
@@ -1270,6 +1482,11 @@ const ALIGN = {
  * origin transitively, bump the origin's span, and emit only origin cells.
  */
 function table(ctx, n, caption, shortCaption = null) {
+    const valigned = (n.columns ?? []).some((c) => c?.valign)
+        || (n.rows ?? []).some((r) => r?.cells?.some((c) => c?.valign));
+    if (valigned) {
+        warn(ctx, "table: vertical alignment is dropped - pandoc's Table has no slot for it", { construct: 'table' }, n.pos);
+    }
     if (!caption && Array.isArray(n.caption)) {
         ctx.captionKind = captionLabel(n.caption);
         caption = inlines(ctx, n.caption);
@@ -1289,7 +1506,10 @@ function table(ctx, n, caption, shortCaption = null) {
     const groups = read.groups;
     // Split leading all-header rows into the table head.
     let headCount = 0;
-    while (headCount < rows.length && rows[headCount].length > 0 && rows[headCount].every((c) => c.header)) {
+    // A span marker carries no header flag of its own, as in the engine's walk.
+    while (headCount < rows.length
+        && rows[headCount].some((c) => c.span === undefined)
+        && rows[headCount].every((c) => c.header || c.span !== undefined)) {
         headCount++;
     }
     if (groups)
@@ -1354,8 +1574,15 @@ function table(ctx, n, caption, shortCaption = null) {
         const declared = ALIGN[columns[c]?.align ?? ''];
         if (declared)
             return declared;
-        const cell = firstRow[c];
-        return firstRowIsHead && cell ? ALIGN[cell.align ?? ''] ?? 'AlignDefault' : 'AlignDefault';
+        if (!firstRowIsHead)
+            return 'AlignDefault';
+        // The last header row that marks the column sets its default, as in the engine.
+        for (let r = headCount - 1; r >= 0; r--) {
+            const marked = rows[r][c]?.align;
+            if (marked)
+                return ALIGN[marked] ?? 'AlignDefault';
+        }
+        return 'AlignDefault';
     });
     const origin = rows.map(() => []);
     const emitted = rows.map((row) => row.map(() => null));
@@ -1363,6 +1590,9 @@ function table(ctx, n, caption, shortCaption = null) {
         const row = rows[r];
         for (let c = 0; c < row.length; c++) {
             const cc = row[c];
+            // Already claimed by the strip of a `^` to its left.
+            if (origin[r][c])
+                continue;
             // Pandoc omits covered positions entirely, so a continuation that
             // RESOLVES leaves nowhere to hang its attributes. The grammar
             // cannot produce that shape (a cell carrying attributes is never a
@@ -1377,11 +1607,10 @@ function table(ctx, n, caption, shortCaption = null) {
             };
             if (cc.span === 'colspan') {
                 const org = origin[r][c - 1];
-                if (org) {
-                    // max() keeps 2D blocks correct: interior continuations of
-                    // a lower row must not widen the origin again.
-                    if (r === org.row)
-                        org.cell.colSpan = Math.max(org.cell.colSpan, c - org.col + 1);
+                // Widening a cell that started in an earlier row would cover
+                // cells already placed above (PART 9 section 13 T5).
+                if (org && org.row === r) {
+                    org.cell.colSpan = Math.max(org.cell.colSpan, c - org.col + 1);
                     origin[r][c] = org;
                     droppedAttrs();
                     continue;
@@ -1389,7 +1618,14 @@ function table(ctx, n, caption, shortCaption = null) {
                 warn(ctx, `table: colspan continuation at row ${r + 1}, col ${c + 1} has no origin - emitting empty cell`);
             }
             else if (cc.span === 'rowspan') {
-                const org = r > 0 ? origin[r - 1][c] : undefined;
+                const above = r > 0 ? origin[r - 1][c] : undefined;
+                // T5: only the origin's own column extends it, and only when the
+                // rest of its strip in this row is markers, so a span never
+                // covers another cell.
+                const org = above && above.col === c
+                    && row.slice(c + 1, c + above.cell.colSpan).every((next, k) => next.span !== undefined && !origin[r][c + 1 + k])
+                    ? above
+                    : undefined;
                 if (org) {
                     // POLICY: clip, do not restructure. Carve is the richer
                     // model here - its rows are one flat list, so a rowspan may
@@ -1411,7 +1647,8 @@ function table(ctx, n, caption, shortCaption = null) {
                         // max(): a 2D block has one rowspan continuation per
                         // covered column - count rows, not continuations.
                         org.cell.rowSpan = Math.max(org.cell.rowSpan, r - org.row + 1);
-                        origin[r][c] = org;
+                        for (let k = c; k < c + org.cell.colSpan && k < row.length; k++)
+                            origin[r][k] = org;
                         droppedAttrs();
                         continue;
                     }
@@ -1428,9 +1665,10 @@ function table(ctx, n, caption, shortCaption = null) {
             // A head cell's marker became the ColSpec above, so repeating it
             // here would emit an override pandoc does not need and the source
             // never had.
-            const cellAlign = firstRowIsHead && r === 0
+            const ownAlign = ALIGN[cc.align ?? ''] ?? 'AlignDefault';
+            const cellAlign = firstRowIsHead && r === 0 && ownAlign === colAligns[c]
                 ? 'AlignDefault'
-                : ALIGN[cc.align ?? ''] ?? 'AlignDefault';
+                : ownAlign;
             const pc = P.cell(cellBlocks, cellAlign, toAttr(ctx, cc.attrs));
             origin[r][c] = { cell: pc, row: r, col: c };
             emitted[r][c] = pc;
@@ -2097,6 +2335,42 @@ function scalarValue(ctx, key, raw) {
     }
     return P.MetaInlines(textInlines(value));
 }
+/**
+ * Trojan-Source controls (U+202A-202E, U+2066-2069), mirrored from the
+ * engine, which strips them from every rendered text and code run but keeps
+ * LRM/RLM. Raw passthrough is left alone, as the engine leaves it.
+ */
+const BIDI_CONTROLS = /[\u202a-\u202e\u2066-\u2069]/gu;
+/** Strip {@link BIDI_CONTROLS} in place from Str, Code, CodeBlock and Math; returns the count. */
+function stripBidi(value) {
+    let count = 0;
+    const strip = (s) => s.replace(BIDI_CONTROLS, () => {
+        count++;
+        return '';
+    });
+    const stack = [value];
+    while (stack.length) {
+        const v = stack.pop();
+        if (Array.isArray(v)) {
+            for (const x of v)
+                stack.push(x);
+            continue;
+        }
+        if (!v || typeof v !== 'object')
+            continue;
+        const node = v;
+        if (node.t === 'Str' && typeof node.c === 'string')
+            node.c = strip(node.c);
+        else if ((node.t === 'Code' || node.t === 'CodeBlock' || node.t === 'Math') && Array.isArray(node.c)
+            && typeof node.c[1] === 'string')
+            node.c[1] = strip(node.c[1]);
+        else if (node.t === 'RawInline' || node.t === 'RawBlock')
+            continue;
+        for (const x of Object.values(node))
+            stack.push(x);
+    }
+    return count;
+}
 // --- Entry point ---
 export function convert(ast, options = {}) {
     // PART 12 section 7: frontmatter and footnote DEFINITIONS are block nodes
@@ -2125,6 +2399,7 @@ export function convert(ast, options = {}) {
         footnoteDefs,
         crossrefTargets: new Map(),
         headingIdByText: new Map(),
+        headingIds: resolvedHeadingIds(ast),
         captionTargets: new Set(),
         tight: false,
         inCrossref: false,
@@ -2136,6 +2411,10 @@ export function convert(ast, options = {}) {
         symbols: options.symbols ?? {},
         listTable: options.listTable ?? true,
         noteCount: 0,
+        noteDepth: 0,
+        openNotes: new Set(),
+        citedNotes: new Set(),
+        liftedNotes: [],
         parseBlocks: options.parseBlocks,
         blockScalars: new Map(),
     };
@@ -2145,12 +2424,17 @@ export function convert(ast, options = {}) {
     // sits relative to its target.
     collectCrossrefTargets(ctx, body, new Map());
     const meta = parseMeta(ctx, frontmatter);
+    const converted = blocks(ctx, body);
+    const stripped = stripBidi(meta) + stripBidi(converted);
+    if (stripped > 0) {
+        warn(ctx, `bidi: ${stripped} bidi override or isolate control(s) stripped from text and code, as the engine's writers strip them`, { count: stripped });
+    }
     const diagnostics = ctx.diagnostics;
     return {
         doc: {
             'pandoc-api-version': [...P.PANDOC_API_VERSION],
             meta,
-            blocks: blocks(ctx, body),
+            blocks: converted,
         },
         warnings: ctx.warnings,
         diagnostics,
@@ -2201,7 +2485,14 @@ function collectCrossrefTargets(ctx, nodes, captionCounts, inPanel = false) {
         if (n.type === 'heading') {
             const children = n.children ?? [];
             const a = (n.attrs ?? {});
-            const id = a.id ?? slugify(plainText(children));
+            let id = a.id ?? ctx.headingIds.get(n);
+            if (id === undefined) {
+                const base = slugify(plainText(children));
+                id = base;
+                for (let k = 2; [...ctx.headingIds.values()].includes(id); k++)
+                    id = `${base}-${k}`;
+            }
+            ctx.headingIds.set(n, id);
             if (id && !ctx.crossrefTargets.has(id))
                 ctx.crossrefTargets.set(id, children);
             const text = headingTextKey(plainText(children));
@@ -2280,6 +2571,9 @@ function figureGroupTargets(ctx, n, captionCounts, inPanel) {
         const letter = panelLetter(panelIndex++);
         if (resolved && a.id && !ctx.crossrefTargets.has(a.id)) {
             ctx.crossrefTargets.set(a.id, [{ type: 'text', value: `${resolved}${letter}` }]);
+            // A panel caption holds no `#` either, so the crossref has to
+            // cross as the plain link it renders as (see `captionTargets`).
+            ctx.captionTargets.add(a.id);
         }
         collectCrossrefTargets(ctx, [child], captionCounts, true);
     }

package/dist/diagnostics.js

@@ -2,7 +2,8 @@
 const RULES = [
     { test: /^section:/, code: 'structure-unspellable', class: 'degraded' },
     { test: /^table: rowGroups\.(?:headAttrs|footAttrs|bodies\[\d+\]\.attrs) is dropped/, code: 'field-unspellable', class: 'lossy' },
-    { test: /^code block: a blank-only payload/, code: 'field-unspellable', class: 'lossy' },
+    { test: /^(code|raw) block: a blank-only payload/, code: 'field-unspellable', class: 'lossy' },
+    { test: /^code: a line break inside a code span/, code: 'field-unspellable', class: 'degraded' },
     { test: /^comment:/, code: 'comment-dropped', class: 'lossy' },
     { test: /^inline: unknown node type/, code: 'unknown-carve-inline', class: 'degraded' },
     { test: /^block: unknown node type/, code: 'unknown-carve-block', class: 'degraded' },
@@ -25,8 +26,10 @@ const RULES = [
     { test: /^definition list:/, code: 'definition-entry-skipped', class: 'lossy' },
     { test: /^ordered list: pandoc's example-list numbering/, code: 'ordered-list-counter-degraded', class: 'degraded' },
     { test: /^ordered list:/, code: 'ordered-list-marker-normalized', class: 'normalized' },
+    { test: /^list: a tight item's second paragraph/, code: 'list-item-framing-lost', class: 'degraded' },
     { test: /^list: an empty item/, code: 'empty-list-item-spelled', class: 'normalized' },
     { test: /^task state:/, code: 'task-state-dropped', class: 'lossy' },
+    { test: /^bidi: /, code: 'bidi-control-stripped', class: 'normalized' },
     { test: /^math: attributes/, code: 'math-attributes-dropped', class: 'lossy' },
     { test: /^symbol:/, code: 'symbol-unresolved', class: 'degraded' },
     { test: /^url: a denied scheme/, code: 'unsafe-url-scheme', class: 'lossy' },
@@ -35,6 +38,14 @@ const RULES = [
     { test: /^extension: ruby/, code: 'ruby-flattened', class: 'degraded' },
     { test: /^extension: block extension/, code: 'block-extension-fallback-rendered', class: 'degraded' },
     { test: /^extension:/, code: 'inline-extension-degraded', class: 'degraded' },
+    { test: /^footnote: a cyclic reference/, code: 'nested-note-cycle-dropped', class: 'lossy' },
+    { test: /^footnote: a note referenced inside a note is lifted/, code: 'nested-note-lifted', class: 'degraded' },
+    { test: /^link: an empty destination/, code: 'link-empty-destination-dropped', class: 'lossy' },
+    { test: /^(?:link|image): an empty title is dropped/, code: 'empty-title-dropped', class: 'lossy' },
+    { test: /^attribute: the attributes on a /, code: 'inline-attributes-dropped', class: 'lossy' },
+    { test: /^footnote: \[\^[^\]]*\] is referenced more than once/, code: 'note-reference-duplicated', class: 'degraded' },
+    { test: /^code block: a class without a language/, code: 'code-block-class-read-as-language', class: 'degraded' },
+    { test: /^line block: a hard break/, code: 'line-block-hard-break-dropped', class: 'lossy' },
     { test: /^(?:link|image|footnote): missing definition/, code: 'reference-unresolved', class: 'degraded' },
     { test: /^crossref:/, code: 'crossref-unresolved', class: 'degraded' },
     { test: /^list-table: structure/, code: 'list-table-structure-degraded', class: 'degraded' },
@@ -52,12 +63,13 @@ const RULES = [
     { test: /^table: .*padded with empty cells/, code: 'table-groups-normalized', class: 'degraded' },
     { test: /^table: a cell holds block content/, code: 'table-groups-normalized', class: 'normalized' },
     { test: /^table: the merged id/, code: 'table-wrapper-id-dropped', class: 'lossy' },
-    { test: /^table: a blank row has no pipe-table source spelling/, code: 'table-blank-row-spelled', class: 'normalized' },
     { test: /^table: .*converted with the implicit head\/body split/, code: 'table-row-groups-invalid', class: 'degraded' },
     { test: /^table: .*preserved in the Carve AST as `rowGroups`/, code: 'table-groups-flattened', class: 'degraded' },
     { test: /^table: a foot row's row header is dropped/, code: 'table-foot-row-header-dropped', class: 'lossy' },
     { test: /^table: the body rows disagree on how many leading cells/, code: 'table-row-heads-degraded', class: 'degraded' },
     { test: /^table: the rows of a declared body group disagree/, code: 'table-row-heads-degraded', class: 'degraded' },
+    { test: /^table: a hard break inside a cell/, code: 'table-cell-break-flattened', class: 'lossy' },
+    { test: /^table: vertical alignment/, code: 'table-vertical-alignment-dropped', class: 'lossy' },
     { test: /^table:/, code: 'table-unclassified-loss', class: 'unsupported' },
 ];
 export function diagnostic(direction, message, details, sourceLocation) {

package/dist/import-limits.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Nesting limits checked before a Pandoc document is imported: the reverse
+ * direction recurses per node, and the engine's Carve writer slows down steeply
+ * on deeply nested loose lists, so either could crash or hang the CLI.
+ */
+import type { ConversionDiagnostic } from './diagnostics.js';
+/** Deepest Pandoc node nesting accepted: the engine's own render cap. */
+export declare const MAX_PANDOC_DEPTH: number;
+/** Deepest list nesting accepted. */
+export declare const MAX_LIST_DEPTH = 32;
+export declare class PandocImportLimitError extends Error {
+    readonly diagnostic: ConversionDiagnostic;
+    constructor(kind: 'nodes' | 'lists', depth: number, limit: number);
+}
+/** Throw {@link PandocImportLimitError} when `doc` nests past a limit. Iterative, so it cannot overflow itself. */
+export declare function checkImportLimits(doc: unknown): void;

package/dist/import-limits.js

@@ -0,0 +1,54 @@
+/**
+ * Nesting limits checked before a Pandoc document is imported: the reverse
+ * direction recurses per node, and the engine's Carve writer slows down steeply
+ * on deeply nested loose lists, so either could crash or hang the CLI.
+ */
+import { MAX_RENDER_DEPTH } from '@markup-carve/carve';
+/** Deepest Pandoc node nesting accepted: the engine's own render cap. */
+export const MAX_PANDOC_DEPTH = MAX_RENDER_DEPTH;
+/** Deepest list nesting accepted. */
+export const MAX_LIST_DEPTH = 32;
+const LISTS = new Set(['BulletList', 'OrderedList', 'DefinitionList']);
+export class PandocImportLimitError extends Error {
+    diagnostic;
+    constructor(kind, depth, limit) {
+        const what = kind === 'lists' ? 'lists nest' : 'nodes nest';
+        const message = `pandoc document refused: ${what} ${depth} levels deep, past the import limit of ${limit}`;
+        super(message);
+        this.name = 'PandocImportLimitError';
+        this.diagnostic = {
+            code: 'pandoc-nesting-too-deep',
+            direction: 'pandoc-to-carve',
+            class: 'unsupported',
+            severity: 'error',
+            fidelity: 'dropped',
+            confidence: 'exact',
+            message,
+            details: { kind, depth, limit },
+        };
+    }
+}
+/** Throw {@link PandocImportLimitError} when `doc` nests past a limit. Iterative, so it cannot overflow itself. */
+export function checkImportLimits(doc) {
+    const stack = [[doc, 0, 0]];
+    while (stack.length) {
+        const [value, depth, lists] = stack.pop();
+        if (Array.isArray(value)) {
+            for (const item of value)
+                stack.push([item, depth, lists]);
+            continue;
+        }
+        if (!value || typeof value !== 'object')
+            continue;
+        const t = value.t;
+        const isNode = typeof t === 'string';
+        const nextDepth = isNode ? depth + 1 : depth;
+        const nextLists = isNode && LISTS.has(t) ? lists + 1 : lists;
+        if (nextDepth > MAX_PANDOC_DEPTH)
+            throw new PandocImportLimitError('nodes', nextDepth, MAX_PANDOC_DEPTH);
+        if (nextLists > MAX_LIST_DEPTH)
+            throw new PandocImportLimitError('lists', nextLists, MAX_LIST_DEPTH);
+        for (const child of Object.values(value))
+            stack.push([child, nextDepth, nextLists]);
+    }
+}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import type { PandocDoc } from './pandoc.js';
 import type { ConversionDiagnostic } from './diagnostics.js';
 import { type MigrationReport } from './diagnostics.js';
 export { PANDOC_API_VERSION, type PandocDoc } from './pandoc.js';
+export { PandocImportLimitError, MAX_PANDOC_DEPTH, MAX_LIST_DEPTH } from './import-limits.js';
 export type { ConvertOptions, ConvertResult } from './convert.js';
 export type { ParseOptions } from './parse-options.js';
 export type { ReverseResult } from './reverse.js';

package/dist/index.js

@@ -3,8 +3,10 @@ import { normalizeCarveAst, parseCarveAst, toCarveAst } from './ast-json.js';
 import { convert } from './convert.js';
 import { parseExtensions } from './parse-options.js';
 import { pandocToCarve as reverse } from './reverse.js';
-import { migrationReport } from './diagnostics.js';
+import { diagnostic, migrationReport } from './diagnostics.js';
+import { checkImportLimits, PandocImportLimitError, MAX_PANDOC_DEPTH } from './import-limits.js';
 export { PANDOC_API_VERSION } from './pandoc.js';
+export { PandocImportLimitError, MAX_PANDOC_DEPTH, MAX_LIST_DEPTH } from './import-limits.js';
 /**
  * The engine's own serializer, when the installed engine has one.
  *
@@ -228,14 +230,55 @@ export function carveToPandocJson(source, options) {
  */
 export function pandocToCarve(doc) {
     const parsed = typeof doc === 'string' ? JSON.parse(doc) : doc;
+    checkImportLimits(parsed);
     const { ast, warnings, diagnostics } = reverse(parsed);
     return {
-        carve: carve.renderCarve(engineRenderTree(ast)),
+        carve: writeCarve(ast, warnings, diagnostics),
         warnings,
         diagnostics,
         report: migrationReport(diagnostics),
     };
 }
+function writeCarve(ast, warnings, diagnostics) {
+    const write = (tree) => carve.renderCarve(engineRenderTree(tree));
+    try {
+        return write(ast);
+    }
+    catch (error) {
+        // The Carve tree can nest deeper than the Pandoc one (a list item is a
+        // node of its own), so the engine's cap can still be reached here.
+        if (error instanceof carve.RenderDepthError) {
+            throw new PandocImportLimitError('nodes', MAX_PANDOC_DEPTH + 1, MAX_PANDOC_DEPTH);
+        }
+        // The writer cannot spell some multiline code spans (a line block is
+        // one). Pandoc's own writers treat a newline in `Code` as a space, so
+        // fold it and say so rather than failing the whole document.
+        if (!(error instanceof Error) || !/cannot spell code/.test(error.message))
+            throw error;
+        let folded = false;
+        const fold = (node) => {
+            if (Array.isArray(node))
+                return node.map(fold);
+            if (!node || typeof node !== 'object')
+                return node;
+            const out = {};
+            for (const [key, value] of Object.entries(node))
+                out[key] = fold(value);
+            if (out['type'] === 'code' && typeof out['value'] === 'string' && /[\r\n]/.test(out['value'])) {
+                out['value'] = out['value'].replace(/\r\n?|\n/g, ' ');
+                folded = true;
+            }
+            return out;
+        };
+        const retried = fold(ast);
+        if (!folded)
+            throw error;
+        const message = 'code: a line break inside a code span has no Carve spelling here - written as a space';
+        warnings.push(message);
+        diagnostics.push(diagnostic('pandoc-to-carve', message));
+        return write(retried);
+    }
+}
 /**
  * Convert Pandoc to the canonical Carve exchange AST without forcing it through
  * Carve 0.1 source. This preserves structural fields, notably Pandoc's optional
@@ -243,6 +286,7 @@ export function pandocToCarve(doc) {
  */
 export function pandocToCarveAst(doc) {
     const parsed = typeof doc === 'string' ? JSON.parse(doc) : doc;
+    checkImportLimits(parsed);
     const { ast, warnings, diagnostics } = reverse(parsed, 'ast');
     return { ast: toCarveAst(ast, engineSerializer), warnings, diagnostics, report: migrationReport(diagnostics) };
 }

package/dist/reverse.js

@@ -8,7 +8,7 @@
  * are recognized and restored to their native Carve nodes, which makes
  * carve -> pandoc -> carve round-trips clean.
  */
-import { parse as parseCarve, renderCarve } from '@markup-carve/carve';
+import { parse as parseCarve, renderCarve, resolve } from '@markup-carve/carve';
 import { diagnostic } from './diagnostics.js';
 import { readProvenance } from './provenance.js';
 /**
@@ -290,12 +290,16 @@ function inline(ctx, n) {
             // accept both, because the type string is a single value. That is
             // why this waited for the lockfile to move rather than emitting
             // the new names defensively.
-            if (noteBlocks.length === 1 && (noteBlocks[0].t === 'Para' || noteBlocks[0].t === 'Plain')) {
+            // An inline note cannot hold another (`^[a ^[b]]` renders the inner
+            // one as literal text), so a note with a note inside is written as
+            // a definition, where a nested note does resolve.
+            if (noteBlocks.length === 1 && (noteBlocks[0].t === 'Para' || noteBlocks[0].t === 'Plain')
+                && !containsNote(noteBlocks[0].c)) {
                 return [{ type: 'inline_footnote', inline: inlines(ctx, noteBlocks[0].c) }];
             }
             const id = `fn${++ctx.noteCounter}`;
             ctx.footnoteDefs[id] = blocks(ctx, noteBlocks);
-            return [{ type: 'footnote_ref', id }];
+            return [{ type: 'footnote_ref', label: id }];
         }
         case 'Span':
             {
@@ -319,7 +323,7 @@ function inline(ctx, n) {
 function link(ctx, c) {
     const [a, xs, [href, title]] = c;
     const [, classes] = a;
-    if (classes.includes('uri') || classes.includes('email')) {
+    if ((classes.includes('uri') || classes.includes('email')) && autolinkParses(href, stringify(xs))) {
         const node = { type: 'autolink', href, text: stringify(xs) };
         // `uri`/`email` is the class the forward direction SYNTHESIZES to say
         // what kind of link this is, so it is not the author's and does not
@@ -334,14 +338,39 @@ function link(ctx, c) {
     if (classes.includes('crossref')) {
         return [{ type: 'heading_ref', target: href.replace(/^#/, '') }];
     }
+    if (href === '') {
+        // `[text]()` is literal text in Carve, and `[text](<>)` links to `<>`.
+        warn(ctx, 'link: an empty destination has no Carve spelling - the link text is kept without the link');
+        return inlines(ctx, xs);
+    }
     const node = { type: 'link', href, children: inlines(ctx, xs) };
     if (title)
         node.title = title;
-    const attrs = fromAttr(a);
+    // An autolink the engine cannot spell arrives here; its class is synthesized.
+    const label = stringify(xs);
+    const autolinkShaped = href === label || href === `mailto:${label}`;
+    const attrs = fromAttr([a[0], autolinkShaped ? classes.filter((c) => c !== 'uri' && c !== 'email') : classes, a[2]]);
     if (attrs)
         node.attrs = attrs;
     return [node];
 }
+/**
+ * Whether `<text>` reads back as an autolink to `href`. The engine's autolink
+ * grammar is narrower than pandoc's (an internationalized address is one it
+ * rejects), and such a link is written as an ordinary link instead.
+ */
+function autolinkParses(href, text) {
+    try {
+        const doc = parseCarve(`<${text}>`);
+        const only = doc.children?.[0]?.children;
+        // An empty href is a denied scheme the forward direction blanked; the
+        // engine blanks it again when it renders the autolink.
+        return only?.length === 1 && only[0]?.type === 'autolink' && (href === '' || only[0]?.href === href);
+    }
+    catch {
+        return false;
+    }
+}
 /** Restore convert.ts's classed-span degradations to native Carve nodes. */
 function span(ctx, c) {
     const [a, xs] = c;
@@ -567,7 +596,6 @@ function blocks(ctx, xs) {
         out.push(...block(ctx, x));
     return out;
 }
-const KNOWN_ADMONITIONS = new Set(['note', 'tip', 'warning', 'danger', 'info', 'caution', 'important']);
 function block(ctx, n) {
     const c = n.c;
     switch (n.t) {
@@ -642,7 +670,11 @@ function block(ctx, n) {
         }
         case 'RawBlock': {
             const [format, content] = c;
-            return [{ type: 'raw_block', format, content }];
+            // One final break, as a parsed fence carries (`CARVE-P12-064`).
+            // Unlike `CodeBlock`, pandoc's readers disagree here: markdown and
+            // rst publish `"a"`, gfm, commonmark_x, djot and org `"a\n"`.
+            const ends = content === '' || content.endsWith('\n');
+            return [{ type: 'raw_block', format, content: ends ? content : content + '\n' }];
         }
         case 'HorizontalRule':
             return [{ type: 'thematic_break' }];
@@ -678,14 +710,28 @@ function listItems(ctx, items) {
         let source = item;
         let attrs;
         let taskState = null;
-        if (item.length === 1 && item[0]?.t === 'Div') {
-            const [attr, inner] = item[0].c;
-            if (attr[2].some(([key, value]) => key === 'carve-list-item' && value === 'true')) {
-                taskState = readTaskState(attr[2]);
-                attrs = fromAttr([attr[0], attr[1], attr[2].filter(([key]) => key !== 'carve-list-item' && key !== TASK_STATE_KEY)]);
+        const isEnvelope = (attr) => attr[2].some(([key, value]) => key === 'carve-list-item' && value === 'true');
+        const readEnvelope = (attr) => {
+            taskState = readTaskState(attr[2]);
+            attrs = fromAttr([attr[0], attr[1], attr[2].filter(([key]) => key !== 'carve-list-item' && key !== TASK_STATE_KEY)]);
+        };
+        const lead = item[0];
+        const leadInlines = lead && (lead.t === 'Plain' || lead.t === 'Para') ? lead.c : undefined;
+        const span = leadInlines?.length === 3 && leadInlines[0]?.t === 'Str' && /^[☐☒]$/.test(String(leadInlines[0].c))
+            && leadInlines[1]?.t === 'Space' && leadInlines[2]?.t === 'Span' ? leadInlines[2] : undefined;
+        if (item.length === 1 && lead?.t === 'Div') {
+            const [attr, inner] = lead.c;
+            if (isEnvelope(attr)) {
+                readEnvelope(attr);
                 source = inner;
             }
         }
+        else if (span && isEnvelope(span.c[0])) {
+            // A task item's envelope rides on a Span after its ballot.
+            const [attr, inner] = span.c;
+            readEnvelope(attr);
+            source = [{ t: lead.t, c: [leadInlines[0], leadInlines[1], ...inner] }, ...item.slice(1)];
+        }
         if (source.some((b) => b.t === 'Para'))
             tight = false;
         const children = blocks(ctx, source);
@@ -781,12 +827,9 @@ function orderedList(ctx, c) {
     const olType = OL_STYLE[style.t];
     if (olType)
         node.olType = olType;
-    // Source-style metadata for AST consumers; renderCarve currently
-    // normalizes to `1.` regardless (fmt canonical form).
+    // AST contract 1.1 records only the non-default `)`; `.` is absence.
     if (delim?.t === 'OneParen' || delim?.t === 'TwoParens')
         node.delim = ')';
-    else if (delim?.t === 'Period')
-        node.delim = '.';
     // Pandoc's `Example` list is `(@)` numbering: ONE counter shared by every
     // example list in the document, and items can be labelled and referenced
     // from prose. PART 12 section 6 admits `a`/`A`/`i`/`I` and decimal, so the
@@ -984,7 +1027,8 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     // Row-head columns no longer send a table to the list-table form: the pipe
     // table marks those cells directly (see `rowHeadCols` above), which is
     // readable, needs no extension, and round-trips. Block cells need the
-    // list-table form, as do blank rows without attributes or alignment.
+    // list-table form. A wholly blank row is a pipe-table row since the spec
+    // ruled an explicitly delimited row of blank cells a table (corpus 589).
     //
     // A FOOT USED TO BE A SECOND REASON, AND IT WAS A REAL ONE AT THE TIME.
     // The clause read `|| (ctx.target === 'source' && footRaw.length > 0)`.
@@ -1004,25 +1048,7 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     // (corpus 376, spec f074372), so at the time the pipe form genuinely could
     // not carry a foot and the list-table detour was the only way to keep it.
     // The limitation is gone, so the detour is too.
-    const occupied = allRaw.map(() => []);
-    const hasBlankRows = allRaw.some((row, r) => {
-        let col = 0;
-        let blank = nCols > 0;
-        for (const raw of row[1]) {
-            while (occupied[r][col])
-                col++;
-            const [attr, align, height, width, content] = raw;
-            if (width > 1 || height > 1 || content.length || fromAttr(attr) || align.t !== 'AlignDefault')
-                blank = false;
-            for (let down = 1; down < height && r + down < allRaw.length; down++) {
-                for (let across = 0; across < width; across++)
-                    occupied[r + down][col + across] = true;
-            }
-            col += width;
-        }
-        return blank && !occupied[r].some(Boolean);
-    });
-    const useListTable = ctx.target === 'source' && (hasBlockCells || hasBlankRows);
+    const useListTable = ctx.target === 'source' && hasBlockCells;
     const pending = allRaw.map(() => Array(nCols));
     const rows = [];
     // The pandoc blocks that sat at each grid position, kept alongside the
@@ -1110,7 +1136,6 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
             attrs: fromAttr(a),
             colAligns,
             colWidths: columns.map((column) => column.width),
-            blankRows: !hasBlockCells && hasBlankRows,
         });
     }
     const node = { type: 'table', rows };
@@ -1176,7 +1201,10 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
         && groupBodies.every((b) => b.bodyRows > 0)
         && adjacentRunsDiffer
         && !leadingRunFillsTheRow
-        && headRaw.length === 0 && footRaw.length === 0
+        // A head is the leading run of fully marked rows, so it is safe beside
+        // a collapse as long as the first body does not open with one
+        // (`leadingRunFillsTheRow`). Corpus 589-31.
+        && footRaw.length === 0
         && !headAttrs && !footAttrs;
     const collapsed = [{
             headRows: 0,
@@ -1373,9 +1401,7 @@ function isInlineShaped(cellBlocks) {
  */
 function listTable(ctx, input) {
     const { rows, cellBlocksAt, headRows, footRows, bodies, caption, attrs, colAligns, colWidths } = input;
-    warn(ctx, input.blankRows
-        ? 'table: a blank row has no pipe-table source spelling - emitted as a `::: list-table` (structure preserved)'
-        : 'table: a cell holds block content, which a pipe table cannot spell - emitted as a `::: list-table` (structure preserved)');
+    warn(ctx, 'table: a cell holds block content, which a pipe table cannot spell - emitted as a `::: list-table` (structure preserved)');
     if (bodies.some((b) => b.attrs)) {
         warn(ctx, 'list-table: a body group\'s attributes are dropped - the extension has no body to hang them on');
     }
@@ -1493,12 +1519,27 @@ const bulletListOf = (items) => ({
     ordered: false,
     tight: items.every((item) => (item.children ?? []).length <= 1),
     items,
-    bulletChar: '-',
 });
 function cellInlines(ctx, cellBlocks) {
     // Block cells take the list-table path before this function is called.
     const first = cellBlocks[0];
-    return first ? mergeText(inlines(ctx, first.c)) : [];
+    return first ? mergeText(flattenCellBreaks(ctx, inlines(ctx, first.c))) : [];
+}
+/**
+ * A pipe-table row is one line, so a break inside a cell would end the row and
+ * turn the whole table into a paragraph. A soft break is a space anyway; a hard
+ * break has no spelling in a cell and is reported.
+ */
+function flattenCellBreaks(ctx, nodes) {
+    return nodes.map((n) => {
+        if (n.type === 'soft_break')
+            return text(' ');
+        if (n.type === 'hard_break') {
+            warn(ctx, 'table: a hard break inside a cell has no pipe-table spelling - written as a space');
+            return text(' ');
+        }
+        return Array.isArray(n.children) ? { ...n, children: flattenCellBreaks(ctx, n.children) } : n;
+    });
 }
 function captionFromBlocks(ctx, capBlocks) {
     if (!capBlocks?.length)
@@ -1736,13 +1777,12 @@ function div(ctx, c) {
     let kind;
     let rest = [];
     const wrapper = classes.includes('directive') ? 'directive' : classes.includes('admonition') ? 'admonition' : undefined;
+    // Only the bridge's own `admonition`/`directive` marker makes one: a
+    // pandoc Div classed `note` is an ordinary div that happens to use the word.
     if (wrapper) {
         rest = classes.filter((x) => x !== wrapper);
         kind = rest.shift();
     }
-    else if (classes.length === 1 && KNOWN_ADMONITIONS.has(classes[0])) {
-        kind = classes[0];
-    }
     if (kind) {
         const node = { type: wrapper === 'directive' ? 'directive' : 'admonition', kind, children: [] };
         let children = body;
@@ -1932,6 +1972,10 @@ export function pandocToCarve(doc, target = 'source') {
     const ast = { type: 'document', children };
     if (Object.keys(ctx.footnoteDefs).length)
         ast.footnoteDefs = ctx.footnoteDefs;
+    dropDerivableHeadingIds(ast);
+    if (target === 'source' && hasRejoinedFraming(children, false)) {
+        warn(ctx, "list: a tight item's second paragraph inside an indented container is rejoined to its first by the Carve writer");
+    }
     const yaml = metaToYaml(ctx, doc.meta ?? {});
     if (yaml)
         ast.frontmatter = { format: 'yaml', content: yaml };
@@ -1947,3 +1991,124 @@ function containsShortCaption(value) {
         return true;
     return Object.values(record).some(containsShortCaption);
 }
+const HEADING_TAG = 'data-pandoc-carve-heading';
+/**
+ * Drop a heading id the engine would derive at that position anyway.
+ *
+ * The forward direction writes every heading's resolved id onto `Header`, so
+ * without this a round trip would spell each one out as `{#id}`. Removal is
+ * applied only when re-resolving proves every heading keeps its id; a pandoc
+ * id that differs from the derived one stays explicit.
+ */
+function dropDerivableHeadingIds(ast) {
+    const headings = [];
+    const walk = (value) => {
+        if (Array.isArray(value))
+            value.forEach(walk);
+        else if (value && typeof value === 'object') {
+            if (value.type === 'heading')
+                headings.push(value);
+            Object.values(value).forEach(walk);
+        }
+    };
+    walk(ast);
+    const explicit = headings.filter((h) => typeof h.attrs?.id === 'string');
+    if (explicit.length === 0)
+        return;
+    const resolvedIds = (strip) => {
+        const index = new Map(headings.map((h, i) => [h, i]));
+        const copy = (value) => {
+            if (Array.isArray(value))
+                return value.map(copy);
+            if (!value || typeof value !== 'object')
+                return value;
+            const out = {};
+            for (const [k, v] of Object.entries(value))
+                out[k] = copy(v);
+            const at = index.get(value);
+            if (at !== undefined) {
+                const { id: _id, ...rest } = (out.attrs ?? {});
+                const attrs = strip.has(value) ? rest : { ...rest, ...(_id ? { id: _id } : {}) };
+                out.attrs = { ...attrs, keyValues: { ...(attrs.keyValues ?? {}), [HEADING_TAG]: String(at) } };
+            }
+            return out;
+        };
+        try {
+            const ids = new Array(headings.length);
+            const stack = [resolve(copy(ast))];
+            while (stack.length) {
+                const value = stack.pop();
+                if (Array.isArray(value))
+                    stack.push(...value);
+                else if (value && typeof value === 'object') {
+                    const node = value;
+                    const attrs = node.attrs;
+                    const tag = node.type === 'heading' ? attrs?.keyValues?.[HEADING_TAG] : undefined;
+                    if (tag !== undefined)
+                        ids[Number(tag)] = attrs?.id;
+                    stack.push(...Object.values(node));
+                }
+            }
+            return ids;
+        }
+        catch {
+            return null;
+        }
+    };
+    const baseline = resolvedIds(new Set());
+    const derived = resolvedIds(new Set(explicit));
+    if (!baseline || !derived)
+        return;
+    const strip = new Set(explicit.filter((h) => derived[headings.indexOf(h)] === h.attrs.id));
+    if (strip.size === 0)
+        return;
+    const after = resolvedIds(strip);
+    if (!after || after.some((id, i) => id !== baseline[i]))
+        return;
+    for (const h of strip) {
+        const { id: _id, ...rest } = h.attrs;
+        const order = (rest.order ?? []).filter((o) => o !== '#id');
+        if (order.length === 0)
+            delete h.attrs;
+        else
+            h.attrs = { ...rest, order };
+    }
+}
+function containsNote(value) {
+    if (Array.isArray(value))
+        return value.some(containsNote);
+    if (!value || typeof value !== 'object')
+        return false;
+    if (value.t === 'Note')
+        return true;
+    return containsNote(value.c);
+}
+/**
+ * Whether a tight list nested in a list item or a definition holds an item
+ * with two adjacent paragraphs. The writer spells the second one as a `+`
+ * continuation it places at the wrong column there, so it reads back joined
+ * to the first.
+ */
+function hasRejoinedFraming(nodes, indented) {
+    if (!Array.isArray(nodes))
+        return false;
+    return nodes.some((value) => {
+        if (!value || typeof value !== 'object')
+            return false;
+        const node = value;
+        if (node.type === 'list') {
+            const items = node.items ?? [];
+            if (indented && node.tight && items.some((item) => {
+                const kids = item.children ?? [];
+                return kids.some((kid, i) => kid.type === 'paragraph' && kids[i + 1]?.type === 'paragraph');
+            }))
+                return true;
+            return items.some((item) => hasRejoinedFraming(item.children, true));
+        }
+        if (node.type === 'definition_list') {
+            const items = node.items ?? [];
+            return items.some((item) => (item.definitions ?? []).some((d) => hasRejoinedFraming(d, true)));
+        }
+        return hasRejoinedFraming(node.children, indented);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markup-carve/pandoc-carve",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Carve to Pandoc bridge: convert Carve markup to Pandoc's JSON AST and reach every pandoc output format (LaTeX, Typst, DOCX, PDF, ...)",
   "keywords": [
     "carve",
@@ -55,7 +55,7 @@
     "source": "https://github.com/markup-carve/pandoc-carve"
   },
   "dependencies": {
-    "@markup-carve/carve": "^0.1.10"
+    "@markup-carve/carve": "^0.1.11"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",