@openpresentation/cli 0.2.0 → 0.4.0

package/README.md

@@ -13,7 +13,7 @@ npm install -g @openpresentation/cli
 opf --version
 ```
 
-Or install it as a development dependency and use `npx --no-install opf`. This checkout prepares CLI 0.2.0 with bundled OPF 0.5.0; that version supports rich table cells and headers during validation and pagination. Until 0.2.0 is published, the registry's latest release has the previous schema.
+Or install it as a development dependency and use `npx --no-install opf`. CLI 0.2.0 bundles OPF 0.5.0 and supports rich table cells and headers during validation and pagination.
 
 To verify the standalone package from source, run `pnpm install` and `pnpm test:cli:packed`. This creates `artifacts/cli/openpresentation-cli-0.2.0.tgz`, which can be installed using its absolute path. For source development, run `pnpm --filter @openpresentation/cli build` and `node packages/cli/dist/index.js --help`.
 

package/dist/index.js

@@ -8163,11 +8163,46 @@ function createDataContent(input, options) {
   return { chart: { type: options.chartType ?? "column", data: { columns: names, rows: rows2 } } };
 }
 
-// ../javascript/dist/chunk-WG5A4KZG.js
+// ../javascript/dist/chunk-OVPWNQIJ.js
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+function tableGrid(value, path2 = "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) => `${path2}.${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 cell2 = { 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(cell2);
+    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] = cell2;
+    }
+  }
+  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 cell2 of row) if (!cell2.header) for (let r = 1; r < cell2.rowSpan; r++) allowed.delete(cell2.row - offset + r);
+  return [...allowed];
+}
 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",
@@ -8198,7 +8233,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" });
@@ -8325,6 +8360,16 @@ function richTextLayouter(input, box, requestedSize, options) {
       y += height;
       return line;
     });
+    if (options.uniformLineHeight) {
+      const height = Math.max(...richLines.map((line) => line.height));
+      y = 0;
+      for (const line of richLines) {
+        line.baseline += y - line.y;
+        line.y = y;
+        line.height = height;
+        y += height;
+      }
+    }
     return { lines: ranges.map((range) => whole.slice(range.start, range.end)), fontSize, lineHeight: Math.max(fontSize * 1.22, ...richLines.map((line) => line.height)), richLines, height: y, overflow: y > box.height + 0.01 || richLines.some((line) => line.width > box.width + 0.01) };
   };
   return layout2;
@@ -8391,31 +8436,70 @@ 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 tableOverflows(value, box, scale, settings, options) {
-  const table = record(value), rows2 = Array.isArray(table.rows) ? table.rows : [];
-  const allRows = Array.isArray(table.columns) && table.columns.length ? [table.columns, ...rows2] : rows2;
-  const columns2 = Math.max(1, ...allRows.map((row) => row.length));
-  const width = box.width / columns2 - 20 * scale;
-  const height = Math.min(54 * scale, box.height / Math.max(1, allRows.length)) - 12 * scale;
-  return width <= 0 || height <= 0 || allRows.some((row, index2) => row.some((value2) => {
-    const style = { fontFamily: options.fonts?.body ?? "sans-serif", fontWeight: index2 === 0 && table.columns?.length ? 700 : 400 };
-    const cell2 = { width, height }, minimum = (settings.minFontSize ?? 16) * scale;
-    return (Array.isArray(value2) ? fitRichText(value2, cell2, 15 * scale, minimum, { style, textMeasurement: options.textMeasurement }) : fitText(flatten(value2), cell2, 15 * scale, minimum, textWidthMeasurer(resolveTextStyle(style, options.textMeasurement), options.textMeasurement))).overflow;
-  }));
+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 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((cell2) => {
+    const padding = { top: 8, right: 10, bottom: 4, left: 10, ...cell2.style.padding };
+    const width = cellWidth * cell2.colSpan - (padding.left + padding.right) * scale;
+    const style = { fontFamily: options.fontFamily ?? "sans-serif", fontWeight: cell2.header ? 700 : 400, italic: false, path: cell2.valuePath };
+    return { ...cell2, padding, width, textStyle: style };
+  });
+  const fitCell = (cell2, height, min) => {
+    const textBox = { width: Math.max(scale, cell2.width), height: Math.max(scale, height) };
+    return Array.isArray(cell2.value) ? fitRichText(cell2.value, textBox, requested, min, { style: cell2.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true }) : fitText(flatten(cell2.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell2.textStyle, options.textMeasurement), options.textMeasurement));
+  };
+  const textHeight = (fit) => "height" in fit ? fit.height : fit.lines.length * fit.lineHeight;
+  const required = (cell2, size) => textHeight(fitCell(cell2, scale, size)) + (cell2.padding.top + cell2.padding.bottom) * scale;
+  const natural = Array(grid.rowCount).fill(0), needed = Array(grid.rowCount).fill(0);
+  for (const cell2 of cells) if (cell2.rowSpan === 1) {
+    natural[cell2.row] = Math.max(natural[cell2.row], required(cell2, requested));
+    needed[cell2.row] = Math.max(needed[cell2.row], required(cell2, minimum));
+  }
+  for (const cell2 of cells) if (cell2.rowSpan > 1) for (const [heights2, size] of [[natural, requested], [needed, minimum]]) {
+    const current = heights2.slice(cell2.row, cell2.row + cell2.rowSpan).reduce((a, b) => a + b, 0);
+    const extra = Math.max(0, required(cell2, size) - current) / cell2.rowSpan;
+    for (let r = cell2.row; r < cell2.row + cell2.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 cell2 of cells) {
+    const cellBox = { x: box.x + cell2.column * cellWidth, y: ys[cell2.row], width: cell2.colSpan * cellWidth, height: ys[cell2.row + cell2.rowSpan] - ys[cell2.row] };
+    const available = cellBox.height - (cell2.padding.top + cell2.padding.bottom) * scale;
+    const fit = fitCell(cell2, available, minimum), height = textHeight(fit);
+    const offset = cell2.style.verticalAlign === "bottom" ? Math.max(0, available - height) : cell2.style.verticalAlign === "middle" ? Math.max(0, (available - height) / 2) : 0;
+    const textBox = { x: cellBox.x + cell2.padding.left * scale, y: cellBox.y + cell2.padding.top * scale + offset, width: Math.max(scale, cell2.width), height: Math.max(scale, available - offset) };
+    overflow ||= cell2.width <= 0 || available <= 0 || fit.overflow;
+    rows2[cell2.row].cells.push({ value: cell2.value, input: cell2.input, path: cell2.valuePath, sourcePath: cell2.path, style: cell2.style, row: cell2.row, column: cell2.column, rowSpan: cell2.rowSpan, colSpan: cell2.colSpan, header: cell2.header, rich: Array.isArray(cell2.value), box: cellBox, textBox, textStyle: resolveTextStyle(cell2.textStyle, options.textMeasurement), fit });
+  }
+  return { rows: rows2, columnCount, height: sum(heights), overflow };
+}
+function tableOverflows(value, box, scale, settings, options, path2) {
+  return box.width <= 0 || box.height <= 0 || layoutTable(value, box, { scale, minFontSize: settings.minFontSize, fontFamily: options.fonts?.body, textMeasurement: options.textMeasurement, path: path2 }).overflow;
 }
 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) {
@@ -8471,11 +8555,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), layout2 = record(options.layout);
+  const slide = record2(input), layout2 = 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(layout2.composition), ...record(slide.composition) };
+  const composition = { ...record2(layout2.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);
@@ -8505,7 +8589,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",
@@ -8514,13 +8598,13 @@ function composeSlide(input, options = {}) {
         path: basePath,
         payload: host,
         composition: settings,
-        children: host.blocks.flatMap((block, index2) => collect(record(block), `${basePath}.blocks.${index2}`, depth + 1, [...ancestors, host]))
+        children: host.blocks.flatMap((block, index2) => collect(record2(block), `${basePath}.blocks.${index2}`, 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]), `${path2}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index2) => collect(record(block), `${path2}.blocks.${index2}`)) : collect(slide, path2);
+  const pending = regions.length ? regions.flatMap((key) => collect(record2(slide[key]), `${path2}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index2) => collect(record2(block), `${path2}.blocks.${index2}`)) : collect(slide, path2);
   const groups = [], flows = [];
   const inheritedSettings = (parent, own3 = {}) => ({
     minFontSize: parent.minFontSize,
@@ -8538,7 +8622,7 @@ function composeSlide(input, options = {}) {
       const fit = fitContent(node.field, node.value, text, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path);
       score += (25 * scale - fit.fontSize) / scale + (fit.overflow ? 1e3 : 0);
     }
-    if (node.field === "table" && tableOverflows(node.value, box, scale, settings, options)) score += 1e3;
+    if (node.field === "table" && tableOverflows(node.value, box, scale, settings, options, node.path)) score += 1e3;
     if (box.width < 100 * scale || box.height < 60 * scale) score += 100;
     return score;
   };
@@ -8593,7 +8677,7 @@ function composeSlide(input, options = {}) {
   arrange(pending, contentBox, rootSettings, composition.mode ? 0 : placeholders.length);
   for (const item of items) {
     for (const key of ["x", "y", "width", "height"]) item.box[key] = round(item.box[key]);
-    if (item.field === "table" && tableOverflows(item.value, item.box, scale, item.composition, options)) diagnostics.push({ code: "text-overflow", path: item.path, message: "Table cells do not fit; use fewer rows, fewer columns, or split the table across slides." });
+    if (item.field === "table" && tableOverflows(item.value, item.box, scale, item.composition, options, item.path)) diagnostics.push({ code: "text-overflow", path: item.path, message: "Table cells do not fit; use fewer rows, fewer columns, or split the table across slides." });
     if (item.text?.overflow) diagnostics.push({ code: "text-overflow", path: item.path, message: "Text exceeds its cell at the minimum font size; shorten it, increase its space, or split the slide." });
   }
   for (const group of groups) for (const box of [group.box, group.contentBox]) for (const key of ["x", "y", "width", "height"]) box[key] = round(box[key]);
@@ -8612,7 +8696,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;
@@ -8620,7 +8704,7 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-// ../javascript/dist/chunk-KSN6RQG2.js
+// ../javascript/dist/chunk-GQSK3T7X.js
 var presentation = {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://openpresentation.org/schema/opf/v1",
@@ -12310,10 +12394,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",
@@ -12484,6 +12574,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"
@@ -12504,7 +12605,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",
@@ -33698,7 +33941,7 @@ var catalogEntries = [
   ], records: fontSchemes, index: catalogIndexes.fontSchemes }
 ];
 
-// ../javascript/dist/chunk-PFJE2IW4.js
+// ../javascript/dist/chunk-H7UXKXEJ.js
 var import__ = __toESM(require__(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
 var catalogIds = {
@@ -34496,6 +34739,14 @@ function validatePresentationSemantics(value) {
         slideIds.add(slide.id);
       }
       issues.push(...validateSlideRegions(slide, `/slides/${index2}`));
+      const visitTables = (node, path2) => {
+        if (isRecord(node.table)) for (const issue of tableGrid(node.table).issues) issues.push(semanticIssue(pathFor(path2, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
+        if (Array.isArray(node.blocks)) node.blocks.forEach((block, i) => {
+          if (isRecord(block)) visitTables(block, `${path2}/blocks/${i}`);
+        });
+        for (const key of promotedRegionKeys) if (isRecord(node[key])) visitTables(node[key], pathFor(path2, key));
+      };
+      visitTables(slide, `/slides/${index2}`);
     }
   });
   return issues;
@@ -34516,7 +34767,7 @@ function unknownIdWarning(kind2, value, path2, context) {
   if (context) {
     const entry = inlineCatalogEntry(context, kind2);
     if (entry) {
-      if (Array.isArray(entry.records) && entry.records.some((record2) => isRecord(record2) && record2.id === value)) {
+      if (Array.isArray(entry.records) && entry.records.some((record3) => isRecord(record3) && record3.id === value)) {
         return void 0;
       }
       if (typeof entry.source === "string") {
@@ -34692,7 +34943,7 @@ function assertValidPresentation(value) {
   assertValid(value, "presentation");
 }
 
-// ../javascript/dist/chunk-YLORKB63.js
+// ../javascript/dist/chunk-IQ727X3E.js
 var OPFPaginationError = class extends Error {
   constructor(message, diagnostics = []) {
     super(message);
@@ -34742,7 +34993,7 @@ function leafFor(path2, 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) };
     }
   }
@@ -34890,7 +35141,7 @@ function paginatePresentation(input, options = {}) {
   if (!Number.isInteger(maxSlides) || maxSlides < 1 || maxSlides > 1e4) throw new RangeError("maxSlides must be an integer between 1 and 10000.");
   const output = [], pages = [];
   const reservedIds = presentation2.slides.map((slide) => slide.id).filter(Boolean);
-  const resolve = (kind2, id) => presentation2.catalogs?.[kind2]?.records?.find((record2) => record2.id === id) ?? catalogs[kind2].find((record2) => record2.id === id);
+  const resolve = (kind2, id) => presentation2.catalogs?.[kind2]?.records?.find((record3) => record3.id === id) ?? catalogs[kind2].find((record3) => record3.id === id);
   presentation2.slides.forEach((slide, index2) => {
     const overrides = options.slideOptions?.(slide, index2) ?? {};
     const layout2 = overrides.layout ?? (slide.layout ? resolve("layouts", slide.layout) : void 0);
@@ -35132,7 +35383,7 @@ async function main(argv) {
     return;
   }
   if (argv.length === 1 && argv[0] === "--version") {
-    print({ cli: "0.2.0", opf: "0.5.0" });
+    print({ cli: "0.4.0", opf: "0.7.0" });
     return;
   }
   const [command, ...args] = argv;
@@ -35244,7 +35495,7 @@ async function main(argv) {
     arity(args, 1, 2);
     const entry = catalogEntries.find((entry2) => entry2.kind === args[0]);
     if (!entry) throw new CliError("Unknown catalog. Run opf catalogs.");
-    const result = args[1] === void 0 ? entry.records : entry.records.find((record2) => record2.id === args[1]);
+    const result = args[1] === void 0 ? entry.records : entry.records.find((record3) => record3.id === args[1]);
     if (!result) throw new CliError(`Unknown ${args[0]} id: ${args[1]}`);
     print(result);
     return;