@json-to-office/jto-ops 4.1.0 → 4.4.0

package/dist/index.js

@@ -1746,7 +1746,7 @@ var LINE_OR_WORD_PATTERN = /<line\s+xMin="(-?[\d.]+)"\s+yMin="(-?[\d.]+)"\s+xMax
 function parsePdfTextBbox(bboxXml) {
   const pages = [];
   for (const pageMatch of bboxXml.matchAll(PAGE_PATTERN)) {
-    const words = [];
+    const words2 = [];
     const lines = [];
     let open;
     for (const token of pageMatch[3].matchAll(LINE_OR_WORD_PATTERN)) {
@@ -1762,8 +1762,8 @@ function parsePdfTextBbox(bboxXml) {
           words: []
         };
       } else {
-        open?.words.push(words.length);
-        words.push({
+        open?.words.push(words2.length);
+        words2.push({
           xMin: Number(token[5]),
           yMin: Number(token[6]),
           xMax: Number(token[7]),
@@ -1775,7 +1775,7 @@ function parsePdfTextBbox(bboxXml) {
     pages.push({
       widthPt: Number(pageMatch[1]),
       heightPt: Number(pageMatch[2]),
-      words,
+      words: words2,
       lines
     });
   }
@@ -1947,9 +1947,93 @@ async function extractPdfFonts(pdfPath, options = {}) {
 }
 
 // src/rendered-analysis.ts
+import {
+  QualityEngine
+} from "@json-to-office/quality";
+
+// src/rendered-rules.ts
 import {
   QUALITY_CODES
 } from "@json-to-office/quality";
+function renderedRule(spec) {
+  return {
+    id: spec.id,
+    code: spec.code,
+    description: spec.description,
+    category: spec.category,
+    defaultSeverity: spec.defaultSeverity,
+    defaultCertainty: "rendered",
+    ...spec.formats && { formats: spec.formats },
+    evaluate({ facts }) {
+      const fact = facts.find(isRenderedGeometryFact);
+      if (!fact) return [];
+      return renderedDraftFor(fact).byRule.get(spec.id) ?? [];
+    }
+  };
+}
+var RENDERED_QUALITY_RULES = {
+  id: "rendered",
+  rules: [
+    renderedRule({
+      id: "rendered/clip",
+      code: QUALITY_CODES.RENDERED_CLIP,
+      description: "Words rendered past the page edge by more than 2 pt, or an authored string of which only a leading part rendered (`kind: truncated`, with the share found).",
+      category: "integrity",
+      defaultSeverity: "warning"
+    }),
+    renderedRule({
+      id: "rendered/spill",
+      code: QUALITY_CODES.RENDERED_SPILL,
+      description: "A framed paragraph or slide text box drawn wider (DOCX) or larger (PPTX) than the box it declared.",
+      category: "integrity",
+      defaultSeverity: "warning"
+    }),
+    renderedRule({
+      id: "rendered/overlap",
+      code: QUALITY_CODES.RENDERED_OVERLAP,
+      description: "Two words from different lines whose boxes intersect by more than 30% of the smaller.",
+      category: "integrity",
+      defaultSeverity: "warning"
+    }),
+    renderedRule({
+      id: "rendered/text-missing",
+      code: QUALITY_CODES.RENDERED_TEXT_MISSING,
+      description: "An authored string that appears nowhere in the PDF: fully clipped, hidden, or dropped by the renderer.",
+      category: "integrity",
+      defaultSeverity: "warning"
+    }),
+    renderedRule({
+      id: "rendered/font-substituted",
+      code: QUALITY_CODES.RENDERED_FONT_SUBSTITUTED,
+      description: "A requested family the PDF embeds no face of; a warning when the document declared a source for it, information when the host simply lacks it.",
+      category: "brand",
+      defaultSeverity: "info"
+    }),
+    renderedRule({
+      id: "rendered/empty-page",
+      code: QUALITY_CODES.RENDERED_EMPTY_PAGE,
+      description: "A page with no text at all: a full-page figure is fine, a blank page from a stray break is not.",
+      category: "integrity",
+      defaultSeverity: "info"
+    }),
+    renderedRule({
+      id: "rendered/heading-stranded",
+      code: QUALITY_CODES.RENDERED_HEADING_STRANDED,
+      description: "A heading that is the last body line on its page.",
+      category: "composition",
+      defaultSeverity: "warning",
+      formats: ["docx"]
+    }),
+    renderedRule({
+      id: "rendered/paragraph-split",
+      code: QUALITY_CODES.RENDERED_PARAGRAPH_SPLIT,
+      description: "A paragraph leaving one line alone on either side of a page break (`kind: orphan` or `widow`).",
+      category: "composition",
+      defaultSeverity: "info",
+      formats: ["docx"]
+    })
+  ]
+};
 
 // src/rendered-text-match.ts
 function normalizeForMatch(value) {
@@ -1968,17 +2052,108 @@ function indexDocument(pages, exclude = /* @__PURE__ */ new Set()) {
   const positions = [];
   let cursor = 0;
   pages.forEach((page, pageIndex) => {
-    page.words.forEach((word, index) => {
+    for (const index of readingOrder(page.words)) {
+      const word = page.words[index];
       const key = `${pageIndex}:${index}`;
       const fragment = exclude.has(key) ? "" : normalizeForMatch(word.text);
       refs.push({ pageIndex, word: index });
       fragments.push(fragment);
       positions.push(cursor);
       cursor += fragment.length;
-    });
+    }
   });
   return { pages, refs, fragments, positions, stream: fragments.join("") };
 }
+function readingOrder(words2) {
+  const rotated = new Set(
+    words2.map((_, i) => i).filter((i) => {
+      const w = words2[i];
+      return w.text.length > 2 && w.yMax - w.yMin > 1.5 * (w.xMax - w.xMin);
+    })
+  );
+  const upright = uprightOrder(
+    words2,
+    words2.map((_, i) => i).filter((i) => !rotated.has(i))
+  );
+  const order = [];
+  let next = 0;
+  for (let i = 0; i < words2.length; i++) {
+    if (rotated.has(i)) order.push(i);
+    else order.push(upright[next++]);
+  }
+  return order;
+}
+function uprightOrder(words2, indices) {
+  const rows = [];
+  const byY = [...indices].sort(
+    (a, b) => words2[a].yMin - words2[b].yMin || words2[a].xMin - words2[b].xMin
+  );
+  for (const i of byY) {
+    const row = rows[rows.length - 1];
+    if (row && sameRow(words2[row[0]], words2[i])) row.push(i);
+    else rows.push([i]);
+  }
+  const fragmentsOf = (row) => {
+    const sorted = [...row].sort((a, b) => words2[a].xMin - words2[b].xMin);
+    const out = [];
+    for (const i of sorted) {
+      const last = out[out.length - 1];
+      const w = words2[i];
+      const height = w.yMax - w.yMin;
+      if (last && w.xMin - last.xMax <= height / 2) {
+        last.words.push(i);
+        last.xMax = Math.max(last.xMax, w.xMax);
+      } else out.push({ xMin: w.xMin, xMax: w.xMax, words: [i] });
+    }
+    return out;
+  };
+  const fragments = rows.map(fragmentsOf);
+  const boxes = rows.map((row) => ({
+    yMin: Math.min(...row.map((i) => words2[i].yMin)),
+    yMax: Math.max(...row.map((i) => words2[i].yMax))
+  }));
+  const order = [];
+  let cluster = null;
+  const flush = () => {
+    if (!cluster) return;
+    if (!cluster.multi) {
+      for (const r of cluster.rows)
+        for (const f of fragments[r]) order.push(...f.words);
+    } else {
+      cluster.columns.sort((a, b) => a.xMin - b.xMin);
+      for (const column of cluster.columns) {
+        column.fragments.sort(
+          (a, b) => words2[a.words[0]].yMin - words2[b.words[0]].yMin || a.xMin - b.xMin
+        );
+        for (const f of column.fragments) order.push(...f.words);
+      }
+    }
+    cluster = null;
+  };
+  const overlapping = (columns, f) => columns.filter(
+    (c) => Math.min(c.xMax, f.xMax) - Math.max(c.xMin, f.xMin) > 0
+  );
+  for (let r = 0; r < rows.length; r++) {
+    const lineHeight = boxes[r].yMax - boxes[r].yMin;
+    const adjacent = cluster !== null && boxes[r].yMin - boxes[r - 1].yMax <= lineHeight * 0.9;
+    const wide = cluster !== null && fragments[r].some((f) => overlapping(cluster.columns, f).length > 1);
+    if (!adjacent || wide) flush();
+    if (!cluster) cluster = { rows: [], columns: [], multi: false };
+    cluster.rows.push(r);
+    if (fragments[r].length > 1) cluster.multi = true;
+    for (const f of fragments[r]) {
+      const hit = overlapping(cluster.columns, f)[0];
+      if (hit) {
+        hit.xMin = Math.min(hit.xMin, f.xMin);
+        hit.xMax = Math.max(hit.xMax, f.xMax);
+        hit.fragments.push(f);
+      } else
+        cluster.columns.push({ xMin: f.xMin, xMax: f.xMax, fragments: [f] });
+    }
+  }
+  flush();
+  return order;
+}
 function fragmentAt(index, offset) {
   let low = 0;
   let high = index.positions.length - 1;
@@ -2142,7 +2317,7 @@ function assignInventory(pages, inventory) {
     });
   });
   const body = indexDocument(pages, chromeWords);
-  const claimed = /* @__PURE__ */ new Set();
+  const claimed = /* @__PURE__ */ new Map();
   let cursor = 0;
   for (const entry of inventory) {
     if (entry.repeats) continue;
@@ -2154,7 +2329,7 @@ function assignInventory(pages, inventory) {
     }
     let all = findOccurrences(body, segments);
     let partial;
-    if (all.length === 0 && segments.length === 1) {
+    if (all.length === 0 && segments.length === 1 && !entry.optional) {
       const prefix = longestRenderedPrefix(body, needle);
       if (prefix) {
         all = [occurrence(body, prefix.at, prefix.at + prefix.length)];
@@ -2162,10 +2337,29 @@ function assignInventory(pages, inventory) {
       }
     }
     if (all.length === 0) {
-      results.set(entry, { entry, needle, status: "missing", occurrences: [] });
+      results.set(entry, {
+        entry,
+        needle,
+        status: entry.optional ? "skipped" : "missing",
+        occurrences: []
+      });
       continue;
     }
-    const free = all.filter((o) => !claimed.has(o.at));
+    let free = all.filter((o) => !claimed.has(o.at));
+    if (free.length === 0 && !entry.optional) {
+      const held = all.find((o) => claimed.get(o.at)?.optional);
+      if (held) {
+        const holder = claimed.get(held.at);
+        claimed.delete(held.at);
+        results.set(holder, {
+          entry: holder,
+          needle: results.get(holder)?.needle ?? "",
+          status: "skipped",
+          occurrences: []
+        });
+        free = [held];
+      }
+    }
     if (free.length === 0) {
       results.set(entry, {
         entry,
@@ -2176,7 +2370,7 @@ function assignInventory(pages, inventory) {
       continue;
     }
     const chosen = free.find((o) => o.at >= cursor) ?? free[0];
-    claimed.add(chosen.at);
+    claimed.set(chosen.at, entry);
     cursor = chosen.at;
     results.set(entry, {
       entry,
@@ -2193,15 +2387,23 @@ function assignInventory(pages, inventory) {
 }
 
 // src/rendered-analysis.ts
+function isRenderedGeometryFact(fact) {
+  return fact.kind === "rendered/geometry";
+}
+var drafts = /* @__PURE__ */ new WeakMap();
+function renderedDraftFor(fact) {
+  let draft = drafts.get(fact);
+  if (!draft) {
+    draft = draftRenderedFindings(fact.input);
+    drafts.set(fact, draft);
+  }
+  return draft;
+}
 var VISIBLE_SPILL_PT = 2;
 var OVERLAP_FRACTION = 0.3;
 function finding(draft) {
-  const { ruleId, mapping, page, context, ...rest } = draft;
+  const { mapping, page, context, ...rest } = draft;
   return {
-    source: "quality",
-    ruleId,
-    certainty: "rendered",
-    blocking: false,
     ...rest,
     context: {
       ...context,
@@ -2259,7 +2461,7 @@ function unionBox(parts) {
     { xMin: Infinity, yMin: Infinity, xMax: -Infinity, yMax: -Infinity }
   );
 }
-function analyzeRenderedDocument(input) {
+function draftRenderedFindings(input) {
   const { pages, format } = input;
   const { matches, chromeWords } = assignInventory(pages, input.inventory);
   const owners = wordOwners(matches);
@@ -2293,9 +2495,6 @@ function analyzeRenderedDocument(input) {
     findings.push(
       finding({
         ruleId: "rendered/clip",
-        code: QUALITY_CODES.RENDERED_CLIP,
-        category: "integrity",
-        severity: "warning",
         mapping: bucket.match ? "mapped" : "unmapped",
         page: bucket.page,
         path: bucket.match?.entry.path ?? "",
@@ -2320,9 +2519,6 @@ function analyzeRenderedDocument(input) {
     findings.push(
       finding({
         ruleId: "rendered/clip",
-        code: QUALITY_CODES.RENDERED_CLIP,
-        category: "integrity",
-        severity: "warning",
         mapping: "mapped",
         page: o.endPageIndex + 1,
         path: match.entry.path,
@@ -2359,9 +2555,6 @@ function analyzeRenderedDocument(input) {
       findings.push(
         finding({
           ruleId: "rendered/spill",
-          code: QUALITY_CODES.RENDERED_SPILL,
-          category: "integrity",
-          severity: "warning",
           mapping: "mapped",
           page: o.pageIndex + 1,
           path: match.entry.path,
@@ -2381,14 +2574,14 @@ function analyzeRenderedDocument(input) {
   pages.forEach((page, pageIndex) => {
     const lines = lineOfWord(page);
     const seen = /* @__PURE__ */ new Set();
-    const words = page.words;
-    const byTop = words.map((_, i) => i).sort((a, b) => words[a].yMin - words[b].yMin);
+    const words2 = page.words;
+    const byTop = words2.map((_, i) => i).sort((a, b) => words2[a].yMin - words2[b].yMin);
     for (let p = 0; p < byTop.length; p++) {
       const i = byTop[p];
-      const a = words[i];
+      const a = words2[i];
       for (let q = p + 1; q < byTop.length; q++) {
         const j = byTop[q];
-        const b = words[j];
+        const b = words2[j];
         if (b.yMin >= a.yMax) break;
         const shared = intersects(a, b);
         if (shared <= 0) continue;
@@ -2407,9 +2600,6 @@ function analyzeRenderedDocument(input) {
         findings.push(
           finding({
             ruleId: "rendered/overlap",
-            code: QUALITY_CODES.RENDERED_OVERLAP,
-            category: "integrity",
-            severity: "warning",
             mapping,
             page: pageIndex + 1,
             path: pathA || pathB,
@@ -2432,9 +2622,6 @@ function analyzeRenderedDocument(input) {
     findings.push(
       finding({
         ruleId: "rendered/text-missing",
-        code: QUALITY_CODES.RENDERED_TEXT_MISSING,
-        category: "integrity",
-        severity: "warning",
         mapping: "mapped",
         path: match.entry.path,
         message: `"${excerpt(match.entry.text)}" does not appear anywhere in the rendered pages.`,
@@ -2456,8 +2643,6 @@ function analyzeRenderedDocument(input) {
       findings.push(
         finding({
           ruleId: "rendered/font-substituted",
-          code: QUALITY_CODES.RENDERED_FONT_SUBSTITUTED,
-          category: "brand",
           severity: requested.declared ? "warning" : "info",
           mapping: requested.path ? "mapped" : "unmapped",
           path: requested.path ?? "",
@@ -2478,9 +2663,6 @@ function analyzeRenderedDocument(input) {
     findings.push(
       finding({
         ruleId: "rendered/empty-page",
-        code: QUALITY_CODES.RENDERED_EMPTY_PAGE,
-        category: "integrity",
-        severity: "info",
         mapping: "unmapped",
         page: pageIndex + 1,
         path: "",
@@ -2503,9 +2685,6 @@ function analyzeRenderedDocument(input) {
       findings.push(
         finding({
           ruleId: "rendered/heading-stranded",
-          code: QUALITY_CODES.RENDERED_HEADING_STRANDED,
-          category: "composition",
-          severity: "warning",
           mapping: "mapped",
           page: part.pageIndex + 1,
           path: match.entry.path,
@@ -2539,9 +2718,6 @@ function analyzeRenderedDocument(input) {
       findings.push(
         finding({
           ruleId: "rendered/paragraph-split",
-          code: QUALITY_CODES.RENDERED_PARAGRAPH_SPLIT,
-          category: "composition",
-          severity: "info",
           mapping: "mapped",
           page: (which === "orphan" ? first.pageIndex : last.pageIndex) + 1,
           path: match.entry.path,
@@ -2563,56 +2739,526 @@ function analyzeRenderedDocument(input) {
     skipped: 0
   };
   for (const match of matches) inventory[match.status] += 1;
+  const byRule = /* @__PURE__ */ new Map();
+  for (const draft of findings) {
+    const bucket = byRule.get(draft.ruleId);
+    if (bucket) bucket.push(draft);
+    else byRule.set(draft.ruleId, [draft]);
+  }
+  return {
+    drafts: findings,
+    byRule,
+    inventory,
+    // The same gate the check itself runs under: an empty font list
+    // verified nothing, and must not read as "nothing was substituted".
+    ...input.fonts && input.fonts.length > 0 && input.requestedFonts && {
+      fonts: { requested: input.requestedFonts.length, substituted }
+    }
+  };
+}
+var engine;
+function renderedEngine() {
+  engine ??= new QualityEngine(RENDERED_QUALITY_RULES.rules);
+  return engine;
+}
+function analyzeRenderedDocument(input, options = {}) {
+  const fact = {
+    id: "rendered:geometry",
+    kind: "rendered/geometry",
+    path: "",
+    input
+  };
+  const analysis = renderedEngine().analyzeSync(
+    {
+      format: input.format,
+      model: void 0,
+      facts: [fact],
+      provenance: {},
+      ...input.renderer !== void 0 && { renderer: input.renderer }
+    },
+    options
+  );
+  let draft;
+  try {
+    draft = renderedDraftFor(fact);
+  } catch {
+    draft = void 0;
+  }
   const byMapping = {
     mapped: 0,
     ambiguous: 0,
     unmapped: 0
   };
-  for (const f of findings) {
+  for (const f of analysis.diagnostics) {
     byMapping[f.context?.mapping ?? "unmapped"] += 1;
   }
   return {
-    findings,
+    findings: analysis.diagnostics,
     summary: {
-      pages: pages.length,
-      words: pages.reduce((n, p) => n + p.words.length, 0),
-      inventory,
+      pages: input.pages.length,
+      words: input.pages.reduce((n, p) => n + p.words.length, 0),
+      inventory: draft?.inventory ?? {
+        mapped: 0,
+        ambiguous: 0,
+        missing: 0,
+        skipped: 0
+      },
       findings: byMapping,
-      // The same gate the check itself runs under: an empty font list
-      // verified nothing, and must not read as "nothing was substituted".
-      ...input.fonts && input.fonts.length > 0 && input.requestedFonts && {
-        fonts: { requested: input.requestedFonts.length, substituted }
+      ...draft?.fonts && { fonts: draft.fonts },
+      suppressed: analysis.suppressedCount,
+      blocked: analysis.blocked,
+      truncated: analysis.truncated,
+      ...analysis.profileId !== void 0 && {
+        profileId: analysis.profileId
       }
+    },
+    analysis
+  };
+}
+
+// src/block-matrix.ts
+import {
+  blockDependencies,
+  readBlockDefinitions
+} from "@json-to-office/shared";
+var FALLBACK_FONTS = {
+  heading: { family: "DejaVu Sans" },
+  body: { family: "DejaVu Sans" }
+};
+var MATRIX_IMAGE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAYAAABytg0kAAAAFElEQVR42mNk+M9QzwAFjDAGACPuA/8fMSCgAAAAAElFTkSuQmCC";
+var WORDS = [
+  "performance",
+  "delivery",
+  "retention",
+  "operating",
+  "programme",
+  "contracted",
+  "recommendation",
+  "quarter",
+  "measurement",
+  "ownership",
+  "renewal",
+  "segment",
+  "margin",
+  "baseline",
+  "procurement",
+  "integration"
+];
+function words(count, seed, sentence) {
+  if (count <= 0) return "";
+  const out = [`Item${seed}`];
+  for (let i = 1; i < count; i += 1) out.push(WORDS[(seed + i) % WORDS.length]);
+  return sentence ? `${out.join(" ")}.` : out.join(" ");
+}
+function widestNumber(length, seed = 0) {
+  if (length <= 0) return "";
+  if (length === 1) return "9";
+  if (length < 4) return `\u2212${"9".repeat(length - 1)}`;
+  const group = (digits2) => Array.from({ length: digits2 }, (_, i) => String((i + seed) % 9 + 1)).join("").replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  let digits = 1;
+  while (group(digits + 1).length + 3 <= length) digits += 1;
+  const integer = group(digits);
+  return `\u2212${integer}.${"0".repeat(length - integer.length - 2)}`;
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var NUMERIC_SLOTS = /* @__PURE__ */ new Set(["value", "delta", "cells"]);
+function stringValue(slot, name, edge, seed) {
+  if (slot.enum && slot.enum.length > 0) {
+    const values = slot.enum.map(String);
+    return edge === "max" ? values.reduce((a, b) => b.length > a.length ? b : a) : values[0];
+  }
+  if (slot.maxLength !== void 0 && NUMERIC_SLOTS.has(name)) {
+    return widestNumber(
+      edge === "max" ? slot.maxLength : Math.min(3, slot.maxLength),
+      seed
+    );
+  }
+  if (slot.maxLength !== void 0 && name === "unit") {
+    return edge === "max" ? ` \u20AC${"m".repeat(Math.max(0, slot.maxLength - 2))}`.slice(
+      0,
+      slot.maxLength
+    ) : "%";
+  }
+  if (slot.maxLength !== void 0) {
+    const target = edge === "max" ? slot.maxLength : Math.max(1, slot.minLength ?? 1);
+    let text = `Item${seed}`.slice(0, target);
+    let i = 0;
+    for (; ; ) {
+      const next = WORDS[(seed + i) % WORDS.length];
+      i += 1;
+      if (text.length + 1 + next.length > target) {
+        if (i > WORDS.length) break;
+        continue;
+      }
+      text += ` ${next}`;
+    }
+    return text;
+  }
+  const budget = slot.maxWords ?? 12;
+  const count = edge === "max" ? budget : Math.max(1, Math.min(2, budget));
+  const sentence = !slot.oneLine && slot.role !== "source";
+  if (slot.role === "source") return `Source: ${words(count - 1, seed, false)}`;
+  if (name === "number")
+    return edge === "max" ? words(count, seed, false) : "01";
+  return words(count, seed, sentence);
+}
+function componentValue(name, edge, seed) {
+  if (name === "chart") {
+    const categories = edge === "max" ? 8 : 2;
+    const series = edge === "max" ? 3 : 1;
+    return {
+      name: "chart",
+      props: {
+        type: "column",
+        valAxisTitle: edge === "max" ? `${words(3, seed, false)} (\u20ACm)` : "Revenue (\u20ACm)",
+        ...edge === "max" && { catAxisTitle: words(3, seed + 3, false) },
+        chartColors: ["primary", "secondary", "accent"].slice(0, series),
+        data: Array.from({ length: series }, (_, s) => ({
+          name: words(edge === "max" ? 3 : 1, seed + s, false),
+          // Two words per category is where LibreOffice's native chart
+          // still keeps rotated labels clear of the axis title; at three
+          // the title is drawn over them, at any category count.
+          labels: Array.from(
+            { length: categories },
+            (_2, c) => edge === "max" ? words(2, seed + c, false) : `Q${c + 1}`
+          ),
+          values: Array.from(
+            { length: categories },
+            (_2, c) => 1.2 * (c + 1) + s
+          )
+        }))
+      }
+    };
+  }
+  return {
+    name: "image",
+    props: {
+      base64: MATRIX_IMAGE,
+      width: edge === "max" ? name === "logo" ? "40%" : "100%" : "25%",
+      alt: words(6, seed, false)
+    }
+  };
+}
+function boundarySlotValue(slot, name, edge, seed = 0) {
+  switch (slot.type) {
+    case "string":
+      return stringValue(slot, name, edge, seed);
+    case "number":
+    case "integer":
+      return edge === "max" ? slot.maximum ?? 9999 : slot.minimum ?? 0;
+    case "boolean":
+      return edge === "max" ? true : slot.default ?? true;
+    case "component":
+      return componentValue(name, edge, seed);
+    case "object": {
+      const out = {};
+      for (const [key, property] of Object.entries(slot.properties ?? {})) {
+        if (edge === "min" && !property.required) continue;
+        const value = boundarySlotValue(property, key, edge, seed + key.length);
+        if (value !== void 0) out[key] = value;
+      }
+      return out;
+    }
+    case "array": {
+      const count = edge === "max" ? slot.maxItems ?? 3 : slot.minItems ?? (slot.required ? 1 : 0);
+      const item = slot.items ?? { type: "string" };
+      return Array.from(
+        { length: count },
+        (_, i) => boundarySlotValue(item, name, edge, seed + i)
+      );
+    }
+    default:
+      return void 0;
+  }
+}
+function boundaryInvocation(name, definition, edge, seed = 0, requiredRoles = []) {
+  const slots = {};
+  let offset = seed;
+  for (const [slotName, slot] of Object.entries(definition.slots)) {
+    offset += slotName.length;
+    const required = slot.required === true || slot.role !== void 0 && requiredRoles.includes(slot.role);
+    if (edge === "min" && !required) continue;
+    const value = boundarySlotValue(slot, slotName, edge, offset);
+    if (value !== void 0) slots[slotName] = value;
+  }
+  const labels = slots.labels;
+  const columns = slots.columns;
+  if (Array.isArray(labels) && Array.isArray(columns)) {
+    const cells = definition.slots.columns?.items?.properties?.cells;
+    for (const column of columns) {
+      if (isRecord(column) && Array.isArray(column.cells) && cells?.items) {
+        column.cells = labels.map(
+          (_, i) => boundarySlotValue(cells.items, "cells", edge, offset + i)
+        );
+      }
+    }
+  }
+  return { name: "block", props: { ref: name, slots } };
+}
+function overBudgetInvocation(name, definition, seed = 0) {
+  const invocation = boundaryInvocation(name, definition, "max", seed);
+  const slots = invocation.props.slots;
+  for (const [slotName, slot] of Object.entries(definition.slots)) {
+    if (slot.type === "string" && slot.maxWords !== void 0) {
+      slots[slotName] = `${words(slot.maxWords + 1, seed, !slot.oneLine)}`;
+      return { invocation, slot: slotName, kind: "words" };
+    }
+  }
+  for (const [slotName, slot] of Object.entries(definition.slots)) {
+    if (slot.type === "array" && slot.maxItems !== void 0 && Array.isArray(slots[slotName])) {
+      const items = slots[slotName];
+      slots[slotName] = [...items, items[0]];
+      return { invocation, slot: slotName, kind: "items" };
+    }
+  }
+  return void 0;
+}
+function enumerateBlockDefinitions(template, templateName) {
+  const definitions = readBlockDefinitions(template);
+  const examples = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(walk);
+      return;
     }
+    if (!isRecord(node)) return;
+    const props = node.props;
+    if (node.name === "block" && isRecord(props) && typeof props.ref === "string" && !examples.has(props.ref)) {
+      examples.set(props.ref, isRecord(props.slots) ? props.slots : {});
+    }
+    walk(node.children);
   };
+  walk(isRecord(template) ? template.children : void 0);
+  return Object.entries(definitions).map(([name, definition]) => ({
+    name,
+    template: templateName,
+    pointer: `/props/blocks/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`,
+    definition,
+    ...examples.has(name) && { example: examples.get(name) }
+  }));
+}
+var CHROME = ["cover", "running-head", "section-opener"];
+function nominal(entry, name, definitions) {
+  if (!entry) return void 0;
+  if (entry.example) {
+    return {
+      name: "block",
+      props: { ref: name, slots: structuredClone(entry.example) }
+    };
+  }
+  return boundaryInvocation(name, definitions[name], "min");
+}
+function inlineImages(value) {
+  if (Array.isArray(value)) return value.map(inlineImages);
+  if (!isRecord(value)) return value;
+  if (value.name === "image" && isRecord(value.props) && typeof value.props.path === "string") {
+    const props = { ...value.props, base64: MATRIX_IMAGE };
+    delete props.path;
+    return { ...value, props };
+  }
+  if (value.name === "highcharts") return componentValue("chart", "min", 0);
+  return Object.fromEntries(
+    Object.entries(value).map(([k, v]) => [k, inlineImages(v)])
+  );
+}
+function withDefinitions(definitions, names) {
+  const out = {};
+  for (const name of names) {
+    if (!(name in definitions)) continue;
+    out[name] = definitions[name];
+    for (const dependency of blockDependencies(definitions, name)) {
+      if (dependency in definitions) out[dependency] = definitions[dependency];
+    }
+  }
+  return out;
+}
+function conditions(props, children, theme, font, canvas) {
+  const sections = children.map((child) => {
+    if (!isRecord(child) || child.name !== "section") return child;
+    const props2 = isRecord(child.props) ? child.props : {};
+    const page = isRecord(props2.page) ? props2.page : {};
+    return { ...child, props: { ...props2, page: { ...page, size: canvas } } };
+  });
+  const chart = JSON.stringify(sections).includes('"name":"chart"');
+  return {
+    name: "docx",
+    ...chart && { renderer: "office-open" },
+    props: {
+      ...props,
+      theme,
+      ...font === "fallback" && { themeOverrides: { fonts: FALLBACK_FONTS } }
+    },
+    children: sections
+  };
+}
+var BODY_COPY = words(40, 1e3, true);
+function blockCaseDocument(entries, name, edge, theme, { font = "design", canvas = "A4", requiredRoles = [] } = {}) {
+  const definitions = Object.fromEntries(
+    entries.map((e) => [e.name, e.definition])
+  );
+  const byName = new Map(entries.map((e) => [e.name, e]));
+  const under = (chrome) => chrome === name ? boundaryInvocation(name, definitions[name], edge, 0, requiredRoles) : inlineImages(nominal(byName.get(chrome), chrome, definitions));
+  const cover = under("cover");
+  const runningHead = under("running-head");
+  const opener = under("section-opener");
+  const body = [];
+  if (!CHROME.includes(name)) {
+    if (name === "footnotes" && byName.has("figure")) {
+      body.push(
+        inlineImages(nominal(byName.get("figure"), "figure", definitions))
+      );
+    }
+    body.push(
+      boundaryInvocation(name, definitions[name], edge, 0, requiredRoles)
+    );
+  }
+  body.push({ name: "paragraph", props: { text: BODY_COPY } });
+  const used = /* @__PURE__ */ new Set([
+    name,
+    ...CHROME,
+    ...name === "footnotes" ? ["figure"] : []
+  ]);
+  const children = [];
+  if (cover) children.push({ name: "section", children: [cover] });
+  children.push({
+    name: "section",
+    children: [runningHead, opener, ...body].filter((c) => c !== void 0)
+  });
+  return conditions(
+    {
+      metadata: {
+        title: "Boundary report",
+        author: "jto-ops block matrix",
+        company: "Example client",
+        date: "September 2026"
+      },
+      blocks: withDefinitions(definitions, used)
+    },
+    children,
+    theme,
+    font,
+    canvas
+  );
+}
+function reportCaseDocument(template, edge, theme, { font = "design", canvas = "A4", requiredRoles = [] } = {}) {
+  if (!isRecord(template) || !isRecord(template.props))
+    throw new Error("A template is a document with props.");
+  const definitions = readBlockDefinitions(template);
+  let seed = 0;
+  const rewrite = (node) => {
+    if (Array.isArray(node)) return node.map(rewrite);
+    if (!isRecord(node)) return node;
+    const props2 = node.props;
+    if (node.name === "block" && isRecord(props2) && typeof props2.ref === "string" && definitions[props2.ref]) {
+      seed += 7;
+      return boundaryInvocation(
+        props2.ref,
+        definitions[props2.ref],
+        edge,
+        seed,
+        requiredRoles
+      );
+    }
+    if (node.name === "paragraph" && isRecord(props2) && typeof props2.text === "string") {
+      return {
+        ...node,
+        props: { ...props2, text: edge === "max" ? BODY_COPY : props2.text }
+      };
+    }
+    return Array.isArray(node.children) ? { ...node, children: rewrite(node.children) } : node;
+  };
+  const props = structuredClone(template.props);
+  delete props.theme;
+  delete props.themeOverrides;
+  return conditions(
+    props,
+    rewrite(template.children),
+    theme,
+    font,
+    canvas
+  );
+}
+function generateBlockMatrix(template, templateName, options) {
+  const entries = enumerateBlockDefinitions(template, templateName);
+  const fonts = options.fonts ?? ["design", "fallback"];
+  const edges = options.edges ?? ["min", "max"];
+  const canvases = options.canvases ?? ["A4"];
+  const cases = [];
+  for (const theme of options.themes)
+    for (const font of fonts)
+      for (const canvas of canvases)
+        for (const edge of edges) {
+          if (options.blocks !== false)
+            for (const entry of entries)
+              cases.push({
+                id: `${entry.name}@${edge}/${theme}/${font}/${canvas}`,
+                block: entry.name,
+                edge,
+                theme,
+                font,
+                canvas,
+                document: blockCaseDocument(entries, entry.name, edge, theme, {
+                  font,
+                  canvas,
+                  requiredRoles: options.requiredRoles
+                })
+              });
+          if (options.report !== false)
+            cases.push({
+              id: `report@${edge}/${theme}/${font}/${canvas}`,
+              block: "report",
+              edge,
+              theme,
+              font,
+              canvas,
+              document: reportCaseDocument(template, edge, theme, {
+                font,
+                canvas,
+                requiredRoles: options.requiredRoles
+              })
+            });
+        }
+  return cases;
 }
 export {
   DocxFormatAdapter,
+  FALLBACK_FONTS,
   FontconfigStager,
+  MATRIX_IMAGE,
   MacOSCoreTextStager,
   NoopFontStager,
   PptxFormatAdapter,
+  RENDERED_QUALITY_RULES,
   VISIBLE_SPILL_PT,
   WindowsFontStager,
   analyzeRenderedDocument,
   assignInventory,
   authoredTextForMatch,
+  blockCaseDocument,
+  boundaryInvocation,
+  boundarySlotValue,
   clearRasterizerCache,
   createAdapter,
   createLibreOfficePptxBatchRasterizer,
   createLibreOfficePptxRasterizer,
   emitDiagnostic,
+  enumerateBlockDefinitions,
   extractPdfFonts,
   extractPdfTextGeometry,
   familyRendered,
+  generateBlockMatrix,
   getFontStager,
   getRasterizerCacheStats,
   normalizeForMatch,
+  overBudgetInvocation,
   parsePdfFonts,
   parsePdfTextBbox,
   pdffontsAvailable,
   pdftotextAvailable,
+  readingOrder,
+  reportCaseDocument,
   runWithDiagnosticSink,
-  stderrDiagnosticSink
+  stderrDiagnosticSink,
+  widestNumber
 };
 //# sourceMappingURL=index.js.map