@json-to-office/jto-ops 6.8.0 → 7.0.1

package/dist/index.js

@@ -1061,6 +1061,7 @@ var DocxFormatAdapter = class {
       options.services
     );
     const prepared = !hasPlugins && options.prepared?.format === "docx" ? options.prepared : void 0;
+    const pluginPrepared = hasPlugins && options.prepared?.format === "docx" ? options.prepared : void 0;
     const resolved = prepared ? void 0 : await this.resolveThemes(options);
     const requestedTheme = resolved?.requested;
     const customThemes = resolved?.customThemes;
@@ -1136,6 +1137,7 @@ var DocxFormatAdapter = class {
           requestedTheme,
           customThemes
         );
+        const usable = preparedFor(pluginPrepared, parsed);
         const result = await generator.generateBuffer(docDefinition, {
           validation: {
             allowUnknownFields: options.validation?.allowUnknownFields
@@ -1144,10 +1146,12 @@ var DocxFormatAdapter = class {
           generatedAt: options.generatedAt,
           baseDir: options.baseDir,
           renderer: options.renderer,
-          svgRasterFallback: options.svgRasterFallback
+          svgRasterFallback: options.svgRasterFallback,
+          ...usable && { prepared: usable }
         });
-        emitGenerationWarnings(result.warnings ?? []);
-        options.warnings?.push(...toGenerationWarnings(result.warnings));
+        const emitted = withoutPreparedWarnings(result.warnings ?? [], usable);
+        emitGenerationWarnings(emitted);
+        options.warnings?.push(...toGenerationWarnings(emitted));
         return result.buffer;
       },
       getStandardDefinition: generator.expandStandardDefinition ? async (config) => {
@@ -1230,15 +1234,35 @@ var DocxFormatAdapter = class {
       resolved.requested,
       resolved.customThemes
     );
-    const prepared = core.prepareDocxQualityDocument(
-      normalized.document,
-      {
-        customThemes: normalized.customThemes,
+    const prepared = options.plugins && options.plugins.length > 0 ? await (async () => {
+      let generator = core.createDocumentGenerator({
+        theme: resolved.requested,
+        customThemes: resolved.requested ? {
+          ...resolved.customThemes,
+          [CLI_THEME_KEY]: resolved.requested
+        } : resolved.customThemes,
+        services: withRequestedServices(
+          buildDocxServices(),
+          options.services
+        ),
+        baseDir: options.baseDir,
         fonts: options.fonts,
-        renderer: options.renderer ?? documentRenderer(parsed),
-        warnings
-      }
-    );
+        validation: {
+          allowUnknownFields: options.validation?.allowUnknownFields
+        },
+        renderer: options.renderer
+      });
+      for (const plugin of options.plugins)
+        generator = generator.addComponent(plugin);
+      const result = await generator.prepareQuality(normalized.document);
+      warnings.push(...result.warnings ?? []);
+      return result.prepared;
+    })() : core.prepareDocxQualityDocument(normalized.document, {
+      customThemes: normalized.customThemes,
+      fonts: options.fonts,
+      renderer: options.renderer ?? documentRenderer(parsed),
+      warnings
+    });
     return stampPrepared(
       {
         ...prepared,
@@ -1269,7 +1293,7 @@ var DocxFormatAdapter = class {
   async resolveTheme(options) {
     const core = await import("@json-to-office/core-docx");
     const { requested } = await this.resolveThemes(options);
-    return requested ?? core.themes?.minimal ?? {};
+    return requested ?? core.themes?.consulting ?? {};
   }
   /**
    * Resolve `theme`/`themePath` once for a whole run: `themePath` is read a
@@ -1430,6 +1454,7 @@ var PptxFormatAdapter = class {
       options.services
     );
     const prepared = !hasPlugins && options.prepared?.format === "pptx" ? options.prepared : void 0;
+    const pluginPrepared = hasPlugins && options.prepared?.format === "pptx" ? options.prepared : void 0;
     const resolved = prepared ? void 0 : await this.resolveThemes(options);
     const requestedTheme = resolved?.requested;
     const customThemes = resolved?.customThemes;
@@ -1504,6 +1529,7 @@ var PptxFormatAdapter = class {
           requestedTheme,
           customThemes
         );
+        const usable = preparedFor(pluginPrepared, parsed);
         const result = await generator.generateBuffer(docDefinition, {
           validation: {
             allowUnknownFields: options.validation?.allowUnknownFields
@@ -1511,9 +1537,13 @@ var PptxFormatAdapter = class {
           deterministic: options.deterministic,
           generatedAt: options.generatedAt,
           baseDir: options.baseDir,
-          renderer: options.renderer
+          renderer: options.renderer,
+          ...usable && { prepared: usable }
         });
-        const normalized = toGenerationWarnings(result.warnings);
+        const normalized = withoutPreparedWarnings(
+          toGenerationWarnings(result.warnings),
+          usable
+        );
         emitGenerationWarnings(normalized);
         options.warnings?.push(...normalized);
         return result.buffer;
@@ -1580,19 +1610,37 @@ var PptxFormatAdapter = class {
       resolved.requested,
       resolved.customThemes
     );
-    const prepared = core.preparePptxQualityDocument(
-      normalized.document,
-      {
-        customThemes: normalized.customThemes,
-        fonts: options.fonts,
-        services: withRequestedServices(
-          buildServicesFromEnv(),
-          options.services
-        ),
-        renderer: options.renderer ?? documentRenderer(parsed),
-        warnings
-      }
+    const services = withRequestedServices(
+      buildServicesFromEnv(),
+      options.services
     );
+    const prepared = options.plugins && options.plugins.length > 0 ? await (async () => {
+      let generator = core.createPresentationGenerator({
+        theme: resolved.requested,
+        customThemes: resolved.requested ? {
+          ...resolved.customThemes,
+          [CLI_THEME_KEY]: resolved.requested
+        } : resolved.customThemes,
+        services,
+        baseDir: options.baseDir,
+        fonts: options.fonts,
+        validation: {
+          allowUnknownFields: options.validation?.allowUnknownFields
+        },
+        renderer: options.renderer
+      });
+      for (const plugin of options.plugins)
+        generator = generator.addComponent(plugin);
+      const result = await generator.prepareQuality(normalized.document);
+      warnings.push(...result.warnings ?? []);
+      return result.prepared;
+    })() : core.preparePptxQualityDocument(normalized.document, {
+      customThemes: normalized.customThemes,
+      fonts: options.fonts,
+      services,
+      renderer: options.renderer ?? documentRenderer(parsed),
+      warnings
+    });
     return stampPrepared(
       {
         ...prepared,
@@ -1624,7 +1672,7 @@ var PptxFormatAdapter = class {
     const core = await import("@json-to-office/core-pptx");
     const themes = core.pptxThemes || {};
     const { requested } = await this.resolveThemes(options);
-    return requested ?? themes.minimal ?? {};
+    return requested ?? themes.consulting ?? {};
   }
   /**
    * Resolve `theme`/`themePath` once for a whole run: `themePath` is read a
@@ -2179,7 +2227,7 @@ function authoredTextForMatch(text) {
 function needleSegments(text) {
   return authoredTextForMatch(text).split(FIELD).map(normalizeForMatch).filter((segment) => segment !== "");
 }
-function indexDocument(pages, exclude = /* @__PURE__ */ new Set()) {
+function indexDocument(pages, exclude = /* @__PURE__ */ new Set(), order = pageOrder) {
   const refs = [];
   const fragments = [];
   const positions = [];
@@ -2193,13 +2241,13 @@ function indexDocument(pages, exclude = /* @__PURE__ */ new Set()) {
     positions.push(cursor);
     cursor += fragment.length;
   };
-  const orders = pages.map((page) => pageOrder(page.words, page.lines));
-  orders.forEach((order, pageIndex) => {
-    for (const index of order.upright) push(pageIndex, index);
+  const orders = pages.map((page) => order(page.words, page.lines));
+  orders.forEach((order2, pageIndex) => {
+    for (const index of order2.upright) push(pageIndex, index);
   });
   const rotatedFrom = cursor;
-  orders.forEach((order, pageIndex) => {
-    for (const index of order.rotated) push(pageIndex, index);
+  orders.forEach((order2, pageIndex) => {
+    for (const index of order2.rotated) push(pageIndex, index);
   });
   return {
     pages,
@@ -2224,6 +2272,16 @@ function pageOrder(words2, lines = []) {
     rotated: [...rotated].sort((a, b) => a - b)
   };
 }
+function linedOrder(words2, lines = []) {
+  const rotated = rotatedWords(words2, lines);
+  const upright = words2.map((_, i) => i).filter((i) => !rotated.has(i));
+  return {
+    upright: groupRows(words2, upright).flatMap(
+      (row) => [...row.words].sort((a, b) => words2[a].xMin - words2[b].xMin)
+    ),
+    rotated: [...rotated].sort((a, b) => a - b)
+  };
+}
 function rotatedWords(words2, lines) {
   const rotated = new Set(
     words2.map((_, i) => i).filter((i) => {
@@ -2637,6 +2695,30 @@ function overprintedOccurrence(index, page, region, needle, claimed) {
     })
   };
 }
+function linedOccurrence(lined, body, segments, claimed) {
+  const bodyFragment = /* @__PURE__ */ new Map();
+  body.refs.forEach((ref, i) => {
+    if (body.fragments[i] !== "")
+      bodyFragment.set(`${ref.pageIndex}:${ref.word}`, i);
+  });
+  for (const hit of findOccurrences(lined, segments)) {
+    const claims = [];
+    for (const part of hit.parts)
+      for (const word of part.words) {
+        const i = bodyFragment.get(`${part.pageIndex}:${word}`);
+        if (i === void 0) continue;
+        claims.push({
+          at: body.positions[i],
+          end: body.positions[i] + body.fragments[i].length
+        });
+      }
+    if (claims.length === 0 || claims.some((claim) => claimed(claim.at)))
+      continue;
+    const at = Math.min(...claims.map((claim) => claim.at));
+    return { occurrence: { ...hit, at, end: at }, claims };
+  }
+  return void 0;
+}
 function assignInventory(pages, inventory) {
   const results = /* @__PURE__ */ new Map();
   const chromeWords = /* @__PURE__ */ new Set();
@@ -2676,6 +2758,7 @@ function assignInventory(pages, inventory) {
   for (const row of pageNumberRows(pages, chromeWords))
     claimRow(row.pageIndex, row.box);
   const body = indexDocument(pages, chromeWords);
+  let lined;
   const claims = [];
   const claimsOver = (o) => claims.filter((claim) => o.at < claim.end && claim.at < o.end);
   let cursor = 0;
@@ -2705,6 +2788,19 @@ function assignInventory(pages, inventory) {
         sparse = overprinted.claims;
       }
     }
+    if (all.length === 0 && entry.page === void 0 && !entry.optional) {
+      lined ??= indexDocument(pages, chromeWords, linedOrder);
+      const found = linedOccurrence(
+        lined,
+        body,
+        segments,
+        (offset) => claims.some((claim) => claim.at <= offset && offset < claim.end)
+      );
+      if (found) {
+        all = [found.occurrence];
+        sparse = found.claims;
+      }
+    }
     if (all.length === 0 && segments.length === 1 && !entry.optional) {
       const prefix = longestRenderedPrefix(
         body,
@@ -3481,13 +3577,210 @@ function requestedFontsFromFacts(format, facts, resolvedFonts) {
 // src/block-matrix.ts
 import {
   blockDependencies,
+  blockReferencesFromDocument as blockReferencesFromDocument2,
+  readBlockDefinitions as readBlockDefinitions2
+} from "@json-to-office/shared";
+
+// src/matrix-inventory.ts
+import {
+  blockReferencesFromDocument,
   readBlockDefinitions
 } from "@json-to-office/shared";
+function matrixUniverse(format, themes) {
+  return {
+    themes: [...themes],
+    canvases: format === "docx" ? ["A4", "LETTER"] : ["wide169", "standard43"],
+    fonts: ["design", "fallback"],
+    edges: ["min", "max"]
+  };
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function templateFormat(name, document) {
+  const root = isRecord(document) ? document.name : void 0;
+  if (root === "docx" || root === "pptx") return root;
+  if (name.endsWith(".docx.json")) return "docx";
+  if (name.endsWith(".pptx.json")) return "pptx";
+  return void 0;
+}
+function authoredDeckCanvas(props) {
+  const width = typeof props.slideWidth === "number" ? props.slideWidth : 10;
+  const height = typeof props.slideHeight === "number" ? props.slideHeight : 7.5;
+  return Math.abs(width / height - 16 / 9) < Math.abs(width / height - 4 / 3) ? "wide169" : "standard43";
+}
+function requiredRoles(format, profile) {
+  const required = profile?.rules?.[`${format}/required-chrome`]?.parameters?.required;
+  return Array.isArray(required) ? required.filter((role) => typeof role === "string") : [];
+}
+function templateConditions(format, props, universe) {
+  const named = typeof props.theme === "string" ? props.theme : void 0;
+  const canvas = format === "pptx" ? authoredDeckCanvas(props) : void 0;
+  const canvasExclusions = (reason) => canvas === void 0 ? [] : universe.canvases.filter((c) => c !== canvas).map((c) => ({ condition: `canvas ${c}`, reason }));
+  if (named !== void 0 && universe.themes.includes(named)) {
+    return {
+      theme: named,
+      conditions: {
+        ...structuredClone(universe),
+        ...canvas !== void 0 && { canvases: [canvas] }
+      },
+      exclusions: canvasExclusions(
+        `slot budgets are measured on the ${canvas} slide the template is drawn on; another shape lays out, but holds fewer words`
+      )
+    };
+  }
+  const theme = named ?? "inline";
+  const why = named === void 0 ? "authored against the template's own theme object" : `authored against "${named}", which is no bundled theme`;
+  const exclusions = [
+    ...universe.themes.map((t) => ({ condition: `theme ${t}`, reason: why })),
+    ...canvasExclusions(
+      "absolute geometry fitted to the template's own slide size"
+    ),
+    ...canvas === void 0 ? universe.canvases.filter((c) => c !== "A4").map((c) => ({
+      condition: `canvas ${c}`,
+      reason: "absolute geometry fitted to the template's own page"
+    })) : [],
+    {
+      condition: "font fallback",
+      reason: "lines fitted to the template's own faces; a wider face is another design, not a boundary"
+    }
+  ];
+  return {
+    theme,
+    conditions: {
+      themes: [theme],
+      canvases: [canvas ?? "A4"],
+      fonts: ["design"],
+      edges: [...universe.edges]
+    },
+    exclusions
+  };
+}
+function buildMatrixInventory(templates, options) {
+  const inventory = { templates: [], entries: [] };
+  for (const source of templates) {
+    const format = templateFormat(source.name, source.document);
+    if (!format || !isRecord(source.document)) continue;
+    const props = isRecord(source.document.props) ? source.document.props : {};
+    const universe = matrixUniverse(format, options.themes[format]);
+    const blueprint = options.blueprints?.find(
+      (b) => b.format === format && b.definitions === source.name
+    );
+    const profile = blueprint ? options.profiles?.[blueprint.profile] : void 0;
+    const roles = requiredRoles(format, profile);
+    const { theme, conditions: conditions2, exclusions } = templateConditions(
+      format,
+      props,
+      universe
+    );
+    const definitions = Object.keys(readBlockDefinitions(source.document));
+    const references = blockReferencesFromDocument(source.document, {
+      template: source.name,
+      format
+    });
+    const templateExclusions = [...exclusions];
+    if (definitions.length > 0 && references.length === 0) {
+      templateExclusions.push({
+        condition: "definitions",
+        reason: "the definitions do not validate, so discovery publishes none"
+      });
+    }
+    inventory.templates.push({
+      template: source.name,
+      format,
+      theme,
+      ...blueprint && { profile: blueprint.profile },
+      requiredRoles: roles,
+      definitions,
+      conditions: conditions2,
+      exclusions: templateExclusions
+    });
+    for (const reference of references) {
+      const slotless = Object.keys(reference.definition.slots ?? {}).length === 0;
+      inventory.entries.push({
+        id: `${source.name}#${reference.definitionPointer}`,
+        template: source.name,
+        format,
+        name: reference.name,
+        definitionPointer: reference.definitionPointer,
+        dependencies: reference.dependencies,
+        ...blueprint && { profile: blueprint.profile },
+        requiredRoles: roles,
+        themes: [...conditions2.themes],
+        canvases: [...conditions2.canvases],
+        fonts: [...conditions2.fonts],
+        edges: slotless ? ["max"] : [...conditions2.edges],
+        exclusions: [
+          ...exclusions,
+          ...slotless ? [
+            {
+              condition: "edge min",
+              reason: "no slots, so min and max are the same document"
+            }
+          ] : []
+        ]
+      });
+    }
+  }
+  return inventory;
+}
+function inventoryGaps(entry, universe) {
+  const excluded = new Set(entry.exclusions.map((e) => e.condition));
+  const gaps = [];
+  const check = (kind, all, got) => {
+    for (const value of all) {
+      const condition = `${kind} ${value}`;
+      const has = got.includes(value);
+      if (has && excluded.has(condition)) gaps.push(`${condition}: both`);
+      if (!has && !excluded.has(condition)) gaps.push(`${condition}: neither`);
+    }
+  };
+  check("theme", universe.themes, entry.themes);
+  check("canvas", universe.canvases, entry.canvases);
+  check("font", universe.fonts, entry.fonts);
+  check("edge", universe.edges, entry.edges);
+  return gaps;
+}
+function describeInventory(inventory) {
+  const lines = [];
+  for (const template of inventory.templates) {
+    lines.push(
+      `${template.template} (${template.format}, theme ${template.theme}${template.profile ? `, profile ${template.profile}` : ""}): ${template.definitions.length} definition(s)`
+    );
+    for (const entry of inventory.entries.filter(
+      (e) => e.template === template.template
+    )) {
+      lines.push(
+        `  ${entry.name}: themes ${entry.themes.join(" ")} \xB7 canvases ${entry.canvases.join(
+          " "
+        )} \xB7 fonts ${entry.fonts.join(" ")} \xB7 edges ${entry.edges.join(" ")}`
+      );
+      const reasons = /* @__PURE__ */ new Map();
+      for (const exclusion of entry.exclusions) {
+        reasons.set(exclusion.reason, [
+          ...reasons.get(exclusion.reason) ?? [],
+          exclusion.condition
+        ]);
+      }
+      for (const [reason, conditions2] of reasons)
+        lines.push(`    not ${conditions2.join(", ")}: ${reason}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/block-matrix.ts
+var PPTX_FALLBACK_FONTS = {
+  heading: "DejaVu Sans",
+  body: "DejaVu Sans"
+};
+var PPTX_CANVAS_SIZE = {
+  wide169: { slideWidth: 13.333, slideHeight: 7.5 },
+  standard43: { slideWidth: 10, slideHeight: 7.5 }
+};
 var FALLBACK_FONTS = {
   heading: { family: "DejaVu Sans" },
   body: { family: "DejaVu Sans" }
 };
-var MATRIX_IMAGE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAYAAABytg0kAAAAFElEQVR42mNk+M9QzwAFjDAGACPuA/8fMSCgAAAAAElFTkSuQmCC";
+var MATRIX_IMAGE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAYAAAB/qH1jAAAAEklEQVR42mOIrt34HxkzoAsAAE/xFEFoJgXRAAAAAElFTkSuQmCC";
 var WORDS = [
   "performance",
   "delivery",
@@ -3522,7 +3815,7 @@ function widestNumber(length, seed = 0) {
   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 isRecord2 = (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) {
@@ -3564,14 +3857,17 @@ function stringValue(slot, name, edge, seed) {
     return edge === "max" ? words(count, seed, false) : "01";
   return words(count, seed, sentence);
 }
-function componentValue(name, edge, seed) {
-  if (name === "chart") {
+function componentValue(name, edge, seed, format = "docx") {
+  const chart = name === "chart" || format === "pptx" && name === "content";
+  if (chart && (name === "chart" || edge === "max")) {
     const categories = edge === "max" ? 8 : 2;
     const series = edge === "max" ? 3 : 1;
     return {
       name: "chart",
       props: {
-        type: "column",
+        // The native column chart: `column` in a report, `bar` standing
+        // upright in a deck.
+        type: format === "pptx" ? "bar" : "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),
@@ -3592,6 +3888,12 @@ function componentValue(name, edge, seed) {
       }
     };
   }
+  if (format === "pptx") {
+    return {
+      name: "image",
+      props: { path: MATRIX_IMAGE, alt: words(6, seed, false) }
+    };
+  }
   return {
     name: "image",
     props: {
@@ -3601,7 +3903,7 @@ function componentValue(name, edge, seed) {
     }
   };
 }
-function boundarySlotValue(slot, name, edge, seed = 0) {
+function boundarySlotValue(slot, name, edge, seed = 0, format = "docx") {
   switch (slot.type) {
     case "string":
       return stringValue(slot, name, edge, seed);
@@ -3611,12 +3913,18 @@ function boundarySlotValue(slot, name, edge, seed = 0) {
     case "boolean":
       return edge === "max" ? true : slot.default ?? true;
     case "component":
-      return componentValue(name, edge, seed);
+      return componentValue(name, edge, seed, format);
     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);
+        const value = boundarySlotValue(
+          property,
+          key,
+          edge,
+          seed + key.length,
+          format
+        );
         if (value !== void 0) out[key] = value;
       }
       return out;
@@ -3626,21 +3934,21 @@ function boundarySlotValue(slot, name, edge, seed = 0) {
       const item = slot.items ?? { type: "string" };
       return Array.from(
         { length: count },
-        (_, i) => boundarySlotValue(item, name, edge, seed + i)
+        (_, i) => boundarySlotValue(item, name, edge, seed + i, format)
       );
     }
     default:
       return void 0;
   }
 }
-function boundaryInvocation(name, definition, edge, seed = 0, requiredRoles = []) {
+function boundaryInvocation(name, definition, edge, seed = 0, requiredRoles2 = [], format = "docx") {
   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);
+    const required = slot.required === true || slot.role !== void 0 && requiredRoles2.includes(slot.role);
     if (edge === "min" && !required) continue;
-    const value = boundarySlotValue(slot, slotName, edge, offset);
+    const value = boundarySlotValue(slot, slotName, edge, offset, format);
     if (value !== void 0) slots[slotName] = value;
   }
   const labels = slots.labels;
@@ -3648,17 +3956,30 @@ function boundaryInvocation(name, definition, edge, seed = 0, requiredRoles = []
   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) {
+      if (isRecord2(column) && Array.isArray(column.cells) && cells?.items) {
         column.cells = labels.map(
-          (_, i) => boundarySlotValue(cells.items, "cells", edge, offset + i)
+          (_, i) => boundarySlotValue(
+            cells.items,
+            "cells",
+            edge,
+            offset + i,
+            format
+          )
         );
       }
     }
   }
   return { name: "block", props: { ref: name, slots } };
 }
-function overBudgetInvocation(name, definition, seed = 0) {
-  const invocation = boundaryInvocation(name, definition, "max", seed);
+function overBudgetInvocation(name, definition, seed = 0, format = "docx") {
+  const invocation = boundaryInvocation(
+    name,
+    definition,
+    "max",
+    seed,
+    [],
+    format
+  );
   const slots = invocation.props.slots;
   for (const [slotName, slot] of Object.entries(definition.slots)) {
     if (slot.type === "string" && slot.maxWords !== void 0) {
@@ -3676,27 +3997,41 @@ function overBudgetInvocation(name, definition, seed = 0) {
   return void 0;
 }
 function enumerateBlockDefinitions(template, templateName) {
-  const definitions = readBlockDefinitions(template);
+  const format = templateFormat(templateName, template);
+  if (!format)
+    throw new Error(`${templateName} is neither a report nor a deck.`);
+  const references = blockReferencesFromDocument2(template, {
+    template: templateName,
+    format
+  });
+  const declared = Object.keys(readBlockDefinitions2(template));
+  if (references.length !== declared.length)
+    throw new Error(
+      `${templateName}: discovery publishes ${references.length} of ${declared.length} definitions; the rest do not validate.`
+    );
   const examples = /* @__PURE__ */ new Map();
   const walk = (node) => {
     if (Array.isArray(node)) {
       node.forEach(walk);
       return;
     }
-    if (!isRecord(node)) return;
+    if (!isRecord2(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 : {});
+    if (node.name === "block" && isRecord2(props) && typeof props.ref === "string" && !examples.has(props.ref)) {
+      examples.set(props.ref, isRecord2(props.slots) ? props.slots : {});
     }
     walk(node.children);
   };
-  walk(isRecord(template) ? template.children : void 0);
-  return Object.entries(definitions).map(([name, definition]) => ({
-    name,
+  walk(isRecord2(template) ? template.children : void 0);
+  return references.map((reference) => ({
+    name: reference.name,
+    format,
     template: templateName,
-    pointer: `/props/blocks/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`,
-    definition,
-    ...examples.has(name) && { example: examples.get(name) }
+    pointer: reference.definitionPointer,
+    definition: reference.definition,
+    ...examples.has(reference.name) && {
+      example: examples.get(reference.name)
+    }
   }));
 }
 var CHROME = ["cover", "running-head", "section-opener"];
@@ -3708,19 +4043,27 @@ function nominal(entry, name, definitions) {
       props: { ref: name, slots: structuredClone(entry.example) }
     };
   }
-  return boundaryInvocation(name, definitions[name], "min");
+  return boundaryInvocation(
+    name,
+    definitions[name],
+    "min",
+    0,
+    [],
+    entry.format
+  );
 }
-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;
+function inlineImages(value, format = "docx") {
+  if (Array.isArray(value)) return value.map((v) => inlineImages(v, format));
+  if (!isRecord2(value)) return value;
+  if (value.name === "image" && isRecord2(value.props) && typeof value.props.path === "string" && !value.props.path.startsWith("data:")) {
+    const props = format === "pptx" ? { ...value.props, path: MATRIX_IMAGE } : { ...value.props, base64: MATRIX_IMAGE };
+    if (format === "docx") delete props.path;
     return { ...value, props };
   }
-  if (value.name === "highcharts") return componentValue("chart", "min", 0);
+  if (value.name === "highcharts")
+    return componentValue("chart", "min", 0, format);
   return Object.fromEntries(
-    Object.entries(value).map(([k, v]) => [k, inlineImages(v)])
+    Object.entries(value).map(([k, v]) => [k, inlineImages(v, format)])
   );
 }
 function withDefinitions(definitions, names) {
@@ -3736,9 +4079,9 @@ function withDefinitions(definitions, names) {
 }
 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 : {};
+    if (!isRecord2(child) || child.name !== "section") return child;
+    const props2 = isRecord2(child.props) ? child.props : {};
+    const page = isRecord2(props2.page) ? props2.page : {};
     return { ...child, props: { ...props2, page: { ...page, size: canvas } } };
   });
   const chart = JSON.stringify(sections).includes('"name":"chart"');
@@ -3754,12 +4097,12 @@ function conditions(props, children, theme, font, canvas) {
   };
 }
 var BODY_COPY = words(40, 1e3, true);
-function blockCaseDocument(entries, name, edge, theme, { font = "design", canvas = "A4", requiredRoles = [] } = {}) {
+function blockCaseDocument(entries, name, edge, theme, { font = "design", canvas = "A4", requiredRoles: requiredRoles2 = [] } = {}) {
   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 under = (chrome) => chrome === name ? boundaryInvocation(name, definitions[name], edge, 0, requiredRoles2) : inlineImages(nominal(byName.get(chrome), chrome, definitions));
   const cover = under("cover");
   const runningHead = under("running-head");
   const opener = under("section-opener");
@@ -3771,7 +4114,7 @@ function blockCaseDocument(entries, name, edge, theme, { font = "design", canvas
       );
     }
     body.push(
-      boundaryInvocation(name, definitions[name], edge, 0, requiredRoles)
+      boundaryInvocation(name, definitions[name], edge, 0, requiredRoles2)
     );
   }
   body.push({ name: "paragraph", props: { text: BODY_COPY } });
@@ -3802,26 +4145,26 @@ function blockCaseDocument(entries, name, edge, theme, { font = "design", canvas
     canvas
   );
 }
-function reportCaseDocument(template, edge, theme, { font = "design", canvas = "A4", requiredRoles = [] } = {}) {
-  if (!isRecord(template) || !isRecord(template.props))
+function reportCaseDocument(template, edge, theme, { font = "design", canvas = "A4", requiredRoles: requiredRoles2 = [] } = {}) {
+  if (!isRecord2(template) || !isRecord2(template.props))
     throw new Error("A template is a document with props.");
-  const definitions = readBlockDefinitions(template);
+  const definitions = readBlockDefinitions2(template);
   let seed = 0;
   const rewrite = (node) => {
     if (Array.isArray(node)) return node.map(rewrite);
-    if (!isRecord(node)) return node;
+    if (!isRecord2(node)) return node;
     const props2 = node.props;
-    if (node.name === "block" && isRecord(props2) && typeof props2.ref === "string" && definitions[props2.ref]) {
+    if (node.name === "block" && isRecord2(props2) && typeof props2.ref === "string" && definitions[props2.ref]) {
       seed += 7;
       return boundaryInvocation(
         props2.ref,
         definitions[props2.ref],
         edge,
         seed,
-        requiredRoles
+        requiredRoles2
       );
     }
-    if (node.name === "paragraph" && isRecord(props2) && typeof props2.text === "string") {
+    if (node.name === "paragraph" && isRecord2(props2) && typeof props2.text === "string") {
       return {
         ...node,
         props: { ...props2, text: edge === "max" ? BODY_COPY : props2.text }
@@ -3882,6 +4225,200 @@ function generateBlockMatrix(template, templateName, options) {
         }
   return cases;
 }
+function deckConditions(props, children, theme, font, canvas, themeObject) {
+  const out = structuredClone(props);
+  delete out.qualityProfile;
+  const inline = typeof props.theme !== "string";
+  if (!inline || theme !== "inline") {
+    if (font === "fallback") {
+      const base = themeObject?.(theme);
+      if (!base)
+        throw new Error(
+          `The fallback case on "${theme}" needs the theme's object.`
+        );
+      const fonts = isRecord2(base.fonts) ? base.fonts : {};
+      out.theme = {
+        ...structuredClone(base),
+        fonts: { ...fonts, ...PPTX_FALLBACK_FONTS }
+      };
+    } else {
+      out.theme = theme;
+    }
+  }
+  if ((canvas === "wide169" || canvas === "standard43") && authoredDeckCanvas(props) !== canvas)
+    Object.assign(out, PPTX_CANVAS_SIZE[canvas]);
+  return { name: "pptx", props: out, children };
+}
+function templateProps(template) {
+  if (!isRecord2(template) || !isRecord2(template.props))
+    throw new Error("A template is a document with props.");
+  return template.props;
+}
+function deckBlockCaseDocument(template, entries, name, edge, theme, {
+  font = "design",
+  canvas = "wide169",
+  requiredRoles: requiredRoles2 = [],
+  themeObject
+} = {}) {
+  const props = templateProps(template);
+  const definitions = Object.fromEntries(
+    entries.map((e) => [e.name, e.definition])
+  );
+  const byName = new Map(entries.map((e) => [e.name, e]));
+  const used = /* @__PURE__ */ new Set([name]);
+  const slides = [];
+  if (name !== "cover" && byName.has("cover")) {
+    used.add("cover");
+    slides.push({
+      name: "slide",
+      children: [
+        inlineImages(
+          nominal(byName.get("cover"), "cover", definitions),
+          "pptx"
+        )
+      ]
+    });
+  }
+  slides.push({
+    name: "slide",
+    children: [
+      boundaryInvocation(
+        name,
+        definitions[name],
+        edge,
+        0,
+        requiredRoles2,
+        "pptx"
+      )
+    ]
+  });
+  return deckConditions(
+    { ...props, blocks: withDefinitions(definitions, used) },
+    slides,
+    theme,
+    font,
+    canvas,
+    themeObject
+  );
+}
+function deckReportCaseDocument(template, edge, theme, {
+  font = "design",
+  canvas = "wide169",
+  requiredRoles: requiredRoles2 = [],
+  themeObject
+} = {}) {
+  const props = templateProps(template);
+  const definitions = readBlockDefinitions2(template);
+  let seed = 0;
+  const rewrite = (node) => {
+    if (Array.isArray(node)) return node.map(rewrite);
+    if (!isRecord2(node)) return node;
+    const nodeProps = node.props;
+    if (node.name === "block" && isRecord2(nodeProps) && typeof nodeProps.ref === "string" && definitions[nodeProps.ref]) {
+      seed += 7;
+      return boundaryInvocation(
+        nodeProps.ref,
+        definitions[nodeProps.ref],
+        edge,
+        seed,
+        requiredRoles2,
+        "pptx"
+      );
+    }
+    return Array.isArray(node.children) ? { ...node, children: rewrite(node.children) } : node;
+  };
+  return deckConditions(
+    props,
+    rewrite(template.children),
+    theme,
+    font,
+    canvas,
+    themeObject
+  );
+}
+var stem = (template) => template.replace(/\.(docx|pptx)\.json$/, "");
+function generateMatrixCases(inventory, templates, selection = {}, { themeObject } = {}) {
+  const pick = (supported, wanted) => supported.filter((value) => !wanted || wanted.includes(value));
+  const cases = [];
+  for (const summary of inventory.templates) {
+    if (selection.templates && !selection.templates.includes(summary.template))
+      continue;
+    const source = templates.find((t) => t.name === summary.template);
+    const entries = inventory.entries.filter(
+      (e) => e.template === summary.template
+    );
+    if (!source || entries.length === 0) continue;
+    const definitions = enumerateBlockDefinitions(
+      source.document,
+      summary.template
+    );
+    const withSlots = entries.some((e) => e.edges.includes("min"));
+    for (const theme of pick(summary.conditions.themes, selection.themes))
+      for (const font of pick(summary.conditions.fonts, selection.fonts))
+        for (const canvas of pick(
+          summary.conditions.canvases,
+          selection.canvases
+        ))
+          for (const edge of pick(summary.conditions.edges, selection.edges)) {
+            const shared = {
+              format: summary.format,
+              template: summary.template,
+              ...summary.profile && { profile: summary.profile },
+              edge,
+              theme,
+              font,
+              canvas
+            };
+            const conditions2 = {
+              font,
+              canvas,
+              requiredRoles: summary.requiredRoles,
+              themeObject
+            };
+            if (selection.blocks !== false)
+              for (const entry of entries) {
+                if (!entry.edges.includes(edge)) continue;
+                cases.push({
+                  ...shared,
+                  id: `${stem(summary.template)}/${entry.name}@${edge}/${theme}/${font}/${canvas}`,
+                  block: entry.name,
+                  document: summary.format === "docx" ? blockCaseDocument(
+                    definitions,
+                    entry.name,
+                    edge,
+                    theme,
+                    conditions2
+                  ) : deckBlockCaseDocument(
+                    source.document,
+                    definitions,
+                    entry.name,
+                    edge,
+                    theme,
+                    conditions2
+                  )
+                });
+              }
+            if (selection.report !== false && withSlots)
+              cases.push({
+                ...shared,
+                id: `${stem(summary.template)}/report@${edge}/${theme}/${font}/${canvas}`,
+                block: "report",
+                document: summary.format === "docx" ? reportCaseDocument(
+                  source.document,
+                  edge,
+                  theme,
+                  conditions2
+                ) : deckReportCaseDocument(
+                  source.document,
+                  edge,
+                  theme,
+                  conditions2
+                )
+              });
+          }
+  }
+  return cases;
+}
 export {
   DocxFormatAdapter,
   FALLBACK_FONTS,
@@ -3891,6 +4428,8 @@ export {
   MATRIX_IMAGE,
   MacOSCoreTextStager,
   NoopFontStager,
+  PPTX_CANVAS_SIZE,
+  PPTX_FALLBACK_FONTS,
   PptxFormatAdapter,
   RENDERED_QUALITY_RULES,
   VISIBLE_SPILL_PT,
@@ -3901,10 +4440,14 @@ export {
   blockCaseDocument,
   boundaryInvocation,
   boundarySlotValue,
+  buildMatrixInventory,
   clearRasterizerCache,
   createAdapter,
   createLibreOfficePptxBatchRasterizer,
   createLibreOfficePptxRasterizer,
+  deckBlockCaseDocument,
+  deckReportCaseDocument,
+  describeInventory,
   emitDiagnostic,
   enumerateBlockDefinitions,
   extractPdfFonts,
@@ -3912,9 +4455,12 @@ export {
   extractPdfTextGeometry,
   familyRendered,
   generateBlockMatrix,
+  generateMatrixCases,
   getFontStager,
   getRasterizerCacheStats,
   inkedRows,
+  inventoryGaps,
+  matrixUniverse,
   normalizeForMatch,
   overBudgetInvocation,
   pageInkFromPgm,
@@ -3929,6 +4475,7 @@ export {
   requestedFontsFromFacts,
   runWithDiagnosticSink,
   stderrDiagnosticSink,
+  templateFormat,
   widestNumber
 };
 //# sourceMappingURL=index.js.map