@markup-carve/pandoc-carve 0.1.6 → 0.1.8

package/README.md

@@ -20,7 +20,7 @@ npm install @markup-carve/pandoc-carve
 ```
 
 The CLI requires Pandoc 3.x on `PATH` for formats other than JSON. CI currently
-tests Pandoc 3.11. Pandoc is not bundled.
+tests Pandoc 3.11 and 3.10.2. Pandoc is not bundled.
 
 ## CLI
 
@@ -105,6 +105,13 @@ them. Highlights include:
 - raw target content only survives in matching writers;
 - comments and attribute placement require round-trip metadata.
 
+These limits are measured rather than asserted.
+[pandoc-format-fidelity](https://github.com/markup-carve/pandoc-format-fidelity) runs Carve
+source through this bridge and back for every writer it lists, and publishes the verdicts per
+format: `results/carve-rt.json` holds the Carve round-trip lane, and
+[the report](https://github.com/markup-carve/pandoc-format-fidelity/blob/main/docs/index.html)
+covers every pandoc writer and reader.
+
 Dangerous URL schemes such as `javascript:` are blanked and reported. The
 [URL policy](docs/reference.md#dangerous-url-schemes-are-blanked) documents the
 exact behavior. The [mapping and limitations reference](docs/reference.md#what-maps-to-what)

package/dist/convert.js

@@ -452,8 +452,8 @@ function inLink(ctx, n) {
  * The heading a COLLAPSED reference reaches, or null.
  *
  * `[Some Heading][]` with no definition anywhere links to the heading whose
- * RENDERED text matches, case-insensitively - so `[plain one][]` reaches
- * `# Plain One`. The engine resolves this after the parse, which is why the
+ * RENDERED text matches exactly, case included - so `[Plain One][]` reaches
+ * `# Plain One` and `[plain one][]` does not. The engine resolves this after the parse, which is why the
  * node still carries an empty `href` here.
  *
  * Only the collapsed form. `[text][Some Heading]` does not reach a heading,
@@ -463,9 +463,13 @@ function inLink(ctx, n) {
 function collapsedHeadingRef(ctx, n) {
     if (!String(n.rawRef ?? '').endsWith('][]'))
         return undefined;
-    const text = plainText(n.children ?? []).trim().toLowerCase();
+    const text = headingTextKey(plainText(n.children ?? []));
     return text ? ctx.headingIdByText.get(text) : undefined;
 }
+/** 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');
+}
 function unresolvedReference(ctx, n, kind) {
     if (n.ref === undefined)
         return null;
@@ -631,20 +635,21 @@ function inline(ctx, n) {
             if (ctx.inCrossref)
                 return [];
             const target = String(n.target ?? '');
-            const found = ctx.crossrefTargets.get(target) ??
-                ctx.crossrefTargets.get(target.toLowerCase()) ??
-                findCaseInsensitive(ctx.crossrefTargets, target);
+            // Ids compare exactly (PART 9R R4): the target as written, then
+            // its NFC form. No case fold.
+            const key = ctx.crossrefTargets.has(target) ? target : target.normalize('NFC');
+            const found = ctx.crossrefTargets.get(key);
             if (found) {
                 // A caption target cannot come back as a crossref (see
                 // `captionTargets`), so it goes out as a plain link.
-                const classes = ctx.captionTargets.has(target.toLowerCase())
+                const classes = ctx.captionTargets.has(key)
                     ? []
                     : ['crossref'];
                 ctx.inCrossref = true;
                 try {
                     return [
                         P.Link(P.attr(undefined, classes), inlines(ctx, found), [
-                            `#${target}`,
+                            `#${key}`,
                             '',
                         ]),
                     ];
@@ -906,14 +911,6 @@ function citationDefinition(ctx, n) {
     // pandoc's own readers produce.
     entry.length ? [P.Para(entry)] : []);
 }
-function findCaseInsensitive(map, target) {
-    const lower = target.toLowerCase();
-    for (const [k, v] of map) {
-        if (k.toLowerCase() === lower)
-            return v;
-    }
-    return undefined;
-}
 // --- Blocks ---
 function blocks(ctx, nodes) {
     if (!nodes)
@@ -1563,11 +1560,22 @@ function table(ctx, n, caption, shortCaption = null) {
                 + `${lead} unmarked one(s), which its model cannot express`, { construct: 'table', row: r + 1, rowHeadColumns: lead, dropped: strays }, n.pos);
     }
     return P.Table(
-    // `header-rows` / `footer-rows` are the partition, and the partition
-    // reached `groups` above - leaving them here would state the same fact
-    // twice and put a stray attribute on the table in every pandoc writer.
-    // The list-table reader already filters its own copies of both.
-    toAttrWithout(ctx, n.attrs, ['aligns', 'valigns', 'widths', 'header-rows', 'footer-rows']), caption, colAligns, toRows(0, headCount), bodies, footRows, shortCaption, Array.from({ length: width }, (_, c) => columns[c]?.width ?? null), toAttr(ctx, groups?.headAttrs), toAttr(ctx, groups?.footAttrs));
+    // `header-rows` / `footer-rows` are the partition when a partition was
+    // consumed, and it reached `groups` above - leaving them here would
+    // state the same fact twice and put a stray attribute on the table in
+    // every pandoc writer. The list-table reader filters its own copies too.
+    //
+    // WITHOUT A PARTITION THEY ARE ORDINARY ATTRIBUTES AND HAVE TO SURVIVE.
+    // PART 12 section 15: invalid body metadata synthesizes no partition and
+    // leaves every row-group name, `header-rows` and `footer-rows` included,
+    // an ordinary attribute in HTML. The engine keeps the keys on `attrs`
+    // either way and signals consumption by `rowGroups` alone, so that is
+    // what this reads. Corpus 541: `{header-rows=1 body-rows=x}` renders
+    // `<table header-rows="1" body-rows="x">` and filtering unconditionally
+    // dropped the first of the two.
+    toAttrWithout(ctx, n.attrs, groups
+        ? ['aligns', 'valigns', 'widths', 'header-rows', 'footer-rows']
+        : ['aligns', 'valigns', 'widths']), caption, colAligns, toRows(0, headCount), bodies, footRows, shortCaption, Array.from({ length: width }, (_, c) => columns[c]?.width ?? null), toAttr(ctx, groups?.headAttrs), toAttr(ctx, groups?.footAttrs));
 }
 /**
  * The row-head column count a declared body's rows agree on, or 0.
@@ -2196,7 +2204,7 @@ function collectCrossrefTargets(ctx, nodes, captionCounts, inPanel = false) {
             const id = a.id ?? slugify(plainText(children));
             if (id && !ctx.crossrefTargets.has(id))
                 ctx.crossrefTargets.set(id, children);
-            const text = plainText(children).trim().toLowerCase();
+            const text = headingTextKey(plainText(children));
             // First heading wins, the same way the id map resolves a duplicate.
             if (id && text && !ctx.headingIdByText.has(text))
                 ctx.headingIdByText.set(text, id);
@@ -2214,7 +2222,7 @@ function collectCrossrefTargets(ctx, nodes, captionCounts, inPanel = false) {
                 const a = (n.attrs ?? {});
                 if (a.id && !ctx.crossrefTargets.has(a.id)) {
                     ctx.crossrefTargets.set(a.id, [{ type: 'text', value: `${label} ${next}` }]);
-                    ctx.captionTargets.add(a.id.toLowerCase());
+                    ctx.captionTargets.add(a.id);
                 }
             }
         }
@@ -2259,7 +2267,7 @@ function figureGroupTargets(ctx, n, captionCounts, inPanel) {
         const a = (n.attrs ?? {});
         if (a.id && !ctx.crossrefTargets.has(a.id)) {
             ctx.crossrefTargets.set(a.id, [{ type: 'text', value: resolved }]);
-            ctx.captionTargets.add(a.id.toLowerCase());
+            ctx.captionTargets.add(a.id);
         }
     }
     let panelIndex = 0;

package/dist/diagnostics.js

@@ -10,7 +10,7 @@ const RULES = [
     { test: /^block: pandoc node/, code: 'unsupported-pandoc-block', class: 'unsupported' },
     { test: /^citation: .*typed locator/, code: 'citation-locator-flattened', class: 'normalized' },
     { test: /^citation: .*suppresses its author/, code: 'citation-mode-normalized', class: 'normalized' },
-    { test: /^Cite mixes /, code: 'citation-mode-normalized', class: 'normalized' },
+    { test: /^Cite mixes /, code: 'citation-mode-normalized', class: 'degraded' },
     { test: /^Cite mapped /, code: 'citation-bibliography-not-emitted', class: 'degraded' },
     { test: /^SmallCaps /, code: 'smallcaps-degraded', class: 'degraded' },
     { test: /^short caption:/, code: 'short-caption-source-unavailable', class: 'unsupported' },
@@ -40,16 +40,19 @@ const RULES = [
     { test: /^list-table: structure/, code: 'list-table-structure-degraded', class: 'degraded' },
     { test: /^list-table: the short caption/, code: 'list-table-short-caption-dropped', class: 'lossy' },
     { test: /^list-table: a body group's attributes/, code: 'list-table-body-attributes-dropped', class: 'lossy' },
-    { test: /^list-table: the table's .* body groups/, code: 'list-table-body-groups-merged', class: 'normalized' },
-    { test: /^list-table: the body groups disagree/, code: 'list-table-row-heads-normalized', class: 'normalized' },
+    { test: /^list-table: a row's attributes/, code: 'list-table-row-attributes-dropped', class: 'lossy' },
+    { test: /^list-table: the table's .* body groups/, code: 'list-table-body-groups-merged', class: 'degraded' },
+    { test: /^list-table: the body groups disagree/, code: 'list-table-row-heads-normalized', class: 'degraded' },
     { test: /^list-table: rowspan/, code: 'list-table-rowspan-clipped', class: 'lossy' },
     { test: /^table: a row header outside/, code: 'table-row-head-outside-leading-run', class: 'lossy' },
     { test: /^table: attributes on/, code: 'table-continuation-attributes-dropped', class: 'lossy' },
     { test: /^table: colspan continuation/, code: 'table-colspan-origin-missing', class: 'degraded' },
     { test: /^table: rowspan crossing/, code: 'table-rowspan-clipped', class: 'lossy' },
     { test: /^table: rowspan continuation/, code: 'table-rowspan-origin-missing', class: 'degraded' },
-    { test: /^table: .*padded with empty cells/, code: 'table-groups-normalized', class: 'normalized' },
+    { 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' },

package/dist/reverse.js

@@ -983,9 +983,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 remain the one
-    // reason to leave, because a Carve `table_cell` holds INLINES and there is
-    // no pipe form for a cell holding blocks at all.
+    // readable, needs no extension, and round-trips. Block cells need the
+    // list-table form, as do blank rows without attributes or alignment.
     //
     // 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)`.
@@ -1005,7 +1004,25 @@ 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 useListTable = ctx.target === 'source' && hasBlockCells;
+    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 pending = allRaw.map(() => Array(nCols));
     const rows = [];
     // The pandoc blocks that sat at each grid position, kept alongside the
@@ -1093,6 +1110,7 @@ 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 };
@@ -1102,7 +1120,77 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     // pushed per raw row, so §15's sum holds by construction here. It is
     // checked where it can actually fail instead: on a partition that arrived
     // from outside (see readRowGroups).
-    const groups = { headRows: headRaw.length, bodies: groupBodies, footRows: footRaw.length };
+    // PART 12 section 15, carve#2402: A ROW-HEAD COUNT THE CELLS ALREADY STATE
+    // IS NOT A PARTITION. One body's data rows all carry the same leading `|=`
+    // run, so the count is derivable from them and the field would state
+    // nothing the rows do not - section 15 asks a producer to publish no
+    // `rowGroups` for a table whose one departure is that count on its single
+    // body. Measured on engine 0.1.10: keeping it made the writer spell
+    // `{header-rows=1 body-rows=1 body-header-cols=1}` where the bare pipe
+    // table renders byte-identical HTML. A body with no data row to carry the
+    // markers keeps the field, and so does every multi-body partition, where
+    // the counts are per body and the writer states them positionally.
+    //
+    // THE SAME RULE REACHES A SPLIT THAT ONLY ENCODES THOSE RUNS. Pandoc has no
+    // per-row row-head count, so the FORWARD direction splits one Carve body at
+    // every change in the marked run - that is the only way `|= b |` under
+    // `| a |` keeps its scope through pandoc's model. Those bodies are an
+    // encoding of the cells, not a partition the author wrote, and re-stating
+    // them invents a `tbody` boundary the source never had: measured on corpus
+    // 354-2, one `<tbody>` in becomes two out.
+    //
+    // A split that carries anything else - an intermediate header row, body
+    // attributes, a head or a foot - is real and is stated.
+    //
+    // A LEADING RUN THAT COVERS EVERY COLUMN IS NOT DERIVABLE EITHER WAY. A row
+    // whose every cell is marked reads as a HEADER ROW, and a leading run of
+    // them becomes the table head - so leaving the first body's count to the
+    // markers turns row headers into column headers. Measured on one column:
+    // a single body of two rows at `RowHeadColumns = 1` came back as a two-row
+    // `TableHead` over an empty body, and bodies at `[1, 0]` moved row 1 into
+    // the head. Only the FIRST body matters, because only a LEADING run is read
+    // as a head: corpus 354 collapses safely with counts `[0, 1]` over one
+    // column, since nothing marks its first row.
+    const leadingRunFillsTheRow = (groupBodies[0]?.rowHeadColumns ?? 0) >= nCols;
+    //
+    // EVERY ADJACENT PAIR MUST DISAGREE, because the forward direction splits at
+    // every CHANGE in the run - so the bodies it synthesizes never put two equal
+    // counts side by side. Counts of `[1, 1, 0]` hold a boundary no run change
+    // could have produced, and collapsing the lot merged the first two sections.
+    // "Some count somewhere differs" is not evidence about any one boundary.
+    const adjacentRunsDiffer = groupBodies.every((body, i) => i === 0 || (body.rowHeadColumns ?? 0) !== (groupBodies[i - 1].rowHeadColumns ?? 0));
+    //
+    // AND IT IS THE SOURCE WRITER'S NORMALIZATION ONLY. The pipe table cannot
+    // tell a derived split from an authored one, so writing it has to choose;
+    // the exchange AST has no such constraint and `rowGroups` is exact there,
+    // so `pandocToCarveAst` keeps every boundary the pandoc table carried.
+    const onlyRowHeadRuns = ctx.target === 'source'
+        && groupBodies.length > 1
+        && groupBodies.every((b) => b.headRows === 0 && b.attrs === undefined)
+        // AN EMPTY BODY IS NEVER A DERIVED ONE. The splitter cuts a run of data
+        // rows, so it cannot produce a body with none, and section 15 asks the
+        // writer to state even a single empty body. Collapsing one dropped the
+        // boundary AND, with the empty body leading, left the count check
+        // looking at a body with no rows to mark: `[0 (empty), 2]` over two
+        // columns emitted one fully marked row, which came back as the head.
+        && groupBodies.every((b) => b.bodyRows > 0)
+        && adjacentRunsDiffer
+        && !leadingRunFillsTheRow
+        && headRaw.length === 0 && footRaw.length === 0
+        && !headAttrs && !footAttrs;
+    const collapsed = [{
+            headRows: 0,
+            bodyRows: groupBodies.reduce((sum, b) => sum + b.bodyRows, 0),
+        }];
+    const derivableRowHead = groupBodies.length === 1
+        && groupBodies[0].bodyRows > 0
+        && !leadingRunFillsTheRow;
+    const publishedBodies = onlyRowHeadRuns
+        ? collapsed
+        : derivableRowHead
+            ? groupBodies.map(({ rowHeadColumns: _derivable, ...rest }) => rest)
+            : groupBodies;
+    const groups = { headRows: headRaw.length, bodies: publishedBodies, footRows: footRaw.length };
     if (headAttrs)
         groups.headAttrs = headAttrs;
     if (footAttrs)
@@ -1112,18 +1200,10 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
         if (ctx.target === 'source')
             reportUnspellableGroups(ctx, groups);
     }
-    // BOTH OF THESE ARE THE SOURCE WRITER'S BUSINESS ONLY. On the `ast` target
-    // the partition stays in `rowGroups`, where it is exact: there is no
-    // attribute line to state it on, so stating it would invent attributes the
-    // pandoc table never carried, and no read-back to merge the bodies, so the
-    // merge has no cost to report.
-    const stated = ctx.target === 'source' && footRaw.length > 0;
-    reportRunsAStatedPartitionMerges(ctx, {
-        leads: allRaw.map((_, r) => (isHeaderRow[r] === true ? nCols : rowHeadCols[r] ?? 0)),
-        from: headRaw.length,
-        to: allRaw.length - footRaw.length,
-        stated,
-    });
+    // STATING THE PARTITION IS THE SOURCE WRITER'S BUSINESS ONLY. On the `ast`
+    // target it stays in `rowGroups`, where it is exact: there is no attribute
+    // line to state it on, so stating it would invent attributes the pandoc
+    // table never carried.
     const attrs = ctx.target === 'source' ? statePartition(fromAttr(a), groups) : fromAttr(a);
     if (attrs)
         node.attrs = attrs;
@@ -1137,33 +1217,20 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     return node;
 }
 /**
- * A STATED PARTITION IS ONE BODY, and one body carries one row-header count.
- *
- * The count is not written down anywhere - `RowHeadColumns` has no spelling on
- * the attribute line - so the reader derives it from the leading `|=` run of the
- * body rows. It can only take a count every row agrees on: a declared body's
- * boundaries were stated, so it cannot split at a change the way the derived
- * bodies do. Rows that disagree therefore come back as data cells.
+ * Whether the table's attributes carry body metadata the engine did not consume.
  *
- * That only bites once the partition IS stated, which here means once there is a
- * foot. Without one the reader splits freely and every run survives, which is
- * why the pipe path's loss report does not name row-head columns in general.
- *
- * Reported from the writer because the writer is the only side that knows the
- * runs it just wrote: by the time the source is read back, the disagreement is
- * all that is left of them.
+ * The positional keys only reach `keyValues` when the engine read them as
+ * invalid - a consumed partition is spent on the AST's `rowGroups` instead. So
+ * their presence beside a flat partition is the signal, and PART 12 section 15
+ * then makes every row-group name on that block an ordinary attribute.
  */
-function reportRunsAStatedPartitionMerges(ctx, input) {
-    const { leads, from, to, stated } = input;
-    if (!stated)
-        return;
-    const distinct = new Set(leads.slice(from, to));
-    if (distinct.size < 2)
-        return;
-    warn(ctx, 'table: the body rows disagree on how many leading cells are row headers '
-        + `(${[...distinct].sort((x, y) => x - y).join(', ')}), and stating the foot states `
-        + 'the whole partition as ONE body - the reader takes a count every row agrees on, so '
-        + 'those cells come back as data cells');
+const POSITIONAL_BODY_KEYS = ['body-rows', 'body-header-rows', 'body-header-cols'];
+function carriesInvalidBodyMetadata(keyValues, groups) {
+    if (!POSITIONAL_BODY_KEYS.some((key) => keyValues[key] !== undefined))
+        return false;
+    const flat = groups.headRows === 0 && groups.footRows === 0 && groups.bodies.length === 1
+        && groups.bodies[0].headRows === 0 && groups.bodies[0].attrs === undefined;
+    return flat;
 }
 /**
  * State the head and foot row counts on the pipe table's attribute line.
@@ -1199,9 +1266,23 @@ function reportRunsAStatedPartitionMerges(ctx, input) {
  */
 function statePartition(attrs, groups) {
     const keyValues = { ...(attrs?.keyValues ?? {}) };
-    delete keyValues['header-rows'];
-    delete keyValues['footer-rows'];
-    if (groups.footRows > 0) {
+    // INVALID BODY METADATA MAKES THE WHOLE VOCABULARY ORDINARY ATTRIBUTES, and
+    // an ordinary attribute is retained, not restated. PART 12 section 15:
+    // "Invalid body metadata synthesizes no partition; all row-group metadata
+    // attributes, including `header-rows` and `footer-rows`, remain ordinary
+    // attributes in HTML." Corpus 541 exists to pin that, and dropping
+    // `header-rows` from `{header-rows=1 body-rows=x}` broke it: the source
+    // renders `<table header-rows="1" body-rows="x">` and the round trip
+    // rendered `<table body-rows="x">`.
+    //
+    // The stale-key guard below still applies whenever no such key is present,
+    // which is every table whose partition the engine actually consumed - a
+    // consumed key never reaches `keyValues` at all.
+    if (!carriesInvalidBodyMetadata(keyValues, groups)) {
+        delete keyValues['header-rows'];
+        delete keyValues['footer-rows'];
+    }
+    if (groups.footRows > 0 && !carriesInvalidBodyMetadata(keyValues, groups)) {
         if (groups.headRows > 0)
             keyValues['header-rows'] = String(groups.headRows);
         keyValues['footer-rows'] = String(groups.footRows);
@@ -1229,43 +1310,36 @@ function statePartition(attrs, groups) {
 /**
  * What a `rowGroups` partition says that the PIPE form cannot say back.
  *
- * The partition itself is not a degradation - it reaches the exchange AST
- * intact, and `pandocToCarveAst` hands it on whole. The loss happens one step
- * later, in the source writer: a pipe table states the head and the foot on its
- * attribute line and nothing else, so a second body group, a body's own
- * intermediate header rows and its attributes come out as ordinary body rows.
- * PART 12 §15 says so in as many words and asks for exactly this - "a canonical
- * Carve writer loses it ... conversion APIs with diagnostics should report that
- * loss".
+ * Only a body group's own attributes, now. The partition itself reaches the
+ * exchange AST intact and `pandocToCarveAst` hands it on whole, and the source
+ * writer states the rest of it: `{header-rows=N footer-rows=M}` for the head
+ * and foot, and PART 12 section 15's positional `body-rows`,
+ * `body-header-rows` and `body-header-cols` for the bodies.
  *
- * THE FOOT IS NOT ON THAT LIST ANY MORE, AND IT WAS. `{header-rows=N
- * footer-rows=M}` before a pipe table is what the `rowGroups` note in
- * docs/ast-json.md calls "the simple partition spelled by `header-rows` /
- * `footer-rows`", and the engine synthesizes it - measured, see the note beside
- * `useListTable`. Naming it here reported a loss that no longer happens, on the
- * one construct the writer had just started spelling.
+ * THREE THINGS CAME OFF THIS LIST, each because the writer started spelling
+ * them. The foot went first. Row-head columns went next, read back off the
+ * `|= North | 11 |` markers the writer puts on the cells. The body groups and
+ * their intermediate header rows went with carve 0.1.10, which writes the
+ * positional keys: measured on a head, two bodies of which the second leads
+ * with a header row, and a foot, the round trip returns the same partition and
+ * the HTML carries one `tbody` per body. Reporting them as lost named a loss
+ * that no longer happens.
  *
- * ROW-HEAD COLUMNS ARE NOT ON IT EITHER, for the reason the note beside
- * `rowHeadCols` gives: the pipe table marks those cells (`|= North | 11 |`) and
- * the forward direction reads the count back off exactly that run. Measured in
- * both shapes, with a foot and without.
+ * Section attributes have no attribute-line spelling at all (section 15 says
+ * so), so they are what is left.
  *
  * AST output retains these groups. This diagnostic applies only when writing
- * source, whose pipe-table syntax cannot express the full partition.
+ * source.
  */
 function reportUnspellableGroups(ctx, groups) {
     const lost = [];
-    if (groups.bodies.length > 1)
-        lost.push(`${groups.bodies.length} body groups`);
-    if (groups.bodies.some((b) => b.headRows > 0))
-        lost.push("a body's intermediate header rows");
     if (groups.bodies.some((b) => b.attrs !== undefined))
         lost.push("a body group's attributes");
     if (!lost.length)
         return;
     warn(ctx, `table: ${lost.join(', ')} - preserved in the Carve AST as \`rowGroups\`, `
-        + 'but a pipe table states only its head and foot row counts, so the '
-        + 'emitted source flattens them into body rows');
+        + 'but Carve source has no spelling for the attributes of a table section, '
+        + 'so the emitted source drops them');
 }
 /**
  * Whether a cell's blocks fit Carve's pipe-table cell, which holds INLINES.
@@ -1299,14 +1373,15 @@ function isInlineShaped(cellBlocks) {
  */
 function listTable(ctx, input) {
     const { rows, cellBlocksAt, headRows, footRows, bodies, caption, attrs, colAligns, colWidths } = input;
-    // One reason is left to be here, so the diagnostic states it rather than
-    // selecting between three strings two of which nothing could reach: row-head
-    // columns are marked on the cells and a foot is stated on the attribute
-    // line, both in the pipe form.
-    warn(ctx, 'table: a cell holds block content, which a pipe table cannot spell - emitted as a `::: list-table` (structure preserved)');
+    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)');
     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');
     }
+    if (rows.some((row) => row.attrs)) {
+        warn(ctx, 'list-table: a row\'s attributes are dropped - the extension has no row-attribute spelling');
+    }
     if (bodies.slice(1).some((b) => b.headRows === 0)) {
         warn(ctx, `list-table: the table's ${bodies.length} body groups merge where a later body has no header row to mark its boundary`);
     }
@@ -1471,27 +1546,6 @@ function figure(ctx, c) {
             return [node];
         }
     }
-    if (single?.t === 'Table') {
-        // The wrapper and the Table collapse into ONE Carve node, so their
-        // attrs merge rather than the inner one silently winning: pandoc's
-        // readers put the label on the Figure, not on the Table it wraps, and
-        // dropping it took the id a `</#id>` resolves against with it. The
-        // outer id wins, classes union, key/values merge with the outer taking
-        // precedence.
-        //
-        // A table is the only host that collapses this way, because it is the
-        // only one Carve gives a caption of its own. Every other host keeps
-        // both nodes - the wrapper stays a `figure` and the host's own attrs
-        // ride on the target - which is what the Div arm below sorts out.
-        //
-        // It matters most for a §4c table PANEL, whose id is what resolves as
-        // the group's number plus a letter.
-        const node = table(ctx, single.c, caption, shortCaption);
-        const outer = fromAttr(a);
-        if (outer)
-            node.attrs = mergeCAttrs(node.attrs, outer);
-        return [node];
-    }
     // A HOST THAT CARRIES ITS OWN ATTRIBUTES ARRIVES INSIDE A DIV. Pandoc's
     // BlockQuote, Para and CodeBlock have no Attr slot, so `block()` in the
     // forward direction wraps an attributed one in a Div. A `div` is not a
@@ -1515,6 +1569,21 @@ function figure(ctx, c) {
             ]);
         }
     }
+    if (host?.t === 'Table') {
+        // A table caption lives on the table, including when a reader puts
+        // an alignment Div between it and the Figure. Outer attributes win.
+        const node = table(ctx, host.c, caption, shortCaption);
+        const outer = fromAttr(a);
+        for (const attrs of [hostAttrs, outer]) {
+            const current = node.attrs;
+            if (current?.id && attrs?.id && current.id !== attrs.id) {
+                warn(ctx, `table: the merged id "${current.id}" is dropped in favor of "${attrs.id}" - one Carve node has one id`);
+            }
+            if (attrs)
+                node.attrs = mergeCAttrs(current, attrs);
+        }
+        return [node];
+    }
     if (host && FIGURE_HOSTS.has(host.t)) {
         // A single-host `Figure` is an ordinary `figure` around that host -
         // the generic captioned wrapper of PART 9 §4b, which is what the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markup-carve/pandoc-carve",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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.8"
+    "@markup-carve/carve": "^0.1.10"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",