@openpresentation/opf 0.6.0 → 0.7.0

package/dist/{catalogs-x1oFFQnd.d.ts → catalogs-BnnkUX9O.d.ts}

@@ -1,4 +1,4 @@
-import { a as SchemaName } from './schemas-C1DxapX2.js';
+import { a as SchemaName } from './schemas--QRVBhU1.js';
 
 /**
  * Schema for audience records in the pptx.gallery library. Each record names an audience archetype (e.g. 'executives', 'engineering-team', 'investors') and carries seniority, technical-fluency, decision-power, and attention-budget hints used by AI-driven generation. Audiences are referenced from OPF documents via audience; the engine resolves the reference against catalogs.audiences (inline) → catalogs.audiences.source → the default catalog at https://www.pptx.gallery/audiences. The audience field also accepts free-form strings; this catalog is for engine-aware audience archetypes that carry generation hints.

package/dist/catalogs.d.ts

@@ -1,2 +1,2 @@
-export { C as CatalogEntry, a as CatalogIndex, b as CatalogIndexRecord, c as CatalogKind, d as CatalogRecord, i as audiences, j as catalogEntries, k as catalogIndexes, l as catalogKinds, m as catalogSchemaNames, n as catalogs, o as chartTypes, p as colorSchemes, q as fontSchemes, r as languages, s as layouts, t as narratives, u as purposes, v as socialPlatforms, w as themes, x as tones } from './catalogs-x1oFFQnd.js';
-import './schemas-C1DxapX2.js';
+export { C as CatalogEntry, a as CatalogIndex, b as CatalogIndexRecord, c as CatalogKind, d as CatalogRecord, i as audiences, j as catalogEntries, k as catalogIndexes, l as catalogKinds, m as catalogSchemaNames, n as catalogs, o as chartTypes, p as colorSchemes, q as fontSchemes, r as languages, s as layouts, t as narratives, u as purposes, v as socialPlatforms, w as themes, x as tones } from './catalogs-BnnkUX9O.js';
+import './schemas--QRVBhU1.js';

package/dist/{chunk-KSN6RQG2.js → chunk-GQSK3T7X.js}

@@ -3688,10 +3688,16 @@ Resolution order: inline catalogs.fontSchemes.records[] -> catalogs.fontSchemes.
                 "items": {
                   "$ref": "#/$defs/TextRun"
                 }
+              },
+              {
+                "$ref": "#/$defs/StyledTableCell"
+              },
+              {
+                "type": "null"
               }
             ]
           },
-          "description": "Optional column labels rendered above table rows. Each label is a string or an array of TextRun values for inline formatting.",
+          "description": "Optional column labels. Labels may be strings, rich runs or styled cell objects. Null is an empty label or a placeholder covered by a preceding column span.",
           "examples": [
             [
               "Region",
@@ -3862,6 +3868,17 @@ Resolution order: inline catalogs.fontSchemes.records[] -> catalogs.fontSchemes.
       "description": "A cell in inline chart data."
     },
     "TableCell": {
+      "oneOf": [
+        {
+          "$ref": "#/$defs/TableCellValue"
+        },
+        {
+          "$ref": "#/$defs/StyledTableCell"
+        }
+      ],
+      "description": "A scalar, rich-run array, or styled/spanning cell object. Existing scalar and rich forms remain valid."
+    },
+    "TableCellValue": {
       "oneOf": [
         {
           "type": "string"
@@ -3882,7 +3899,149 @@ Resolution order: inline catalogs.fontSchemes.records[] -> catalogs.fontSchemes.
           }
         }
       ],
-      "description": "A cell in table content. Scalar values keep their text representation; TextRun arrays preserve inline formatting and use mixed-style text measurement."
+      "description": "A scalar table value or canonical rich text runs, without cell decoration or geometry."
+    },
+    "StyledTableCell": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "value"
+      ],
+      "properties": {
+        "value": {
+          "$ref": "#/$defs/TableCellValue",
+          "description": "Editable cell content; styling and spans do not change its scalar type or rich runs."
+        },
+        "style": {
+          "$ref": "#/$defs/TableCellStyle"
+        },
+        "colSpan": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Number of grid columns covered, starting at this cell. Covered positions must contain null. Default 1."
+        },
+        "rowSpan": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Number of grid rows covered, starting at this cell. Covered positions must contain null. Header cells cannot span into body rows. Default 1."
+        }
+      },
+      "description": "A cell with explicit visual style or merged geometry. Its position remains its array column index; use null placeholders for every covered grid position."
+    },
+    "TableCellStyle": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "fill": {
+          "type": "string",
+          "pattern": "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
+          "description": "Explicit RGB or RGBA color. Eight-digit colors include alpha; #00000000 is transparent."
+        },
+        "color": {
+          "type": "string",
+          "pattern": "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
+          "description": "Default text color, overridden by individual rich run colors."
+        },
+        "align": {
+          "type": "string",
+          "enum": [
+            "left",
+            "center",
+            "right"
+          ],
+          "description": "Horizontal text alignment inside the cell."
+        },
+        "verticalAlign": {
+          "type": "string",
+          "enum": [
+            "top",
+            "middle",
+            "bottom"
+          ],
+          "description": "Vertical alignment inside the padded cell box."
+        },
+        "padding": {
+          "$ref": "#/$defs/TableCellPadding"
+        },
+        "borders": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "top": {
+              "$ref": "#/$defs/TableCellBorder"
+            },
+            "right": {
+              "$ref": "#/$defs/TableCellBorder"
+            },
+            "bottom": {
+              "$ref": "#/$defs/TableCellBorder"
+            },
+            "left": {
+              "$ref": "#/$defs/TableCellBorder"
+            }
+          },
+          "description": "Independent cell edges. Omitted edges retain the table theme border; width 0 removes an edge."
+        }
+      },
+      "description": "Cell appearance. Sizes use reference pixels at a 720-pixel canvas short edge and scale with the slide."
+    },
+    "TableCellPadding": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "top": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 200
+        },
+        "right": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 200
+        },
+        "bottom": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 200
+        },
+        "left": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 200
+        }
+      },
+      "description": "Text insets in reference pixels. Defaults: top 8, right 10, bottom 4, left 10."
+    },
+    "TableCellBorder": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "color",
+        "width"
+      ],
+      "properties": {
+        "color": {
+          "type": "string",
+          "pattern": "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
+          "description": "Explicit RGB or RGBA color. Eight-digit colors include alpha; #00000000 is transparent."
+        },
+        "width": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 32,
+          "description": "Border width in reference pixels; 0 removes this edge."
+        },
+        "dash": {
+          "type": "string",
+          "enum": [
+            "solid",
+            "dash",
+            "dot"
+          ],
+          "description": "Default solid."
+        }
+      },
+      "description": "One explicit cell border."
     },
     "Catalogs": {
       "type": "object",

package/dist/{chunk-23MXJL2K.js → chunk-H7UXKXEJ.js}

@@ -1,5 +1,5 @@
-import { MAX_COMPOSITION_DEPTH } from './chunk-C7GKRLI6.js';
-import { schemas } from './chunk-KSN6RQG2.js';
+import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-OVPWNQIJ.js';
+import { schemas } from './chunk-GQSK3T7X.js';
 import { catalogSchemaNames } from './chunk-TWMRZ43O.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
@@ -802,6 +802,14 @@ function validatePresentationSemantics(value) {
         slideIds.add(slide.id);
       }
       issues.push(...validateSlideRegions(slide, `/slides/${index}`));
+      const visitTables = (node, path) => {
+        if (isRecord(node.table)) for (const issue of tableGrid(node.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
+        if (Array.isArray(node.blocks)) node.blocks.forEach((block, i) => {
+          if (isRecord(block)) visitTables(block, `${path}/blocks/${i}`);
+        });
+        for (const key of promotedRegionKeys) if (isRecord(node[key])) visitTables(node[key], pathFor(path, key));
+      };
+      visitTables(slide, `/slides/${index}`);
     }
   });
   return issues;

package/dist/{chunk-C6U7LLBT.js → chunk-IQ727X3E.js}

@@ -1,5 +1,5 @@
-import { assertValidPresentation } from './chunk-23MXJL2K.js';
-import { resolveFontFamilies, resolveCanvasDimensions, composeSlide } from './chunk-C7GKRLI6.js';
+import { assertValidPresentation } from './chunk-H7UXKXEJ.js';
+import { resolveFontFamilies, resolveCanvasDimensions, composeSlide, tableRowBoundaries } from './chunk-OVPWNQIJ.js';
 import { catalogs } from './chunk-TWMRZ43O.js';
 
 // src/pagination.ts
@@ -52,7 +52,7 @@ function leafFor(path, field, value) {
     const values = Array.isArray(value) ? value : value[key];
     if (Array.isArray(values)) {
       leaf.unit = "items";
-      leaf.boundaries = Array.from({ length: values.length + 1 }, (_, i) => i);
+      leaf.boundaries = field === "table" ? tableRowBoundaries(value) : Array.from({ length: values.length + 1 }, (_, i) => i);
       leaf.slice = (a, b) => Array.isArray(value) ? value.slice(a, b) : { ...value, [key]: values.slice(a, b) };
     }
   }

package/dist/{chunk-C7GKRLI6.js → chunk-OVPWNQIJ.js}

@@ -1,8 +1,45 @@
+// src/table.ts
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+function tableGrid(value, path = "table") {
+  const table = record(value), hasHeaders = Array.isArray(table.columns) && table.columns.length > 0;
+  const values = [...hasHeaders ? [table.columns] : [], ...Array.isArray(table.rows) ? table.rows : []];
+  const columnCount = values.reduce((count, row) => Math.max(count, Array.isArray(row) ? row.length : 0), 1), rowCount = values.length;
+  const owners = Array.from({ length: rowCount }, () => Array(columnCount));
+  const rows2 = Array.from({ length: rowCount }, () => []), issues = [];
+  const location = (r, c) => `${path}.${hasHeaders && r === 0 ? "columns" : `rows.${r - Number(hasHeaders)}`}.${c}`;
+  for (let r = 0; r < rowCount; r++) for (let c = 0; c < columnCount; c++) {
+    const input = values[r]?.[c], cellPath = location(r, c), existing = owners[r][c];
+    if (existing) {
+      if (input !== null) issues.push({ path: cellPath, message: "A position covered by a spanning cell must explicitly contain null; content cannot be hidden." });
+      continue;
+    }
+    const object = record(input), styled = Object.hasOwn(object, "value");
+    const rowSpan = styled ? object.rowSpan ?? 1 : 1, colSpan = styled ? object.colSpan ?? 1 : 1;
+    if (!Number.isSafeInteger(rowSpan) || !Number.isSafeInteger(colSpan) || rowSpan < 1 || colSpan < 1 || r + rowSpan > rowCount || c + colSpan > columnCount || hasHeaders && r === 0 && rowSpan > 1) {
+      issues.push({ path: cellPath, message: "Cell spans must be positive integers within the table grid and cannot cross from headers into body rows." });
+      continue;
+    }
+    const cell = { input, value: styled ? object.value : input, style: styled ? record(object.style) : {}, row: r, column: c, rowSpan, colSpan, header: hasHeaders && r === 0, path: cellPath, valuePath: styled ? cellPath + ".value" : cellPath };
+    rows2[r].push(cell);
+    for (let y = r; y < r + rowSpan; y++) for (let x = c; x < c + colSpan; x++) {
+      if (owners[y][x]) issues.push({ path: cellPath, message: "Cell spans cannot overlap another spanning cell." });
+      else owners[y][x] = cell;
+    }
+  }
+  return { rows: rows2, columnCount, rowCount, hasHeaders, owners, issues };
+}
+function tableRowBoundaries(value) {
+  const grid = tableGrid(value), offset = Number(grid.hasHeaders), count = grid.rowCount - offset;
+  const allowed = new Set(Array.from({ length: count + 1 }, (_, i) => i));
+  for (const row of grid.rows) for (const cell of row) if (!cell.header) for (let r = 1; r < cell.rowSpan; r++) allowed.delete(cell.row - offset + r);
+  return [...allowed];
+}
+
 // src/composition.ts
 var MAX_COMPOSITION_DEPTH = 32;
 function resolveFontFamilies(input) {
-  const scheme = record(input);
-  const family = (value) => typeof value === "string" ? value : record(value).family;
+  const scheme = record2(input);
+  const family = (value) => typeof value === "string" ? value : record2(value).family;
   return {
     heading: family(scheme.heading) ?? scheme.major ?? scheme.minor ?? "Roboto",
     body: family(scheme.body) ?? scheme.minor ?? scheme.major ?? "Roboto",
@@ -33,7 +70,7 @@ var fields = ["text", "items", "bullets", "image", "video", "chart", "table", "c
 var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
 var rows = ["top", "middle", "bottom"];
 var columns = ["left", "center", "right"];
-var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var kind = (field) => field === "items" || field === "bullets" ? "list" : field;
 var round = (value) => Math.round(value * 1e6) / 1e6 || value;
 var textSegments = new Intl.Segmenter("und", { granularity: "grapheme" });
@@ -236,53 +273,61 @@ function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { s
 function contentText(field, value) {
   if (field === "text" || headings.has(field)) return flatten(value);
   if (field === "items" || field === "bullets") return (Array.isArray(value) ? value : [value]).map((item) => {
-    const entry = record(item);
+    const entry = record2(item);
     return `\u2022 ${flatten(item)}${entry.description ? `
 ${flatten(entry.description)}` : ""}`;
   }).join("\n");
-  if (field === "code") return flatten(record(value).source ?? value);
-  if (field === "quote") return flatten(record(value).text ?? value);
+  if (field === "code") return flatten(record2(value).source ?? value);
+  if (field === "quote") return flatten(record2(value).text ?? value);
   return void 0;
 }
 function layoutTable(value, box, options = {}) {
   const scale = options.scale ?? 1, requested = 15 * scale, minimum = (options.minFontSize ?? 16) * scale;
   if (![box.x, box.y, box.width, box.height, scale, minimum].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) throw new RangeError("Table dimensions, scale and font sizes must be finite and positive.");
-  const table = record(value), headers = Array.isArray(table.columns) && table.columns.length > 0;
-  const values = [...headers ? [table.columns] : [], ...Array.isArray(table.rows) ? table.rows : []];
-  const columnCount = Math.max(1, ...values.map((row) => row.length)), cellWidth = box.width / columnCount;
-  const width = Math.max(scale, cellWidth - 20 * scale), padding = 12 * scale;
+  const grid = tableGrid(value, options.path ?? "table");
+  if (grid.issues.length) throw new RangeError(`${grid.issues[0].path}: ${grid.issues[0].message}`);
+  const columnCount = grid.columnCount, cellWidth = box.width / columnCount;
+  const cells = grid.rows.flat().map((cell) => {
+    const padding = { top: 8, right: 10, bottom: 4, left: 10, ...cell.style.padding };
+    const width = cellWidth * cell.colSpan - (padding.left + padding.right) * scale;
+    const style = { fontFamily: options.fontFamily ?? "sans-serif", fontWeight: cell.header ? 700 : 400, italic: false, path: cell.valuePath };
+    return { ...cell, padding, width, textStyle: style };
+  });
   const fitCell = (cell, height, min) => {
-    const textBox = { width, height: Math.max(scale, height) };
-    return Array.isArray(cell.value) ? fitRichText(cell.value, textBox, requested, min, { style: cell.style, textMeasurement: options.textMeasurement, uniformLineHeight: true }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.style, options.textMeasurement), options.textMeasurement));
+    const textBox = { width: Math.max(scale, cell.width), height: Math.max(scale, height) };
+    return Array.isArray(cell.value) ? fitRichText(cell.value, textBox, requested, min, { style: cell.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
   };
   const textHeight = (fit) => "height" in fit ? fit.height : fit.lines.length * fit.lineHeight;
-  const measured = values.map((row, index) => {
-    const header = headers && index === 0;
-    const cells = Array.from({ length: columnCount }, (_, column) => {
-      const path = `${options.path ?? "table"}.${header ? "columns" : `rows.${index - Number(headers)}`}.${column}`;
-      return { value: row[column], path, header, style: { fontFamily: options.fontFamily ?? "sans-serif", fontWeight: header ? 700 : 400, italic: false, path } };
-    });
-    const natural2 = Math.max(...cells.map((cell) => textHeight(fitCell(cell, scale, requested)) + padding));
-    const preferred2 = Math.max(54 * scale, natural2);
-    const needed2 = Math.min(preferred2, Math.max(...cells.map((cell) => textHeight(fitCell(cell, scale, minimum)) + padding)));
-    return { cells, preferred: preferred2, natural: natural2, needed: needed2 };
-  });
-  const preferred = measured.reduce((sum, row) => sum + row.preferred, 0), natural = measured.reduce((sum, row) => sum + row.natural, 0), needed = measured.reduce((sum, row) => sum + row.needed, 0);
-  let y = box.y, overflow = cellWidth <= 20 * scale;
-  const rows2 = measured.map((row) => {
-    const height = preferred <= box.height ? row.preferred : natural <= box.height ? row.natural + (row.preferred - row.natural) * (box.height - natural) / Math.max(Number.EPSILON, preferred - natural) : needed <= box.height ? row.needed + (row.natural - row.needed) * (box.height - needed) / Math.max(Number.EPSILON, natural - needed) : row.needed * box.height / needed;
-    const rowBox = { x: box.x, y, width: box.width, height };
-    const cells = row.cells.map((cell, column) => {
-      const cellBox = { x: box.x + column * cellWidth, y, width: cellWidth, height };
-      const textBox = { x: cellBox.x + 10 * scale, y: y + 8 * scale, width, height: Math.max(scale, height - padding) };
-      const fit = fitCell(cell, textBox.height, minimum);
-      overflow ||= height <= padding || fit.overflow;
-      return { value: cell.value, path: cell.path, header: cell.header, rich: Array.isArray(cell.value), box: cellBox, textBox, textStyle: resolveTextStyle(cell.style, options.textMeasurement), fit };
-    });
-    y += height;
-    return { box: rowBox, cells };
-  });
-  return { rows: rows2, columnCount, height: y - box.y, overflow };
+  const required = (cell, size) => textHeight(fitCell(cell, scale, size)) + (cell.padding.top + cell.padding.bottom) * scale;
+  const natural = Array(grid.rowCount).fill(0), needed = Array(grid.rowCount).fill(0);
+  for (const cell of cells) if (cell.rowSpan === 1) {
+    natural[cell.row] = Math.max(natural[cell.row], required(cell, requested));
+    needed[cell.row] = Math.max(needed[cell.row], required(cell, minimum));
+  }
+  for (const cell of cells) if (cell.rowSpan > 1) for (const [heights2, size] of [[natural, requested], [needed, minimum]]) {
+    const current = heights2.slice(cell.row, cell.row + cell.rowSpan).reduce((a, b) => a + b, 0);
+    const extra = Math.max(0, required(cell, size) - current) / cell.rowSpan;
+    for (let r = cell.row; r < cell.row + cell.rowSpan; r++) heights2[r] += extra;
+  }
+  const preferred = natural.map((height) => Math.max(54 * scale, height));
+  for (let r = 0; r < needed.length; r++) needed[r] = Math.min(preferred[r], needed[r]);
+  const sum = (values) => values.reduce((a, b) => a + b, 0);
+  const preferredTotal = sum(preferred), naturalTotal = sum(natural), neededTotal = sum(needed);
+  const heights = preferred.map((height, r) => preferredTotal <= box.height ? height : naturalTotal <= box.height ? natural[r] + (height - natural[r]) * (box.height - naturalTotal) / Math.max(Number.EPSILON, preferredTotal - naturalTotal) : neededTotal <= box.height ? needed[r] + (natural[r] - needed[r]) * (box.height - neededTotal) / Math.max(Number.EPSILON, naturalTotal - neededTotal) : needed[r] * box.height / neededTotal);
+  const ys = [box.y];
+  for (const height of heights) ys.push(ys.at(-1) + height);
+  let overflow = false;
+  const rows2 = heights.map((height, r) => ({ box: { x: box.x, y: ys[r], width: box.width, height }, cells: [] }));
+  for (const cell of cells) {
+    const cellBox = { x: box.x + cell.column * cellWidth, y: ys[cell.row], width: cell.colSpan * cellWidth, height: ys[cell.row + cell.rowSpan] - ys[cell.row] };
+    const available = cellBox.height - (cell.padding.top + cell.padding.bottom) * scale;
+    const fit = fitCell(cell, available, minimum), height = textHeight(fit);
+    const offset = cell.style.verticalAlign === "bottom" ? Math.max(0, available - height) : cell.style.verticalAlign === "middle" ? Math.max(0, (available - height) / 2) : 0;
+    const textBox = { x: cellBox.x + cell.padding.left * scale, y: cellBox.y + cell.padding.top * scale + offset, width: Math.max(scale, cell.width), height: Math.max(scale, available - offset) };
+    overflow ||= cell.width <= 0 || available <= 0 || fit.overflow;
+    rows2[cell.row].cells.push({ value: cell.value, input: cell.input, path: cell.valuePath, sourcePath: cell.path, style: cell.style, row: cell.row, column: cell.column, rowSpan: cell.rowSpan, colSpan: cell.colSpan, header: cell.header, rich: Array.isArray(cell.value), box: cellBox, textBox, textStyle: resolveTextStyle(cell.textStyle, options.textMeasurement), fit });
+  }
+  return { rows: rows2, columnCount, height: sum(heights), overflow };
 }
 function tableOverflows(value, box, scale, settings, options, path) {
   return box.width <= 0 || box.height <= 0 || layoutTable(value, box, { scale, minFontSize: settings.minFontSize, fontFamily: options.fonts?.body, textMeasurement: options.textMeasurement, path }).overflow;
@@ -291,7 +336,7 @@ function flatten(value) {
   if (value == null) return "";
   if (typeof value !== "object") return String(value);
   if (Array.isArray(value)) return value.map(flatten).join("");
-  const item = record(value);
+  const item = record2(value);
   return flatten(item.text ?? item.value ?? item.source ?? JSON.stringify(value));
 }
 function regionParts(key) {
@@ -347,11 +392,11 @@ function assertComposition(value) {
   if (value.overflow !== void 0 && !["warn", "error"].includes(value.overflow)) throw new RangeError("Invalid composition.overflow.");
 }
 function composeSlide(input, options = {}) {
-  const slide = record(input), layout = record(options.layout);
+  const slide = record2(input), layout = record2(options.layout);
   const width = options.width ?? 1280, height = options.height ?? 720;
   if (![width, height].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Canvas dimensions must be finite and positive.");
   const scale = Math.min(width, height) / 720;
-  const composition = { ...record(layout.composition), ...record(slide.composition) };
+  const composition = { ...record2(layout.composition), ...record2(slide.composition) };
   assertComposition(composition);
   const padding = (composition.padding ?? 0.08) * Math.min(width, height);
   const gap = (composition.gap ?? 1 / 30) * Math.min(width, height);
@@ -381,7 +426,7 @@ function composeSlide(input, options = {}) {
   const collect = (host, basePath, depth = 0, ancestors = []) => {
     if (Array.isArray(host.blocks)) {
       if (depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(host)) throw new RangeError(`Content groups must be acyclic and nest at most ${MAX_COMPOSITION_DEPTH} levels.`);
-      const settings = record(host.composition);
+      const settings = record2(host.composition);
       assertComposition(settings);
       return [{
         field: "blocks",
@@ -390,13 +435,13 @@ function composeSlide(input, options = {}) {
         path: basePath,
         payload: host,
         composition: settings,
-        children: host.blocks.flatMap((block, index) => collect(record(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
+        children: host.blocks.flatMap((block, index) => collect(record2(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
       }];
     }
     return fields.filter((field) => host[field] !== void 0).map((field) => ({ field, type: host.type ?? kind(field), value: host[field], path: `${basePath}.${field}`, payload: { type: host.type ?? kind(field), [field]: host[field] } }));
   };
   const regions = Object.keys(slide).filter((key) => regionParts(key)).sort();
-  const pending = regions.length ? regions.flatMap((key) => collect(record(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => collect(record(block), `${path}.blocks.${index}`)) : collect(slide, path);
+  const pending = regions.length ? regions.flatMap((key) => collect(record2(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => collect(record2(block), `${path}.blocks.${index}`)) : collect(slide, path);
   const groups = [], flows = [];
   const inheritedSettings = (parent, own = {}) => ({
     minFontSize: parent.minFontSize,
@@ -488,7 +533,7 @@ function resolveCanvasDimensions(input) {
     letter: [11, 8.5],
     a4: [11.69, 8.27]
   };
-  const value = record(input);
+  const value = record2(input);
   const preset = presets[typeof input === "string" ? input : value.preset] ?? presets.widescreen;
   const width = (value.widthInches ?? preset[0]) * 96;
   const height = (value.heightInches ?? preset[1]) * 96;
@@ -496,4 +541,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { MAX_COMPOSITION_DEPTH, OPFCompositionError, composeSlide, fitList, fitRichText, fitText, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textWidthMeasurer, wrapText };
+export { MAX_COMPOSITION_DEPTH, OPFCompositionError, composeSlide, fitList, fitRichText, fitText, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textWidthMeasurer, wrapText };

package/dist/composition.d.ts

@@ -1,3 +1,46 @@
+/** Canonical table grid. No renderer, fonts, DOM or network dependencies. */
+interface TableBorder {
+    color: string;
+    width: number;
+    dash?: 'solid' | 'dash' | 'dot';
+}
+interface TableCellStyle {
+    fill?: string;
+    color?: string;
+    align?: 'left' | 'center' | 'right';
+    verticalAlign?: 'top' | 'middle' | 'bottom';
+    padding?: Partial<Record<'top' | 'right' | 'bottom' | 'left', number>>;
+    borders?: Partial<Record<'top' | 'right' | 'bottom' | 'left', TableBorder>>;
+}
+interface TableGridCell {
+    input: unknown;
+    value: unknown;
+    style: TableCellStyle;
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
+    header: boolean;
+    path: string;
+    valuePath: string;
+}
+interface TableGridIssue {
+    path: string;
+    message: string;
+}
+interface TableGrid {
+    rows: TableGridCell[][];
+    columnCount: number;
+    rowCount: number;
+    hasHeaders: boolean;
+    /** Anchor at each covered position; covered positions are not additional cells. */
+    owners: (TableGridCell | undefined)[][];
+    issues: TableGridIssue[];
+}
+declare function tableGrid(value: unknown, path?: string): TableGrid;
+/** Row boundaries that preserve every vertical merge, used by pagination. */
+declare function tableRowBoundaries(value: unknown): number[];
+
 /** Portable layout geometry. No fonts, DOM, renderer, or network dependencies. */
 interface Composition {
     mode?: "auto" | "grid" | "row" | "column";
@@ -190,6 +233,13 @@ interface TableLayoutOptions {
 }
 interface TableCellLayout {
     value: unknown;
+    input: unknown;
+    sourcePath: string;
+    style: TableCellStyle;
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
     path: string;
     header: boolean;
     rich: boolean;
@@ -222,4 +272,4 @@ declare function resolveCanvasDimensions(input: unknown): {
     height: number;
 };
 
-export { type ComposeSlideOptions, type ComposedFlow, type ComposedGroup, type ComposedItem, type Composition, type CompositionTrack, type FontFamilies, type LayoutBox, type LayoutDiagnostic, type ListEntryLayout, type ListFit, type ListText, type ListValue, MAX_COMPOSITION_DEPTH, type MeasureTextWidth, OPFCompositionError, type RichTextFit, type RichTextFragment, type RichTextLine, type RichTextOptions, type RichTextRun, type SlideComposition, type TableCellLayout, type TableLayout, type TableLayoutOptions, type TableRowLayout, type TextFit, type TextMeasurement, type TextStyle, composeSlide, fitList, fitRichText, fitText, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textWidthMeasurer, wrapText };
+export { type ComposeSlideOptions, type ComposedFlow, type ComposedGroup, type ComposedItem, type Composition, type CompositionTrack, type FontFamilies, type LayoutBox, type LayoutDiagnostic, type ListEntryLayout, type ListFit, type ListText, type ListValue, MAX_COMPOSITION_DEPTH, type MeasureTextWidth, OPFCompositionError, type RichTextFit, type RichTextFragment, type RichTextLine, type RichTextOptions, type RichTextRun, type SlideComposition, type TableBorder, type TableCellLayout, type TableCellStyle, type TableGrid, type TableGridCell, type TableGridIssue, type TableLayout, type TableLayoutOptions, type TableRowLayout, type TextFit, type TextMeasurement, type TextStyle, composeSlide, fitList, fitRichText, fitText, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textWidthMeasurer, wrapText };

package/dist/composition.js

@@ -1 +1 @@
-export { MAX_COMPOSITION_DEPTH, OPFCompositionError, composeSlide, fitList, fitRichText, fitText, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textWidthMeasurer, wrapText } from './chunk-C7GKRLI6.js';
+export { MAX_COMPOSITION_DEPTH, OPFCompositionError, composeSlide, fitList, fitRichText, fitText, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textWidthMeasurer, wrapText } from './chunk-OVPWNQIJ.js';