document-schema 7.12.0 → 7.14.0

package/dist/package-node.d.cts

@@ -1,2 +1,2 @@
-import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-DMS4Zrfi.cjs";
+import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-C1HxQdNK.cjs";
 export { DrawPageChild, DrawPageDescriptor, DrawPageDescriptorSchema, DrawPageGroupNode, DrawPageGroupSchema, HeadingGroupNode, HeadingGroupSchema, HeadingParagraph, HeadingParagraphSchema, ListChild, ListGroupNode, ListGroupSchema, ListParagraph, ListParagraphSchema, SectionChild, SectionConstructGroupNode, SectionConstructGroupSchema, SectionDescriptor, SectionDescriptorSchema, SectionGroupNode, SectionGroupSchema, ShapeChild, ShapeConstructGroupNode, ShapeConstructGroupSchema, ShapeDescriptor, ShapeDescriptorSchema, ShapeGroupNode, ShapeGroupSchema, SheetChild, SheetDescriptor, SheetDescriptorSchema, SheetGroupNode, SheetGroupSchema, SlideDescriptor, SlideDescriptorSchema, SlideGroupNode, SlideGroupSchema, TreeBlockLeaf, TreeBlockLeafSchema, TreeGroup, TreeGroupSchema, TreeLeaf, TreeLeafSchema, TreeNode, TreeNodeSchema, isDrawPageGroupNode, isHeadingGroupNode, isListGroupNode, isSectionConstructGroupNode, isSectionGroupNode, isShapeConstructGroupNode, isShapeGroupNode, isSheetGroupNode, isSlideGroupNode, isTreeBlockLeaf, isTreeGroup, isTreeLeaf, isTreeNode };

package/dist/package-node.d.ts

@@ -1,2 +1,2 @@
-import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-CjEahULr.js";
+import { $ as isSheetGroupNode, A as SheetDescriptor, B as TreeGroup, C as ShapeConstructGroupNode, D as ShapeGroupNode, E as ShapeDescriptorSchema, F as SlideDescriptorSchema, G as TreeNodeSchema, H as TreeLeaf, I as SlideGroupNode, J as isListGroupNode, K as isDrawPageGroupNode, L as SlideGroupSchema, M as SheetGroupNode, N as SheetGroupSchema, O as ShapeGroupSchema, P as SlideDescriptor, Q as isShapeGroupNode, R as TreeBlockLeaf, S as ShapeChild, T as ShapeDescriptor, U as TreeLeafSchema, V as TreeGroupSchema, W as TreeNode, X as isSectionGroupNode, Y as isSectionConstructGroupNode, Z as isShapeConstructGroupNode, _ as SectionConstructGroupSchema, a as DrawPageGroupSchema, b as SectionGroupNode, c as HeadingParagraph, d as ListGroupNode, et as isSlideGroupNode, f as ListGroupSchema, g as SectionConstructGroupNode, h as SectionChild, i as DrawPageGroupNode, it as isTreeNode, j as SheetDescriptorSchema, k as SheetChild, l as HeadingParagraphSchema, m as ListParagraphSchema, n as DrawPageDescriptor, nt as isTreeGroup, o as HeadingGroupNode, p as ListParagraph, q as isHeadingGroupNode, r as DrawPageDescriptorSchema, rt as isTreeLeaf, s as HeadingGroupSchema, t as DrawPageChild, tt as isTreeBlockLeaf, u as ListChild, v as SectionDescriptor, w as ShapeConstructGroupSchema, x as SectionGroupSchema, y as SectionDescriptorSchema, z as TreeBlockLeafSchema } from "./package-node-DdotoNEU.js";
 export { DrawPageChild, DrawPageDescriptor, DrawPageDescriptorSchema, DrawPageGroupNode, DrawPageGroupSchema, HeadingGroupNode, HeadingGroupSchema, HeadingParagraph, HeadingParagraphSchema, ListChild, ListGroupNode, ListGroupSchema, ListParagraph, ListParagraphSchema, SectionChild, SectionConstructGroupNode, SectionConstructGroupSchema, SectionDescriptor, SectionDescriptorSchema, SectionGroupNode, SectionGroupSchema, ShapeChild, ShapeConstructGroupNode, ShapeConstructGroupSchema, ShapeDescriptor, ShapeDescriptorSchema, ShapeGroupNode, ShapeGroupSchema, SheetChild, SheetDescriptor, SheetDescriptorSchema, SheetGroupNode, SheetGroupSchema, SlideDescriptor, SlideDescriptorSchema, SlideGroupNode, SlideGroupSchema, TreeBlockLeaf, TreeBlockLeafSchema, TreeGroup, TreeGroupSchema, TreeLeaf, TreeLeafSchema, TreeNode, TreeNodeSchema, isDrawPageGroupNode, isHeadingGroupNode, isListGroupNode, isSectionConstructGroupNode, isSectionGroupNode, isShapeConstructGroupNode, isShapeGroupNode, isSheetGroupNode, isSlideGroupNode, isTreeBlockLeaf, isTreeGroup, isTreeLeaf, isTreeNode };

package/dist/package.d.cts

@@ -1,6 +1,6 @@
 import { d as MathMlNode } from "./mathml-Czqc1mdZ.cjs";
 import { p as MathExpression } from "./math-BScHxedi.cjs";
-import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-DMS4Zrfi.cjs";
+import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-C1HxQdNK.cjs";
 import { z } from "zod";
 //#region src/package.d.ts
 declare const TreeEmbeddedFontSchema: z.ZodObject<{
@@ -638,12 +638,12 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
   children: z.ZodArray<z.ZodObject<{
     origin: z.ZodOptional<z.ZodEnum<{
-      body: "body";
       chart: "chart";
       diagram: "diagram";
       table: "table";
       image: "image";
       notes: "notes";
+      body: "body";
     }>>;
     interpretation: z.ZodOptional<z.ZodObject<{
       transcript: z.ZodOptional<z.ZodObject<{

package/dist/package.d.ts

@@ -1,6 +1,6 @@
 import { d as MathMlNode } from "./mathml-Czqc1mdZ.js";
 import { p as MathExpression } from "./math-BScHxedi.js";
-import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-CjEahULr.js";
+import { I as SlideGroupNode, M as SheetGroupNode, b as SectionGroupNode, i as DrawPageGroupNode } from "./package-node-DdotoNEU.js";
 import { z } from "zod";
 //#region src/package.d.ts
 declare const TreeEmbeddedFontSchema: z.ZodObject<{
@@ -638,12 +638,12 @@ declare const DocumentTreeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
   children: z.ZodArray<z.ZodObject<{
     origin: z.ZodOptional<z.ZodEnum<{
-      body: "body";
       chart: "chart";
       diagram: "diagram";
       table: "table";
       image: "image";
       notes: "notes";
+      body: "body";
     }>>;
     interpretation: z.ZodOptional<z.ZodObject<{
       transcript: z.ZodOptional<z.ZodObject<{

package/dist/schema-io.cjs

@@ -7,7 +7,7 @@ const SCHEMA_FILE_NAMES = {
 	ContentDocument: "content-document.schema.json"
 };
 function schemaUriFor(kind) {
-	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/${SCHEMA_FILE_NAMES[kind]}`;
+	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/${SCHEMA_FILE_NAMES[kind]}`;
 }
 const SCHEMA_URI_PATTERN = /^https:\/\/cdn\.jsdelivr\.net\/npm\/document-schema\.js@([^/]+)\/schemas\/(document-tree|document-package|content-document|layout-document)\.schema\.json$/;
 function parseSchemaUri(uri) {
@@ -102,7 +102,7 @@ function documentFromJson(value) {
 	if (parts.stem === "document-package") throw new DocumentPackageRenamedError(value.$schema);
 	const kind = kindForFileStem(parts.stem);
 	if (kind === void 0) throw new UnrecognizedDocumentSchemaError(value.$schema);
-	if (majorVersionOf(parts.version) !== majorVersionOf("7.12.0")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.12.0");
+	if (majorVersionOf(parts.version) !== majorVersionOf("7.14.0")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.14.0");
 	switch (kind) {
 		case "DocumentTree": return {
 			kind,

package/dist/schema-io.d.cts

@@ -1,4 +1,4 @@
-import { C as ContentDocument } from "./content-DnNAXdH_.cjs";
+import { C as ContentDocument } from "./content-BNUhgRbB.cjs";
 import { DocumentTree } from "./package.cjs";
 //#region src/schema-io.d.ts
 type DocumentSchemaKind = "DocumentTree" | "ContentDocument";

package/dist/schema-io.d.ts

@@ -1,4 +1,4 @@
-import { C as ContentDocument } from "./content-vx3Mbnjy.js";
+import { C as ContentDocument } from "./content-CYPkduUB.js";
 import { DocumentTree } from "./package.js";
 //#region src/schema-io.d.ts
 type DocumentSchemaKind = "DocumentTree" | "ContentDocument";

package/dist/schema-io.js

@@ -6,7 +6,7 @@ const SCHEMA_FILE_NAMES = {
 	ContentDocument: "content-document.schema.json"
 };
 function schemaUriFor(kind) {
-	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/${SCHEMA_FILE_NAMES[kind]}`;
+	return `https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/${SCHEMA_FILE_NAMES[kind]}`;
 }
 const SCHEMA_URI_PATTERN = /^https:\/\/cdn\.jsdelivr\.net\/npm\/document-schema\.js@([^/]+)\/schemas\/(document-tree|document-package|content-document|layout-document)\.schema\.json$/;
 function parseSchemaUri(uri) {
@@ -101,7 +101,7 @@ function documentFromJson(value) {
 	if (parts.stem === "document-package") throw new DocumentPackageRenamedError(value.$schema);
 	const kind = kindForFileStem(parts.stem);
 	if (kind === void 0) throw new UnrecognizedDocumentSchemaError(value.$schema);
-	if (majorVersionOf(parts.version) !== majorVersionOf("7.12.0")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.12.0");
+	if (majorVersionOf(parts.version) !== majorVersionOf("7.14.0")) throw new SchemaVersionMismatchError(value.$schema, parts.version, "7.14.0");
 	switch (kind) {
 		case "DocumentTree": return {
 			kind,

package/dist/table-grid.cjs

@@ -48,6 +48,89 @@ function walkTableGrid(table) {
 		};
 	}));
 }
+/** The span of a cell that occupies its own grid position only, which is what an absent `colSpan` or `rowSpan` means. */
+const UNMERGED_SPAN = 1;
+function widestRowLength(table) {
+	let width = 0;
+	for (const row of table.rows) width = Math.max(width, row.cells.length);
+	return width;
+}
+function coveredFault(position) {
+	const { rowIndex, columnIndex, anchorRowIndex, anchorColumnIndex, cell } = position;
+	if (cell.blocks.length > 0) return {
+		kind: "coveredContent",
+		rowIndex,
+		columnIndex,
+		anchorRowIndex,
+		anchorColumnIndex
+	};
+	if (tableCellColumnSpan(cell) > UNMERGED_SPAN || tableCellRowSpan(cell) > UNMERGED_SPAN) return {
+		kind: "coveredSpan",
+		rowIndex,
+		columnIndex,
+		anchorRowIndex,
+		anchorColumnIndex
+	};
+}
+function overlappedRegion(anchor, row) {
+	const footprintEnd = anchor.columnIndex + tableCellColumnSpan(anchor.cell);
+	for (const position of row.slice(anchor.columnIndex + 1, footprintEnd)) if (position.anchorRowIndex !== void 0 && position.anchorRowIndex < anchor.rowIndex) return position;
+}
+function anchorFault(anchor, row, rowCount) {
+	const { rowIndex, columnIndex, cell } = anchor;
+	if (columnIndex + tableCellColumnSpan(cell) > row.length) return {
+		kind: "anchorOverrunsColumns",
+		rowIndex,
+		columnIndex
+	};
+	if (rowIndex + tableCellRowSpan(cell) > rowCount) return {
+		kind: "anchorOverrunsRows",
+		rowIndex,
+		columnIndex
+	};
+	const overlapped = overlappedRegion(anchor, row);
+	if (overlapped !== void 0) return {
+		kind: "overlappingAnchors",
+		rowIndex,
+		columnIndex,
+		earlierAnchorRowIndex: overlapped.anchorRowIndex,
+		earlierAnchorColumnIndex: overlapped.anchorColumnIndex
+	};
+}
+/**
+* The first place `table` contradicts the grid rule, or `undefined` when it obeys it. It never throws: a caller decides what a fault means for it, the way findConstructMarkerImbalance leaves that decision to each consumer of a block list.
+*
+* Rows are compared with each other before any position is classified, since an anchor's footprint can only be measured against a grid every row shares; the positions are then checked in row-major order, so the fault returned is the earliest one in reading order.
+*
+* The check states the whole of the rule and nothing beyond it: a table with no rows, or whose rows are all empty, has no fault, and neither `columnWidthsPt` nor a cell's own properties other than its blocks and spans are consulted.
+*/
+function findTableGridFault(table) {
+	const gridColumnCount = widestRowLength(table);
+	for (const [rowIndex, row] of table.rows.entries()) if (row.cells.length !== gridColumnCount) return {
+		kind: "raggedRow",
+		rowIndex,
+		cellCount: row.cells.length,
+		gridColumnCount
+	};
+	const grid = walkTableGrid(table);
+	for (const row of grid) for (const position of row) {
+		const fault = position.anchorRowIndex === void 0 ? anchorFault(position, row, grid.length) : coveredFault(position);
+		if (fault !== void 0) return fault;
+	}
+}
+/**
+* One sentence stating a fault in words, for a writer that refuses or reports a table the grid rule does not admit: it names the fault by its position and, where the fault involves a second region, by that region's anchor. Indices are 0-based, matching every index in the descriptor. The sentence carries no entry point or format of its own, so each caller prefixes whatever names its own operation.
+*/
+function describeTableGridFault(fault) {
+	switch (fault.kind) {
+		case "raggedRow": return `row ${String(fault.rowIndex)} holds ${String(fault.cellCount)} cells where the widest row holds ${String(fault.gridColumnCount)}, but every row of a table covers the same grid`;
+		case "coveredContent": return `the cell at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} lies inside the merged region anchored at row ${String(fault.anchorRowIndex)}, column ${String(fault.anchorColumnIndex)} but carries content of its own, and a merged region's content belongs to its anchor`;
+		case "coveredSpan": return `the cell at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} lies inside the merged region anchored at row ${String(fault.anchorRowIndex)}, column ${String(fault.anchorColumnIndex)} but states a span of its own, and only a region's anchor carries a span`;
+		case "anchorOverrunsColumns": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} spans past the last column of the grid`;
+		case "anchorOverrunsRows": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} spans past the last row of the table`;
+		case "overlappingAnchors": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} overlaps the region anchored at row ${String(fault.earlierAnchorRowIndex)}, column ${String(fault.earlierAnchorColumnIndex)}, but a grid position belongs to one region only`;
+	}
+}
 function placedGridWidth(rows, columnCount) {
 	let width = columnCount;
 	for (const row of rows) for (const { columnIndex, cell } of row.cells) width = Math.max(width, columnIndex + tableCellColumnSpan(cell));
@@ -112,6 +195,8 @@ function placeAnchorTableRows(rows, columnCount) {
 }
 //#endregion
 exports.denseTableRows = denseTableRows;
+exports.describeTableGridFault = describeTableGridFault;
+exports.findTableGridFault = findTableGridFault;
 exports.placeAnchorTableRows = placeAnchorTableRows;
 exports.tableCellColumnSpan = tableCellColumnSpan;
 exports.tableCellRowSpan = tableCellRowSpan;

package/dist/table-grid.d.cts

@@ -1,5 +1,5 @@
 import { o as TextDirection } from "./style-D06NwxAJ.cjs";
-import { _n as ContentTableRow, hn as ContentTableCell, mn as ContentTable } from "./content-DnNAXdH_.cjs";
+import { _n as ContentTableRow, hn as ContentTableCell, mn as ContentTable } from "./content-BNUhgRbB.cjs";
 //#region src/table-grid.d.ts
 /** The number of grid columns a cell occupies; an absent `colSpan` means the cell occupies its own column only. */
 declare function tableCellColumnSpan(cell: ContentTableCell): number;
@@ -33,6 +33,52 @@ type TableGridPosition = TableGridAnchor | TableGridCovered;
  * This is the walk a consumer runs instead of accumulating spans itself. A writer targeting a format that stores only anchors (HTML's `<td colspan>`, a docx `w:tc` with `w:gridSpan`) keeps the anchors and drops the covered positions; a writer targeting a format that stores covered positions explicitly (ODF, pptx) writes both; a reader checks its own output against it.
  */
 declare function walkTableGrid(table: ContentTable): TableGridPosition[][];
+/**
+ * Where a table stops obeying the grid rule (ContentTableCell in src/content.ts states the rule; walkTableGrid derives the classification every check here is made against). Every variant names a position in the table's own row and column indices.
+ *
+ * - `raggedRow`: the row holds `cellCount` entries where the table's widest row holds `gridColumnCount`, so the rows do not all cover the same grid.
+ * - `coveredContent`: the position is covered by the region anchored at `anchorRowIndex`, `anchorColumnIndex` yet carries blocks of its own; the region's content belongs to its anchor, so a second copy has nowhere to go.
+ * - `coveredSpan`: the position is covered by the region anchored at `anchorRowIndex`, `anchorColumnIndex` yet carries a `colSpan` or `rowSpan` of its own. Spans are set on the anchor only and walkTableGrid never consults a covered entry's, so this is how a second anchor starting inside another's footprint shows up: the walk assigns each position to the first anchor covering it, which leaves the second entry classified as covered and its span ignored.
+ * - `anchorOverrunsColumns`: the anchor at this position has a `colSpan` reaching past the last grid column.
+ * - `anchorOverrunsRows`: the anchor at this position has a `rowSpan` reaching past the last row of the table.
+ * - `overlappingAnchors`: the anchor at this position starts outside every other region but its footprint reaches a position already covered by the region anchored at `earlierAnchorRowIndex`, `earlierAnchorColumnIndex`, so two regions claim one position.
+ *
+ * A `kind` tag discriminates rather than property presence, because the variants' required fields are not mutually exclusive: several variants' fields include another's.
+ */
+type TableGridFault = {
+  readonly kind: "raggedRow";
+  readonly rowIndex: number;
+  readonly cellCount: number;
+  readonly gridColumnCount: number;
+} | {
+  readonly kind: "coveredContent" | "coveredSpan";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly anchorRowIndex: number;
+  readonly anchorColumnIndex: number;
+} | {
+  readonly kind: "anchorOverrunsColumns" | "anchorOverrunsRows";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+} | {
+  readonly kind: "overlappingAnchors";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly earlierAnchorRowIndex: number;
+  readonly earlierAnchorColumnIndex: number;
+};
+/**
+ * The first place `table` contradicts the grid rule, or `undefined` when it obeys it. It never throws: a caller decides what a fault means for it, the way findConstructMarkerImbalance leaves that decision to each consumer of a block list.
+ *
+ * Rows are compared with each other before any position is classified, since an anchor's footprint can only be measured against a grid every row shares; the positions are then checked in row-major order, so the fault returned is the earliest one in reading order.
+ *
+ * The check states the whole of the rule and nothing beyond it: a table with no rows, or whose rows are all empty, has no fault, and neither `columnWidthsPt` nor a cell's own properties other than its blocks and spans are consulted.
+ */
+declare function findTableGridFault(table: ContentTable): TableGridFault | undefined;
+/**
+ * One sentence stating a fault in words, for a writer that refuses or reports a table the grid rule does not admit: it names the fault by its position and, where the fault involves a second region, by that region's anchor. Indices are 0-based, matching every index in the descriptor. The sentence carries no entry point or format of its own, so each caller prefixes whatever names its own operation.
+ */
+declare function describeTableGridFault(fault: TableGridFault): string;
 /** A cell together with the grid column it starts at, for a reader whose source format states that column directly. */
 interface PositionedTableCell {
   readonly columnIndex: number;
@@ -43,6 +89,7 @@ interface PositionedTableRow {
   readonly cells: readonly PositionedTableCell[];
   readonly heightPt?: number;
   readonly direction?: TextDirection;
+  readonly isHeader?: boolean;
 }
 /**
  * Build dense rows from cells a reader has already positioned, filling every position no cell was placed at with an empty covered cell.
@@ -55,6 +102,7 @@ interface AnchorTableRow {
   readonly cells: readonly ContentTableCell[];
   readonly heightPt?: number;
   readonly direction?: TextDirection;
+  readonly isHeader?: boolean;
 }
 /**
  * Build dense rows from anchor cells alone, placing each at the first grid column no earlier cell already reaches -- the placement HTML's own table model needs, where a `rowspan` in one row silently consumes a column in the rows below it and nothing marks the consumed position.
@@ -63,4 +111,4 @@ interface AnchorTableRow {
  */
 declare function placeAnchorTableRows(rows: readonly AnchorTableRow[], columnCount: number): ContentTableRow[];
 //#endregion
-export { AnchorTableRow, PositionedTableCell, PositionedTableRow, TableGridAnchor, TableGridCovered, TableGridPosition, denseTableRows, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };
+export { AnchorTableRow, PositionedTableCell, PositionedTableRow, TableGridAnchor, TableGridCovered, TableGridFault, TableGridPosition, denseTableRows, describeTableGridFault, findTableGridFault, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };

package/dist/table-grid.d.ts

@@ -1,5 +1,5 @@
 import { o as TextDirection } from "./style-D06NwxAJ.js";
-import { _n as ContentTableRow, hn as ContentTableCell, mn as ContentTable } from "./content-vx3Mbnjy.js";
+import { _n as ContentTableRow, hn as ContentTableCell, mn as ContentTable } from "./content-CYPkduUB.js";
 //#region src/table-grid.d.ts
 /** The number of grid columns a cell occupies; an absent `colSpan` means the cell occupies its own column only. */
 declare function tableCellColumnSpan(cell: ContentTableCell): number;
@@ -33,6 +33,52 @@ type TableGridPosition = TableGridAnchor | TableGridCovered;
  * This is the walk a consumer runs instead of accumulating spans itself. A writer targeting a format that stores only anchors (HTML's `<td colspan>`, a docx `w:tc` with `w:gridSpan`) keeps the anchors and drops the covered positions; a writer targeting a format that stores covered positions explicitly (ODF, pptx) writes both; a reader checks its own output against it.
  */
 declare function walkTableGrid(table: ContentTable): TableGridPosition[][];
+/**
+ * Where a table stops obeying the grid rule (ContentTableCell in src/content.ts states the rule; walkTableGrid derives the classification every check here is made against). Every variant names a position in the table's own row and column indices.
+ *
+ * - `raggedRow`: the row holds `cellCount` entries where the table's widest row holds `gridColumnCount`, so the rows do not all cover the same grid.
+ * - `coveredContent`: the position is covered by the region anchored at `anchorRowIndex`, `anchorColumnIndex` yet carries blocks of its own; the region's content belongs to its anchor, so a second copy has nowhere to go.
+ * - `coveredSpan`: the position is covered by the region anchored at `anchorRowIndex`, `anchorColumnIndex` yet carries a `colSpan` or `rowSpan` of its own. Spans are set on the anchor only and walkTableGrid never consults a covered entry's, so this is how a second anchor starting inside another's footprint shows up: the walk assigns each position to the first anchor covering it, which leaves the second entry classified as covered and its span ignored.
+ * - `anchorOverrunsColumns`: the anchor at this position has a `colSpan` reaching past the last grid column.
+ * - `anchorOverrunsRows`: the anchor at this position has a `rowSpan` reaching past the last row of the table.
+ * - `overlappingAnchors`: the anchor at this position starts outside every other region but its footprint reaches a position already covered by the region anchored at `earlierAnchorRowIndex`, `earlierAnchorColumnIndex`, so two regions claim one position.
+ *
+ * A `kind` tag discriminates rather than property presence, because the variants' required fields are not mutually exclusive: several variants' fields include another's.
+ */
+type TableGridFault = {
+  readonly kind: "raggedRow";
+  readonly rowIndex: number;
+  readonly cellCount: number;
+  readonly gridColumnCount: number;
+} | {
+  readonly kind: "coveredContent" | "coveredSpan";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly anchorRowIndex: number;
+  readonly anchorColumnIndex: number;
+} | {
+  readonly kind: "anchorOverrunsColumns" | "anchorOverrunsRows";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+} | {
+  readonly kind: "overlappingAnchors";
+  readonly rowIndex: number;
+  readonly columnIndex: number;
+  readonly earlierAnchorRowIndex: number;
+  readonly earlierAnchorColumnIndex: number;
+};
+/**
+ * The first place `table` contradicts the grid rule, or `undefined` when it obeys it. It never throws: a caller decides what a fault means for it, the way findConstructMarkerImbalance leaves that decision to each consumer of a block list.
+ *
+ * Rows are compared with each other before any position is classified, since an anchor's footprint can only be measured against a grid every row shares; the positions are then checked in row-major order, so the fault returned is the earliest one in reading order.
+ *
+ * The check states the whole of the rule and nothing beyond it: a table with no rows, or whose rows are all empty, has no fault, and neither `columnWidthsPt` nor a cell's own properties other than its blocks and spans are consulted.
+ */
+declare function findTableGridFault(table: ContentTable): TableGridFault | undefined;
+/**
+ * One sentence stating a fault in words, for a writer that refuses or reports a table the grid rule does not admit: it names the fault by its position and, where the fault involves a second region, by that region's anchor. Indices are 0-based, matching every index in the descriptor. The sentence carries no entry point or format of its own, so each caller prefixes whatever names its own operation.
+ */
+declare function describeTableGridFault(fault: TableGridFault): string;
 /** A cell together with the grid column it starts at, for a reader whose source format states that column directly. */
 interface PositionedTableCell {
   readonly columnIndex: number;
@@ -43,6 +89,7 @@ interface PositionedTableRow {
   readonly cells: readonly PositionedTableCell[];
   readonly heightPt?: number;
   readonly direction?: TextDirection;
+  readonly isHeader?: boolean;
 }
 /**
  * Build dense rows from cells a reader has already positioned, filling every position no cell was placed at with an empty covered cell.
@@ -55,6 +102,7 @@ interface AnchorTableRow {
   readonly cells: readonly ContentTableCell[];
   readonly heightPt?: number;
   readonly direction?: TextDirection;
+  readonly isHeader?: boolean;
 }
 /**
  * Build dense rows from anchor cells alone, placing each at the first grid column no earlier cell already reaches -- the placement HTML's own table model needs, where a `rowspan` in one row silently consumes a column in the rows below it and nothing marks the consumed position.
@@ -63,4 +111,4 @@ interface AnchorTableRow {
  */
 declare function placeAnchorTableRows(rows: readonly AnchorTableRow[], columnCount: number): ContentTableRow[];
 //#endregion
-export { AnchorTableRow, PositionedTableCell, PositionedTableRow, TableGridAnchor, TableGridCovered, TableGridPosition, denseTableRows, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };
+export { AnchorTableRow, PositionedTableCell, PositionedTableRow, TableGridAnchor, TableGridCovered, TableGridFault, TableGridPosition, denseTableRows, describeTableGridFault, findTableGridFault, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };

package/dist/table-grid.js

@@ -47,6 +47,89 @@ function walkTableGrid(table) {
 		};
 	}));
 }
+/** The span of a cell that occupies its own grid position only, which is what an absent `colSpan` or `rowSpan` means. */
+const UNMERGED_SPAN = 1;
+function widestRowLength(table) {
+	let width = 0;
+	for (const row of table.rows) width = Math.max(width, row.cells.length);
+	return width;
+}
+function coveredFault(position) {
+	const { rowIndex, columnIndex, anchorRowIndex, anchorColumnIndex, cell } = position;
+	if (cell.blocks.length > 0) return {
+		kind: "coveredContent",
+		rowIndex,
+		columnIndex,
+		anchorRowIndex,
+		anchorColumnIndex
+	};
+	if (tableCellColumnSpan(cell) > UNMERGED_SPAN || tableCellRowSpan(cell) > UNMERGED_SPAN) return {
+		kind: "coveredSpan",
+		rowIndex,
+		columnIndex,
+		anchorRowIndex,
+		anchorColumnIndex
+	};
+}
+function overlappedRegion(anchor, row) {
+	const footprintEnd = anchor.columnIndex + tableCellColumnSpan(anchor.cell);
+	for (const position of row.slice(anchor.columnIndex + 1, footprintEnd)) if (position.anchorRowIndex !== void 0 && position.anchorRowIndex < anchor.rowIndex) return position;
+}
+function anchorFault(anchor, row, rowCount) {
+	const { rowIndex, columnIndex, cell } = anchor;
+	if (columnIndex + tableCellColumnSpan(cell) > row.length) return {
+		kind: "anchorOverrunsColumns",
+		rowIndex,
+		columnIndex
+	};
+	if (rowIndex + tableCellRowSpan(cell) > rowCount) return {
+		kind: "anchorOverrunsRows",
+		rowIndex,
+		columnIndex
+	};
+	const overlapped = overlappedRegion(anchor, row);
+	if (overlapped !== void 0) return {
+		kind: "overlappingAnchors",
+		rowIndex,
+		columnIndex,
+		earlierAnchorRowIndex: overlapped.anchorRowIndex,
+		earlierAnchorColumnIndex: overlapped.anchorColumnIndex
+	};
+}
+/**
+* The first place `table` contradicts the grid rule, or `undefined` when it obeys it. It never throws: a caller decides what a fault means for it, the way findConstructMarkerImbalance leaves that decision to each consumer of a block list.
+*
+* Rows are compared with each other before any position is classified, since an anchor's footprint can only be measured against a grid every row shares; the positions are then checked in row-major order, so the fault returned is the earliest one in reading order.
+*
+* The check states the whole of the rule and nothing beyond it: a table with no rows, or whose rows are all empty, has no fault, and neither `columnWidthsPt` nor a cell's own properties other than its blocks and spans are consulted.
+*/
+function findTableGridFault(table) {
+	const gridColumnCount = widestRowLength(table);
+	for (const [rowIndex, row] of table.rows.entries()) if (row.cells.length !== gridColumnCount) return {
+		kind: "raggedRow",
+		rowIndex,
+		cellCount: row.cells.length,
+		gridColumnCount
+	};
+	const grid = walkTableGrid(table);
+	for (const row of grid) for (const position of row) {
+		const fault = position.anchorRowIndex === void 0 ? anchorFault(position, row, grid.length) : coveredFault(position);
+		if (fault !== void 0) return fault;
+	}
+}
+/**
+* One sentence stating a fault in words, for a writer that refuses or reports a table the grid rule does not admit: it names the fault by its position and, where the fault involves a second region, by that region's anchor. Indices are 0-based, matching every index in the descriptor. The sentence carries no entry point or format of its own, so each caller prefixes whatever names its own operation.
+*/
+function describeTableGridFault(fault) {
+	switch (fault.kind) {
+		case "raggedRow": return `row ${String(fault.rowIndex)} holds ${String(fault.cellCount)} cells where the widest row holds ${String(fault.gridColumnCount)}, but every row of a table covers the same grid`;
+		case "coveredContent": return `the cell at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} lies inside the merged region anchored at row ${String(fault.anchorRowIndex)}, column ${String(fault.anchorColumnIndex)} but carries content of its own, and a merged region's content belongs to its anchor`;
+		case "coveredSpan": return `the cell at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} lies inside the merged region anchored at row ${String(fault.anchorRowIndex)}, column ${String(fault.anchorColumnIndex)} but states a span of its own, and only a region's anchor carries a span`;
+		case "anchorOverrunsColumns": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} spans past the last column of the grid`;
+		case "anchorOverrunsRows": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} spans past the last row of the table`;
+		case "overlappingAnchors": return `the merged region anchored at row ${String(fault.rowIndex)}, column ${String(fault.columnIndex)} overlaps the region anchored at row ${String(fault.earlierAnchorRowIndex)}, column ${String(fault.earlierAnchorColumnIndex)}, but a grid position belongs to one region only`;
+	}
+}
 function placedGridWidth(rows, columnCount) {
 	let width = columnCount;
 	for (const row of rows) for (const { columnIndex, cell } of row.cells) width = Math.max(width, columnIndex + tableCellColumnSpan(cell));
@@ -110,4 +193,4 @@ function placeAnchorTableRows(rows, columnCount) {
 	return denseTableRows(positionAnchorRows(rows), columnCount);
 }
 //#endregion
-export { denseTableRows, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };
+export { denseTableRows, describeTableGridFault, findTableGridFault, placeAnchorTableRows, tableCellColumnSpan, tableCellRowSpan, tableGridColumnCount, walkTableGrid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-schema",
-  "version": "7.12.0",
+  "version": "7.14.0",
   "description": "The canonical, format-agnostic content and document-tree schemas shared by ooxml.js, odf.js, documents.js, pdf-codec, and markdown-codec, plus the structural transform between them -- no format-specific or I/O behaviour.",
   "type": "module",
   "repository": {

package/schemas/content-document.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/content-document.schema.json",
+  "$id": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/content-document.schema.json",
   "oneOf": [
     {
       "type": "object",
@@ -133,7 +133,7 @@
               "blocks": {
                 "type": "array",
                 "items": {
-                  "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                  "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                 }
               },
               "breakType": {
@@ -151,19 +151,19 @@
                   "default": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   },
                   "even": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   },
                   "first": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   }
                 },
@@ -175,19 +175,19 @@
                   "default": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   },
                   "even": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   },
                   "first": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   }
                 },
@@ -199,19 +199,19 @@
                   "default": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   },
                   "even": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   },
                   "first": {
                     "type": "array",
                     "items": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                     }
                   }
                 },
@@ -638,7 +638,7 @@
                     "blocks": {
                       "type": "array",
                       "items": {
-                        "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                        "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                       }
                     }
                   },
@@ -2659,7 +2659,7 @@
                       ]
                     },
                     "document": {
-                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/content-document.schema.json"
+                      "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/content-document.schema.json"
                     },
                     "frame": {
                       "type": "object",
@@ -5021,7 +5021,7 @@
                     "blocks": {
                       "type": "array",
                       "items": {
-                        "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/undefined#/$defs/schema2"
+                        "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/undefined#/$defs/schema2"
                       }
                     }
                   },
@@ -7955,6 +7955,9 @@
             "ltr",
             "rtl"
           ]
+        },
+        "isHeader": {
+          "type": "boolean"
         }
       },
       "required": [
@@ -8027,7 +8030,7 @@
           ]
         },
         "document": {
-          "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/content-document.schema.json"
+          "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/content-document.schema.json"
         },
         "frame": {
           "$ref": "#/$defs/Box"
@@ -10353,7 +10356,7 @@
           ]
         },
         "document": {
-          "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.12.0/schemas/content-document.schema.json"
+          "$ref": "https://cdn.jsdelivr.net/npm/document-schema.js@7.14.0/schemas/content-document.schema.json"
         },
         "frame": {
           "$ref": "#/$defs/Box"