@stll/folio-core 0.33.1 → 0.34.0

package/dist/ai-edits/table-template.js

@@ -0,0 +1,176 @@
+import { stripBlockIdentityAttrs } from "./block-identity.js";
+import { Fragment } from "prosemirror-model";
+//#region src/ai-edits/table-template.ts
+/**
+* Building a table from another document's table rather than from a grid of
+* strings.
+*
+* `insertTable` and `insertTableRow` describe their content as cell texts,
+* which is the right shape for a caller that writes a table from nothing. A
+* comparison is not that caller: the table it adds already exists in the
+* document it is comparing against, complete with its `w:tblPr`, its
+* `w:tblGrid` widths, per-row `w:trPr`, per-cell `w:tcPr` — spans, vertical
+* merges, shading, borders, margins, alignment — and cell paragraphs carrying
+* their own properties. Rebuilding that from text loses every one of them, and
+* a consumer accepting the redline then gets a table that is not the one it
+* was compared to.
+*
+* So the operation may be handed the node it should place. The copy is
+* structural and keeps everything by default; what it cannot bring is what
+* only the package it came from can resolve — a relationship id (a drawing, a
+* hyperlink), a note or comment id, a bookmark, a paragraph identity, or a
+* tracked change belonging to the other document's history. Everything that
+* describes the table itself travels.
+*/
+/**
+* Nodes that name something the other package owns: a drawing's relationship,
+* an anchored frame's, a bookmark's id. They resolve to nothing once the table
+* has crossed, so they are dropped rather than copied into a dangling
+* reference.
+*/
+const PACKAGE_BOUND_NODE_NAMES = /* @__PURE__ */ new Set([
+	"image",
+	"textBox",
+	"textBoxAnchor",
+	"shape",
+	"bookmarkBoundary"
+]);
+/**
+* Marks that name something the other package owns. Run properties are the
+* point of copying the runs at all, so the denial is narrow: a relationship, a
+* note, a comment, and the other document's revisions.
+*/
+const PACKAGE_BOUND_MARK_NAMES = /* @__PURE__ */ new Set([
+	"hyperlink",
+	"footnoteRef",
+	"comment",
+	"insertion",
+	"deletion",
+	"runPropertyChange"
+]);
+/**
+* Paragraph attrs cleared on a copied paragraph: its identity, the bookmarks
+* and empty hyperlinks that name package-scoped ids, the section it ended, and
+* the tracked-change history of the document it came from. Its formatting —
+* style, alignment, spacing, indentation, borders, shading, tabs — is what the
+* copy exists to carry, and stays.
+*/
+const CLEARED_PARAGRAPH_ATTRS = [
+	"bookmarks",
+	"_emptyHyperlinks",
+	"_propertyChanges",
+	"pPrMark",
+	"_suggestedInsert",
+	"_sectionProperties",
+	"sectionBreakType",
+	"renderedPageBreakBefore"
+];
+/** Table, row and cell attrs that record the other document's revisions. */
+const CLEARED_TABLE_ATTRS = ["tblPrChange", "_suggestedInsert"];
+const CLEARED_ROW_ATTRS = [
+	"trIns",
+	"trDel",
+	"trPrChange"
+];
+const CLEARED_CELL_ATTRS = ["cellMarker", "tcPrChange"];
+const withoutAttrs = (attrs, cleared) => {
+	const next = { ...attrs };
+	for (const key of cleared) next[key] = null;
+	return next;
+};
+const insertionMarkOf = (schema, revision) => {
+	const markType = schema.marks["insertion"];
+	if (!revision || !markType) return null;
+	const { revisionId, author, date, initials, provenance, suggestionId } = revision;
+	return markType.create({
+		revisionId,
+		author,
+		date,
+		...initials !== void 0 && { initials },
+		...provenance !== void 0 && { provenance },
+		...suggestionId !== void 0 && { suggestionId }
+	});
+};
+const copiedAttrs = (node, context) => {
+	switch (node.type.spec["tableRole"]) {
+		case "table": return withoutAttrs(node.attrs, CLEARED_TABLE_ATTRS);
+		case "row": {
+			const attrs = withoutAttrs(node.attrs, CLEARED_ROW_ATTRS);
+			return context.revision ? {
+				...attrs,
+				trIns: context.revision
+			} : attrs;
+		}
+		case "cell":
+		case "header_cell": {
+			const attrs = withoutAttrs(node.attrs, CLEARED_CELL_ATTRS);
+			return context.clampRowSpan ? {
+				...attrs,
+				rowspan: 1
+			} : attrs;
+		}
+		default: return node.isTextblock ? withoutAttrs(stripBlockIdentityAttrs(node.attrs), CLEARED_PARAGRAPH_ATTRS) : node.attrs;
+	}
+};
+/**
+* One node of the template, or `null` when it names something the package it
+* came from owns. Inline content carries the insertion mark; a nested table is
+* copied by the same rules as the one holding it.
+*/
+const copyNode = (node, context) => {
+	if (PACKAGE_BOUND_NODE_NAMES.has(node.type.name)) return null;
+	const marks = node.marks.filter(({ type }) => !PACKAGE_BOUND_MARK_NAMES.has(type.name));
+	if (node.isLeaf) return node.mark(node.isInline && context.insertion ? [...marks, context.insertion] : marks);
+	const inner = node.type.spec["tableRole"] === "table" ? {
+		...context,
+		clampRowSpan: false
+	} : context;
+	const content = [];
+	node.forEach((child) => {
+		const copied = copyNode(child, inner);
+		if (copied) content.push(copied);
+	});
+	return node.type.create(copiedAttrs(node, context), Fragment.fromArray(content), marks);
+};
+/**
+* The template table, ready to insert: its properties, grid, rows and cells
+* carried verbatim, nested tables included, and every row plus every run
+* stamped as an insertion when the caller is tracking changes.
+*
+* `null` when the template is not a table or holds no rows, so the caller can
+* fall back to the operation's own cell texts rather than place something that
+* is not one.
+*/
+const tableFromTemplate = ({ schema, template, revision }) => {
+	if (template.type.spec["tableRole"] !== "table" || template.childCount === 0) return null;
+	return copyNode(template, {
+		revision: revision ?? null,
+		insertion: insertionMarkOf(schema, revision ?? null),
+		clampRowSpan: false
+	});
+};
+/**
+* The template row, ready to insert into an existing table.
+*
+* Refused — `null`, so the caller falls back to the operation's cell texts —
+* when the row's cells do not span exactly the receiving table's grid: a row
+* of a different width would leave the table's map inconsistent with its own
+* grid. A cell that merged vertically in the document it came from is placed
+* unmerged, because the rows it reached into are not this table's.
+*/
+const tableRowFromTemplate = ({ template, columnCount }) => {
+	if (template.type.spec["tableRole"] !== "row" || template.childCount === 0) return null;
+	let spanned = 0;
+	template.forEach((cell) => {
+		const colspan = cell.attrs["colspan"];
+		spanned += typeof colspan === "number" ? colspan : 1;
+	});
+	if (spanned !== columnCount) return null;
+	return copyNode(template, {
+		revision: null,
+		insertion: null,
+		clampRowSpan: true
+	});
+};
+//#endregion
+export { tableFromTemplate, tableRowFromTemplate };

package/dist/ai-edits/types.d.ts

@@ -1,5 +1,10 @@
 //#region src/ai-edits/types.d.ts
 type FolioAIBlockKind = "heading" | "listItem" | "paragraph";
+type FolioAIInlineFormatting = Partial<Record<"bold" | "italic" | "underline" | "strike", boolean>> & {
+  fontFamily?: string | null;
+  fontSizePt?: number | null;
+  color?: string | null;
+};
 type FolioAIBlockPreviewRun = {
   text: string;
   bold?: boolean;
@@ -9,6 +14,7 @@ type FolioAIBlockPreviewRun = {
   fontFamily?: string;
   fontSizePt?: number;
   color?: string;
+  directFormatting?: FolioAIInlineFormatting;
 };
 /**
  * Where a block sits inside its innermost enclosing table. Every index is
@@ -165,12 +171,6 @@ type FolioDocumentNavigationTarget = {
   story: "main";
   blockId: string;
 } | FolioAITextRangeHandle;
-type FolioAIInlineFormatting = {
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  strike?: boolean;
-};
 /**
  * A party in an `insertSignatureTable` op. Mirrors the
  * `signatureTable` helper in `docx-core/legal-source/compile.ts`:
@@ -276,6 +276,13 @@ type FolioAIEditOperation = FolioAIEditReviewMeta & {
  * Delete the whole block. A block with words loses them and its paragraph
  * mark; a BLANK block has only a paragraph mark to lose, and loses it, so
  * the empty line goes away rather than the operation doing nothing.
+ *
+ * The block that ENDS its container is the exception, in both modes: a
+ * body, a cell, a header or footer, a note and a text box each end with a
+ * paragraph, and a deleted mark there would say "join with the paragraph
+ * after this one" where there is none. It loses its words and keeps its
+ * place. To remove it, delete the mark of the block BEFORE it, which
+ * merges forward into it.
  */
 {
   id: string;

package/dist/compare/__fixtures__/body-sequence.d.ts

@@ -13,6 +13,61 @@
  * gets written.
  */
 type CellContent = string | readonly BodyItem[];
+/** `w:tcPr` children a fixture can author, each named after the element. */
+type CellProperties = {
+  /** `w:gridSpan`: grid columns this cell occupies. */
+  gridSpan?: number;
+  /** `w:vMerge`: the cell starts a vertical merge, or continues one. */
+  verticalMerge?: "restart" | "continue";
+  /** `w:tcW` in twips. */
+  width?: number;
+  /** `w:shd` fill colour, as six hex digits. */
+  shadingFill?: string;
+  /** `w:vAlign`. */
+  verticalAlign?: "top" | "center" | "bottom";
+  /** `w:tcBorders`, single style on all four sides, in eighths of a point. */
+  borderSize?: number;
+  /** `w:tcMar`, the same margin on all four sides, in twips. */
+  margin?: number;
+};
+/** A cell: its content alone, or its content and its own `w:tcPr`. */
+type Cell = CellContent | ({
+  content: CellContent;
+} & CellProperties);
+/** A row: its cells alone, or its cells and its own `w:trPr`. */
+type TableRow = readonly Cell[] | {
+  cells: readonly Cell[];
+  /** `w:trHeight` in twips. */
+  height?: number;
+  /** `w:tblHeader`: the row repeats at the top of every page. */
+  header?: boolean;
+  /** `w:jc` on the row. */
+  justification?: "left" | "center" | "right";
+};
+/** `w:tblPr` children a fixture can author, each named after the element. */
+type TableProperties = {
+  /** `w:tblStyle`. */
+  styleId?: string;
+  /** `w:tblW`. */
+  width?: {
+    value: number;
+    type: "auto" | "dxa" | "pct";
+  };
+  /** `w:jc` on the table. */
+  justification?: "left" | "center" | "right";
+  /** `w:tblInd` in twips. */
+  indent?: number;
+  /** `w:tblBorders`, single style on every side, in eighths of a point. */
+  borderSize?: number;
+  /** `w:shd` fill colour on the table, as six hex digits. */
+  shadingFill?: string;
+  /** `w:tblLayout`. */
+  layout?: "fixed" | "autofit";
+  /** `w:tblCellMar`, the same margin on all four sides, in twips. */
+  cellMargin?: number;
+  /** `w:tblLook` value, as four hex digits. */
+  look?: string;
+};
 /**
  * One inline of a paragraph: plain text, or text carrying an external
  * hyperlink. A link is the case where a revision wrapper and the linked runs
@@ -35,7 +90,11 @@ type BodyItem = {
   paraId?: string;
 } | {
   kind: "table";
-  rows: readonly (readonly CellContent[])[];
+  rows: readonly TableRow[];
+  /** `w:tblPr` children, written in the order the schema requires. */
+  properties?: TableProperties;
+  /** `w:tblGrid` column widths, in twips. One per grid column. */
+  columnWidths?: readonly number[];
   /**
    * Rows a package hides with `w:hidden`. The snapshot skips their whole
    * subtree, so a document that has one is the case where the snapshot
@@ -53,4 +112,4 @@ type BodySequenceOptions = {
 };
 declare const buildBodySequenceDocx: (items: readonly BodyItem[], { header }?: BodySequenceOptions) => Promise<ArrayBuffer>;
 //#endregion
-export { BodyItem, BodySequenceOptions, CellContent, ParagraphInline, buildBodySequenceDocx };
+export { BodyItem, BodySequenceOptions, Cell, CellContent, CellProperties, ParagraphInline, TableProperties, TableRow, buildBodySequenceDocx };

package/dist/compare/__fixtures__/body-sequence.js

@@ -15,6 +15,8 @@ const WORDPROCESSING = "application/vnd.openxmlformats-officedocument.wordproces
 const MARKUP_COMPATIBILITY = "http://schemas.openxmlformats.org/markup-compatibility/2006";
 const PACKAGE_RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006";
 const CORE_PROPERTIES_TYPE = "application/vnd.openxmlformats-package.core-properties+xml";
+const EXTENDED_PROPERTIES = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties";
+const EXTENDED_PROPERTIES_TYPE = "application/vnd.openxmlformats-officedocument.extended-properties+xml";
 const WORDML_2010 = "http://schemas.microsoft.com/office/word/2010/wordml";
 /**
 * `createFolders: false` because JSZip stamps the folder entries it
@@ -24,6 +26,12 @@ const ZIP_ENTRY_OPTIONS = {
 	date: new Date(Date.UTC(2e3, 0, 1)),
 	createFolders: false
 };
+const isRowOptions = (row) => "cells" in row;
+const isCellSpec = (cell) => typeof cell === "object" && "content" in cell;
+const rowCells = (row) => isRowOptions(row) ? row.cells : row;
+const rowOptions = (row) => isRowOptions(row) ? row : {};
+const cellContent = (cell) => isCellSpec(cell) ? cell.content : cell;
+const cellProperties = (cell) => isCellSpec(cell) ? cell : {};
 /**
 * A paragraph's id is derived from its own content, not from its position.
 *
@@ -69,7 +77,10 @@ const collectHrefs = (items, hrefs) => {
 			for (const inline of item.text) if (typeof inline !== "string" && !hrefs.includes(inline.href)) hrefs.push(inline.href);
 			continue;
 		}
-		for (const row of item.rows) for (const cell of row) if (typeof cell !== "string") collectHrefs(cell, hrefs);
+		for (const row of item.rows) for (const cell of rowCells(row)) {
+			const content = cellContent(cell);
+			if (typeof content !== "string") collectHrefs(content, hrefs);
+		}
 	}
 };
 const EMPTY_PARAGRAPH = {
@@ -89,14 +100,90 @@ const closedSequence = (items) => {
 /** A cell must also contain a paragraph, which the empty sequence supplies. */
 const cellXml = (content, context) => typeof content === "string" ? paragraph(content, context) : itemsXml(closedSequence(content), context);
 /** `w:tbl` is `w:tblPr, w:tblGrid, rows`: a fixture without the grid is not one. */
-const tableGrid = (rows) => {
+const tableGrid = (item) => {
+	if (item.columnWidths) return `<w:tblGrid>${item.columnWidths.map((width) => `<w:gridCol w:w="${String(width)}"/>`).join("")}</w:tblGrid>`;
 	let columns = 0;
-	for (const cells of rows) columns = Math.max(columns, cells.length);
+	for (const row of item.rows) {
+		let spanned = 0;
+		for (const cell of rowCells(row)) spanned += cellProperties(cell).gridSpan ?? 1;
+		columns = Math.max(columns, spanned);
+	}
 	return `<w:tblGrid>${`<w:gridCol w:w="2000"/>`.repeat(columns)}</w:tblGrid>`;
 };
+const BORDER_SIDES = [
+	"top",
+	"left",
+	"bottom",
+	"right",
+	"insideH",
+	"insideV"
+];
+const CELL_BORDER_SIDES = [
+	"top",
+	"left",
+	"bottom",
+	"right"
+];
+const MARGIN_SIDES = [
+	"top",
+	"left",
+	"bottom",
+	"right"
+];
+const borders = (element, sides, size) => `<w:${element}>${sides.map((side) => `<w:${side} w:val="single" w:sz="${String(size)}" w:space="0" w:color="000000"/>`).join("")}</w:${element}>`;
+const margins = (element, value) => `<w:${element}>${MARGIN_SIDES.map((side) => `<w:${side} w:w="${String(value)}" w:type="dxa"/>`).join("")}</w:${element}>`;
+/**
+* `w:tblPr` children in the order CT_TblPrBase declares: tblStyle, tblW, jc,
+* tblInd, tblBorders, shd, tblLayout, tblCellMar, tblLook. `w:tblW` is always
+* written.
+*/
+const tableProperties = ({ properties }) => {
+	const width = properties?.width ?? {
+		value: 0,
+		type: "auto"
+	};
+	return `<w:tblPr>${[
+		...properties?.styleId === void 0 ? [] : [`<w:tblStyle w:val="${properties.styleId}"/>`],
+		`<w:tblW w:w="${String(width.value)}" w:type="${width.type}"/>`,
+		...properties?.justification === void 0 ? [] : [`<w:jc w:val="${properties.justification}"/>`],
+		...properties?.indent === void 0 ? [] : [`<w:tblInd w:w="${String(properties.indent)}" w:type="dxa"/>`],
+		...properties?.borderSize === void 0 ? [] : [borders("tblBorders", BORDER_SIDES, properties.borderSize)],
+		...properties?.shadingFill === void 0 ? [] : [`<w:shd w:val="clear" w:color="auto" w:fill="${properties.shadingFill}"/>`],
+		...properties?.layout === void 0 ? [] : [`<w:tblLayout w:type="${properties.layout}"/>`],
+		...properties?.cellMargin === void 0 ? [] : [margins("tblCellMar", properties.cellMargin)],
+		...properties?.look === void 0 ? [] : [`<w:tblLook w:val="${properties.look}"/>`]
+	].join("")}</w:tblPr>`;
+};
+/**
+* `w:trPr` children. `CT_TrPrBase` is a repeated choice rather than a
+* sequence, so the order here is the readable one rather than a required one.
+*/
+const rowProperties = (row, hidden) => {
+	const { header, height, justification } = rowOptions(row);
+	const parts = [
+		...height === void 0 ? [] : [`<w:trHeight w:val="${String(height)}"/>`],
+		...header === true ? ["<w:tblHeader/>"] : [],
+		...justification === void 0 ? [] : [`<w:jc w:val="${justification}"/>`],
+		...hidden ? ["<w:hidden/>"] : []
+	];
+	return parts.length === 0 ? "" : `<w:trPr>${parts.join("")}</w:trPr>`;
+};
+/** `w:tcPr` children in schema order; `w:tcW` is always written. */
+const cellPropertiesXml = (cell) => {
+	const properties = cellProperties(cell);
+	return `<w:tcPr>${[
+		`<w:tcW w:w="${String(properties.width ?? 2e3)}" w:type="dxa"/>`,
+		...properties.gridSpan === void 0 ? [] : [`<w:gridSpan w:val="${String(properties.gridSpan)}"/>`],
+		...properties.verticalMerge === void 0 ? [] : [properties.verticalMerge === "restart" ? `<w:vMerge w:val="restart"/>` : `<w:vMerge/>`],
+		...properties.borderSize === void 0 ? [] : [borders("tcBorders", CELL_BORDER_SIDES, properties.borderSize)],
+		...properties.shadingFill === void 0 ? [] : [`<w:shd w:val="clear" w:color="auto" w:fill="${properties.shadingFill}"/>`],
+		...properties.margin === void 0 ? [] : [margins("tcMar", properties.margin)],
+		...properties.verticalAlign === void 0 ? [] : [`<w:vAlign w:val="${properties.verticalAlign}"/>`]
+	].join("")}</w:tcPr>`;
+};
 const table = (item, context) => {
 	const hidden = new Set(item.hiddenRows ?? []);
-	return `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr>` + tableGrid(item.rows) + item.rows.map((cells, rowIndex) => `<w:tr>${hidden.has(rowIndex) ? `<w:trPr><w:hidden/></w:trPr>` : ""}${cells.map((content) => `<w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr>${cellXml(content, context)}</w:tc>`).join("")}</w:tr>`).join("") + `</w:tbl>`;
+	return `<w:tbl>${tableProperties(item)}` + tableGrid(item) + item.rows.map((row, rowIndex) => `<w:tr>${rowProperties(row, hidden.has(rowIndex))}${rowCells(row).map((cell) => `<w:tc>${cellPropertiesXml(cell)}${cellXml(cellContent(cell), context)}</w:tc>`).join("")}</w:tr>`).join("") + `</w:tbl>`;
 };
 const itemsXml = (items, context) => items.map((item) => item.kind === "paragraph" ? paragraph(item.text, context, {
 	...item.styleId === void 0 ? {} : { styleId: item.styleId },
@@ -114,9 +201,10 @@ const buildBodySequenceDocx = async (items, { header } = {}) => {
 	const linkRelationships = hrefs.map((href, index) => `<Relationship Id="rId${index + firstLinkRelationship}" Type="${OFFICE_RELATIONSHIPS}/hyperlink" Target="${href}" TargetMode="External"/>`).join("");
 	const paraId = createParaIdAllocator();
 	const parts = {
-		"[Content_Types].xml": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="${WORDPROCESSING}.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="${WORDPROCESSING}.styles+xml"/>` + (header ? `<Override PartName="/word/header1.xml" ContentType="${WORDPROCESSING}.header+xml"/>` : "") + `<Override PartName="/docProps/core.xml" ContentType="${CORE_PROPERTIES_TYPE}"/></Types>`,
-		"_rels/.rels": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS}"><Relationship Id="rId1" Type="${OFFICE_RELATIONSHIPS}/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="${PACKAGE_RELATIONSHIPS}/metadata/core-properties" Target="docProps/core.xml"/></Relationships>`,
+		"[Content_Types].xml": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="${WORDPROCESSING}.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="${WORDPROCESSING}.styles+xml"/>` + (header ? `<Override PartName="/word/header1.xml" ContentType="${WORDPROCESSING}.header+xml"/>` : "") + `<Override PartName="/docProps/core.xml" ContentType="${CORE_PROPERTIES_TYPE}"/><Override PartName="/docProps/app.xml" ContentType="${EXTENDED_PROPERTIES_TYPE}"/></Types>`,
+		"_rels/.rels": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS}"><Relationship Id="rId1" Type="${OFFICE_RELATIONSHIPS}/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="${PACKAGE_RELATIONSHIPS}/metadata/core-properties" Target="docProps/core.xml"/><Relationship Id="rId3" Type="${OFFICE_RELATIONSHIPS}/extended-properties" Target="docProps/app.xml"/></Relationships>`,
 		"docProps/core.xml": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cp:coreProperties xmlns:cp="${PACKAGE_RELATIONSHIPS}/metadata/core-properties" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dcterms:created xsi:type="dcterms:W3CDTF">2000-01-01T00:00:00Z</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">2000-01-01T00:00:00Z</dcterms:modified></cp:coreProperties>`,
+		"docProps/app.xml": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Properties xmlns="${EXTENDED_PROPERTIES}"><AppVersion>1.0.0</AppVersion></Properties>`,
 		"word/_rels/document.xml.rels": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="${RELATIONSHIPS}"><Relationship Id="rId1" Type="${OFFICE_RELATIONSHIPS}/styles" Target="styles.xml"/>` + (header ? `<Relationship Id="${HEADER_RELATIONSHIP_ID}" Type="${OFFICE_RELATIONSHIPS}/header" Target="header1.xml"/>` : "") + linkRelationships + `</Relationships>`,
 		"word/styles.xml": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:styles xmlns:w="${NAMESPACE}"><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style><w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/></w:style></w:styles>`,
 		"word/document.xml": `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="${NAMESPACE}" xmlns:r="${OFFICE_RELATIONSHIPS}" xmlns:mc="${MARKUP_COMPATIBILITY}" xmlns:w14="${WORDML_2010}" mc:Ignorable="w14"><w:body>` + bodyXml(items, {

package/dist/compare/compare.d.ts

@@ -51,25 +51,32 @@ type PlannedStoryComparison = {
  * parsing, no serialization, no clock.
  */
 declare const planComparison: ({ pairs }: ParsedComparison) => Result<readonly PlannedStoryComparison[], CompareDocxOperationLimitError>;
-/** What stage 3 produced: the change list, and whether it was proven. */
+/** What stage 3 produced: the change list, whether it was proven, and whether it wrote anything. */
 type AppliedComparison = {
   changes: readonly CompareChange[];
   verification: CompareVerification;
+  /**
+   * Whether the stage wrote into the base document at all. A comparison that
+   * found nothing writes nothing, and the serialize stage then hands the
+   * arriving bytes back rather than reproducing them.
+   */
+  documentChanged: boolean;
 };
 /**
  * Stage 3: write the planned operations into the base document as tracked
  * changes, then check the work rather than trust it. Both directions of the
- * round trip are checked, structure included: accepting the story's generated
- * revisions must reproduce the target, and rejecting them must reproduce the
- * base it was compared from. A difference the operation vocabulary cannot
- * express would otherwise leave a redline that reads plausibly and is wrong.
+ * round trip are checked, structure and table geometry included: accepting the
+ * story's generated revisions must reproduce the target, and rejecting them
+ * must reproduce the base it was compared from. A difference the operation
+ * vocabulary cannot express would otherwise leave a redline that reads
+ * plausibly and is wrong.
  *
  * The check reports rather than throws. {@link compareDocx} decides what to do
  * with an unverified result, because "give me your best attempt and tell me
  * what you could not represent" and "give me nothing unless you can prove it"
  * are both legitimate asks and only the caller knows which one it is making.
  */
-declare const applyComparison: ({ reviewer, revisionStamp, granularity, numberingChanges }: ParsedComparison, planned: readonly PlannedStoryComparison[]) => Result<AppliedComparison, CompareDocxApplyError>;
+declare const applyComparison: ({ reviewer, targetReviewer, revisionStamp, granularity, numberingChanges }: ParsedComparison, planned: readonly PlannedStoryComparison[]) => Result<AppliedComparison, CompareDocxApplyError>;
 /**
  * Stage 4: the result package, with every ZIP entry date pinned.
  *
@@ -89,7 +96,7 @@ declare const applyComparison: ({ reviewer, revisionStamp, granularity, numberin
  * composition let the benchmark's own composition disagree with the shipped
  * one within a single run.
  */
-declare const serializeComparison: ({ baseBuffer, baseCarriedRevisions, reviewer, packageDate }: ParsedComparison, planned: readonly PlannedStoryComparison[]) => Promise<Result<ArrayBuffer, CompareDocxSerializeError | CompareDocxFinalParagraphMarkError>>;
+declare const serializeComparison: ({ baseBuffer, baseCarriedRevisions, reviewer, packageDate, revisionStamp }: ParsedComparison, { documentChanged }: AppliedComparison) => Promise<Result<ArrayBuffer, CompareDocxSerializeError | CompareDocxFinalParagraphMarkError>>;
 /**
  * Compare `base` against `target` and return `base` carrying the tracked
  * changes that turn it into `target`, alongside the change list describing