@json-to-office/jto-ops 6.2.0 → 7.0.0

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,48 +2227,92 @@ 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 = [];
   let cursor = 0;
-  pages.forEach((page, pageIndex) => {
-    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;
-    }
+  const push = (pageIndex, index) => {
+    const word = pages[pageIndex].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;
+  };
+  const orders = pages.map((page) => order(page.words, page.lines));
+  orders.forEach((order2, pageIndex) => {
+    for (const index of order2.upright) push(pageIndex, index);
   });
-  return { pages, refs, fragments, positions, stream: fragments.join("") };
+  const rotatedFrom = cursor;
+  orders.forEach((order2, pageIndex) => {
+    for (const index of order2.rotated) push(pageIndex, index);
+  });
+  return {
+    pages,
+    refs,
+    fragments,
+    positions,
+    stream: fragments.join(""),
+    rotatedFrom
+  };
+}
+function readingOrder(words2, lines = []) {
+  const { upright, rotated } = pageOrder(words2, lines);
+  return [...upright, ...rotated];
+}
+function pageOrder(words2, lines = []) {
+  const rotated = rotatedWords(words2, lines);
+  return {
+    upright: uprightOrder(
+      words2,
+      words2.map((_, i) => i).filter((i) => !rotated.has(i))
+    ),
+    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 readingOrder(words2) {
+function rotatedWords(words2, lines) {
   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++]);
+  for (const line of lines) {
+    if (line.words.length < 2) continue;
+    const stacked = line.words.slice(1).every((index, n) => {
+      const a = words2[line.words[n]];
+      const b = words2[index];
+      const across = Math.min(a.xMax, b.xMax) - Math.max(a.xMin, b.xMin);
+      const along = Math.min(a.yMax, b.yMax) - Math.max(a.yMin, b.yMin);
+      return across > 0 && along <= 0;
+    });
+    if (stacked) for (const index of line.words) rotated.add(index);
   }
-  return order;
+  return rotated;
 }
 function median(values) {
   const sorted = [...values].sort((a, b) => a - b);
   const mid = sorted.length >> 1;
   return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
 }
+var ROW_SIZE_RATIO = 2;
+function comparableSize(a, b) {
+  const ha = a.yMax - a.yMin;
+  const hb = b.yMax - b.yMin;
+  return Math.max(ha, hb) <= ROW_SIZE_RATIO * Math.min(ha, hb);
+}
 function groupRows(words2, indices) {
   const rows = [];
   const byY = [...indices].sort(
@@ -2229,7 +2321,8 @@ function groupRows(words2, indices) {
   for (const i of byY) {
     const word = words2[i];
     const row = rows[rows.length - 1];
-    if (row && sameRow(words2[row.words[0]], word)) {
+    const peer = row?.words.find((w) => comparableSize(words2[w], word));
+    if (row && peer !== void 0 && sameRow(words2[peer], word)) {
       row.words.push(i);
       row.yMin = Math.min(row.yMin, word.yMin);
       row.yMax = Math.max(row.yMax, word.yMax);
@@ -2267,20 +2360,25 @@ function uprightOrder(words2, indices) {
   const fragments = rows.map(fragmentsOf);
   const boxes = grouped;
   const order = [];
+  const read = /* @__PURE__ */ new Set();
+  const readColumn = (column) => {
+    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);
+      read.add(f);
+    }
+  };
   let cluster = null;
   const flush = () => {
     if (!cluster) return;
     if (cluster.columns.length < 2) {
       for (const r of cluster.rows)
-        for (const f of fragments[r]) order.push(...f.words);
+        for (const f of fragments[r]) if (!read.has(f)) 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);
-      }
+      for (const column of cluster.columns) readColumn(column);
     }
     cluster = null;
   };
@@ -2294,6 +2392,16 @@ function uprightOrder(words2, indices) {
     if (!adjacent || wide) flush();
     if (!cluster) cluster = { rows: [], columns: [] };
     cluster.rows.push(r);
+    const landing = /* @__PURE__ */ new Map();
+    for (const f of fragments[r]) {
+      const hit = overlapping(cluster.columns, f)[0];
+      if (hit) landing.set(hit, (landing.get(hit) ?? 0) + 1);
+    }
+    for (const [column, count] of landing) {
+      if (count < 2) continue;
+      readColumn(column);
+      cluster.columns.splice(cluster.columns.indexOf(column), 1);
+    }
     for (const f of fragments[r]) {
       const hit = overlapping(cluster.columns, f)[0];
       if (hit) {
@@ -2361,6 +2469,7 @@ function occurrence(index, at, end) {
   const parts = partsOf(index, at, end);
   return {
     at,
+    end,
     pageIndex: parts[0].pageIndex,
     endPageIndex: parts[parts.length - 1].pageIndex,
     parts
@@ -2386,7 +2495,11 @@ function findOccurrences(index, segments) {
       end = next + segments[s].length;
     }
     if (!complete || !alignedToFragments(index, at, end)) continue;
-    hits.push(occurrence(index, at, end));
+    const hit = occurrence(index, at, end);
+    if (at < index.rotatedFrom ? end > index.rotatedFrom : hit.pageIndex !== hit.endPageIndex) {
+      continue;
+    }
+    hits.push(hit);
     searchFrom = end;
   }
   return hits;
@@ -2394,7 +2507,7 @@ function findOccurrences(index, segments) {
 var MIN_NEEDLE_LENGTH = 3;
 var MIN_PARTIAL_PREFIX = 16;
 var CHROME_BAND = 0.2;
-function longestRenderedPrefix(index, needle) {
+function longestRenderedPrefix(index, needle, page, region) {
   if (needle.length < MIN_PARTIAL_PREFIX) return void 0;
   const anchor = needle.slice(0, MIN_PARTIAL_PREFIX);
   let best;
@@ -2407,14 +2520,36 @@ function longestRenderedPrefix(index, needle) {
     if (first >= index.fragments.length || index.positions[first] !== at) {
       continue;
     }
+    if (page !== void 0 && index.refs[first].pageIndex !== page) continue;
+    const rotated = at >= index.rotatedFrom;
+    const limit = Math.min(
+      page !== void 0 || rotated ? pageEnd(index, first) : index.stream.length,
+      rotated ? index.stream.length : index.rotatedFrom
+    );
+    if (at + MIN_PARTIAL_PREFIX > limit) continue;
     let length = MIN_PARTIAL_PREFIX;
-    while (length < needle.length && index.stream.charCodeAt(at + length) === needle.charCodeAt(length)) {
+    while (length < needle.length && at + length < limit && index.stream.charCodeAt(at + length) === needle.charCodeAt(length)) {
       length++;
     }
+    if (region && !touchesRegion(partsOf(index, at, at + length), region)) {
+      continue;
+    }
     if (!best || length > best.length) best = { length, at };
   }
   return best;
 }
+function pageEnd(index, from) {
+  const page = index.refs[from].pageIndex;
+  let i = from;
+  while (i < index.refs.length && index.refs[i].pageIndex === page) i++;
+  return i < index.positions.length ? index.positions[i] : index.stream.length;
+}
+var REGION_TOLERANCE_PT = 2;
+function touchesRegion(parts, region) {
+  return parts.some(
+    (part) => part.xMax >= region.xMin - REGION_TOLERANCE_PT && part.xMin <= region.xMax + REGION_TOLERANCE_PT && part.yMax >= region.yMin - REGION_TOLERANCE_PT && part.yMin <= region.yMax + REGION_TOLERANCE_PT
+  );
+}
 function sameRow(a, b) {
   const overlap = Math.min(a.yMax, b.yMax) - Math.max(a.yMin, b.yMin);
   const shorter = Math.min(a.yMax - a.yMin, b.yMax - b.yMin);
@@ -2470,6 +2605,120 @@ function pageNumberRows(pages, claimed) {
     )
   );
 }
+function insideRegion(occurrences, region) {
+  let best;
+  for (const o of occurrences) {
+    let inside = 0;
+    let total = 0;
+    for (const part of o.parts) {
+      const w = Math.min(part.xMax, region.xMax) - Math.max(part.xMin, region.xMin);
+      const h = Math.min(part.yMax, region.yMax) - Math.max(part.yMin, region.yMin);
+      if (w > 0 && h > 0) inside += w * h;
+      total += (part.xMax - part.xMin) * (part.yMax - part.yMin);
+    }
+    const share = total > 0 ? inside / total : 0;
+    if (share > 0 && (!best || share > best.share)) {
+      best = { occurrence: o, share };
+    }
+  }
+  return best?.occurrence;
+}
+function overprintedOccurrence(index, page, region, needle, claimed) {
+  const words2 = index.pages[page]?.words;
+  if (!words2) return void 0;
+  const fragmentOf = /* @__PURE__ */ new Map();
+  index.refs.forEach((ref, i) => {
+    if (ref.pageIndex !== page || index.fragments[i] === "") return;
+    const w = words2[ref.word];
+    const centre = (w.xMin + w.xMax) / 2;
+    if (centre < region.xMin || centre > region.xMax) return;
+    if (w.yMax < region.yMin) return;
+    fragmentOf.set(ref.word, i);
+  });
+  const sequence = groupRows(words2, [...fragmentOf.keys()]).flatMap(
+    (row) => [...row.words].sort((a, b) => words2[a].xMin - words2[b].xMin)
+  );
+  let reach = /* @__PURE__ */ new Map();
+  let best;
+  for (const word of sequence) {
+    const i = fragmentOf.get(word);
+    const text = index.fragments[i];
+    const usable = !claimed(index.positions[i]);
+    const next = /* @__PURE__ */ new Map();
+    const offer = (consumed, path9) => {
+      const held = next.get(consumed);
+      if (!held || path9.skips < held.skips) next.set(consumed, path9);
+    };
+    const inside = words2[word].yMin + words2[word].yMax <= 2 * region.yMax && words2[word].yMin + words2[word].yMax >= 2 * region.yMin;
+    if (usable && inside && needle.startsWith(text)) {
+      offer(text.length, { skips: 0, words: [word] });
+    }
+    for (const [consumed, path9] of reach) {
+      if (usable && needle.startsWith(text, consumed)) {
+        offer(consumed + text.length, {
+          skips: path9.skips,
+          words: [...path9.words, word]
+        });
+      }
+      offer(consumed, { skips: path9.skips + 1, words: path9.words });
+    }
+    const done = next.get(needle.length);
+    if (done && (!best || done.skips < best.skips)) best = done;
+    next.delete(needle.length);
+    reach = next;
+  }
+  if (!best || best.skips > best.words.length) return void 0;
+  const first = fragmentOf.get(best.words[0]);
+  const part = {
+    pageIndex: page,
+    words: best.words,
+    xMin: Math.min(...best.words.map((w) => words2[w].xMin)),
+    yMin: Math.min(...best.words.map((w) => words2[w].yMin)),
+    xMax: Math.max(...best.words.map((w) => words2[w].xMax)),
+    yMax: Math.max(...best.words.map((w) => words2[w].yMax))
+  };
+  const at = index.positions[first];
+  return {
+    occurrence: {
+      at,
+      end: at,
+      pageIndex: page,
+      endPageIndex: page,
+      parts: [part]
+    },
+    claims: best.words.map((w) => {
+      const i = fragmentOf.get(w);
+      return {
+        at: index.positions[i],
+        end: index.positions[i] + index.fragments[i].length
+      };
+    })
+  };
+}
+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();
@@ -2509,7 +2758,9 @@ function assignInventory(pages, inventory) {
   for (const row of pageNumberRows(pages, chromeWords))
     claimRow(row.pageIndex, row.box);
   const body = indexDocument(pages, chromeWords);
-  const claimed = /* @__PURE__ */ new Map();
+  let lined;
+  const claims = [];
+  const claimsOver = (o) => claims.filter((claim) => o.at < claim.end && claim.at < o.end);
   let cursor = 0;
   for (const entry of inventory) {
     if (entry.repeats) continue;
@@ -2519,10 +2770,44 @@ function assignInventory(pages, inventory) {
       results.set(entry, { entry, needle, status: "skipped", occurrences: [] });
       continue;
     }
-    let all = findOccurrences(body, segments);
+    let all = findOccurrences(body, segments).filter(
+      (o) => (entry.page === void 0 || o.pageIndex === entry.page && o.endPageIndex === entry.page) && (!entry.region || touchesRegion(o.parts, entry.region))
+    );
     let partial;
+    let sparse;
+    if (all.length === 0 && segments.length === 1 && entry.page !== void 0 && entry.region) {
+      const overprinted = overprintedOccurrence(
+        body,
+        entry.page,
+        entry.region,
+        needle,
+        (offset) => claims.some((claim) => claim.at <= offset && offset < claim.end)
+      );
+      if (overprinted) {
+        all = [overprinted.occurrence];
+        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, needle);
+      const prefix = longestRenderedPrefix(
+        body,
+        needle,
+        entry.page,
+        entry.region
+      );
       if (prefix) {
         all = [occurrence(body, prefix.at, prefix.at + prefix.length)];
         partial = { matchedChars: prefix.length, totalChars: needle.length };
@@ -2537,18 +2822,22 @@ function assignInventory(pages, inventory) {
       });
       continue;
     }
-    let free = all.filter((o) => !claimed.has(o.at));
+    let free = all.filter((o) => claimsOver(o).length === 0);
     if (free.length === 0 && !entry.optional) {
-      const held = all.find((o) => claimed.get(o.at)?.optional);
+      const held = all.find((o) => {
+        const over = claimsOver(o);
+        return over.length > 0 && over.every((claim) => claim.entry.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: []
-        });
+        for (const claim of claimsOver(held)) {
+          claims.splice(claims.indexOf(claim), 1);
+          results.set(claim.entry, {
+            entry: claim.entry,
+            needle: results.get(claim.entry)?.needle ?? "",
+            status: "skipped",
+            occurrences: []
+          });
+        }
         free = [held];
       }
     }
@@ -2561,9 +2850,10 @@ function assignInventory(pages, inventory) {
       });
       continue;
     }
-    const chosen = free.find((o) => o.at >= cursor) ?? free[0];
-    claimed.set(chosen.at, entry);
-    cursor = chosen.at;
+    const chosen = (entry.region && insideRegion(free, entry.region)) ?? free.find((o) => o.at >= cursor) ?? free[0];
+    for (const range of sparse ?? [chosen])
+      claims.push({ at: range.at, end: range.end, entry });
+    if (chosen.at < body.rotatedFrom) cursor = chosen.at;
     results.set(entry, {
       entry,
       needle,
@@ -2595,6 +2885,11 @@ function renderedDraftFor(fact) {
 }
 var VISIBLE_SPILL_PT = 2;
 var OVERLAP_FRACTION = 0.3;
+var WORD_BOX_SLACK = 0.2;
+function inkBand(word) {
+  const slack = WORD_BOX_SLACK * Math.max(0, word.yMax - word.yMin);
+  return { yMin: word.yMin + slack, yMax: word.yMax - slack };
+}
 function finding(draft) {
   const { mapping, page, context, ...rest } = draft;
   return {
@@ -2610,12 +2905,15 @@ function round(value) {
   return Math.round(value * 10) / 10;
 }
 function intersects(a, b) {
+  const inkA = inkBand(a);
+  const inkB = inkBand(b);
   const w = Math.min(a.xMax, b.xMax) - Math.max(a.xMin, b.xMin);
-  const h = Math.min(a.yMax, b.yMax) - Math.max(a.yMin, b.yMin);
+  const h = Math.min(inkA.yMax, inkB.yMax) - Math.max(inkA.yMin, inkB.yMin);
   return w > 0 && h > 0 ? w * h : 0;
 }
 function area(w) {
-  return Math.max(0, w.xMax - w.xMin) * Math.max(0, w.yMax - w.yMin);
+  const ink = inkBand(w);
+  return Math.max(0, w.xMax - w.xMin) * Math.max(0, ink.yMax - ink.yMin);
 }
 function excerpt(text, max = 60) {
   const flat = text.replace(/\s+/g, " ").trim();
@@ -2731,14 +3029,51 @@ function draftRenderedFindings(input) {
   }
   for (const match of matches) {
     const box = match.entry.box;
+    const region = match.entry.region;
     if (!box || match.status !== "mapped") continue;
     for (const o of match.occurrences) {
+      const boxHeight = box.heightPt;
+      const byEdges = region !== void 0 && boxHeight !== void 0;
+      if (region && boxHeight !== void 0) {
+        const words2 = o.parts.flatMap(
+          (part) => part.words.map((w) => pages[part.pageIndex].words[w])
+        );
+        const inkTop = Math.min(...words2.map((w) => inkBand(w).yMin));
+        const inkBottom = Math.max(...words2.map((w) => inkBand(w).yMax));
+        const edges = [
+          { edge: "bottom", over: inkBottom - region.yMax, at: inkBottom },
+          { edge: "top", over: region.yMin - inkTop, at: inkTop }
+        ].sort((a, b) => b.over - a.over);
+        const [worst2] = edges;
+        if (worst2.over > VISIBLE_SPILL_PT) {
+          findings.push(
+            finding({
+              ruleId: "rendered/spill",
+              mapping: "mapped",
+              page: o.pageIndex + 1,
+              path: match.entry.path,
+              message: `"${excerpt(match.entry.text)}" runs ${round(worst2.over)} pt past the ${worst2.edge} of its ${round(boxHeight)} pt box on page ${o.pageIndex + 1}.`,
+              suggestion: "Shorten the text, reduce its size, or enlarge the box; the renderer let it spill past the edge the author drew.",
+              evidence: {
+                summary: "Rendered ink against the edge of the declared box",
+                actual: round(worst2.at),
+                expected: round(
+                  worst2.edge === "bottom" ? region.yMax : region.yMin
+                ),
+                unit: "pt",
+                values: { edge: worst2.edge, overPt: round(worst2.over) }
+              }
+            })
+          );
+          continue;
+        }
+      }
       const extent = unionBox(o.parts);
       const rendered = {
         heightPt: extent.yMax - extent.yMin,
         widthPt: extent.xMax - extent.xMin
       };
-      const worst = ["heightPt", "widthPt"].filter((axis) => box[axis] !== void 0).map((axis) => ({
+      const worst = ["heightPt", "widthPt"].filter((axis) => box[axis] !== void 0).filter((axis) => !(byEdges && axis === "heightPt")).map((axis) => ({
         axis,
         declared: box[axis],
         rendered: rendered[axis],
@@ -3152,11 +3487,295 @@ function analyzeRenderedDocument(input, options = {}) {
   };
 }
 
+// src/rendered-inventory.ts
+function renderedInventoryFromFacts(format, facts) {
+  const entries = [];
+  for (const fact of facts) {
+    if (format === "docx" && fact.kind === "docx/text") {
+      const frame = fact.frame;
+      entries.push({
+        path: fact.path,
+        text: String(fact.text),
+        role: fact.role,
+        ...typeof fact.level === "number" && { level: fact.level },
+        ...fact.repeats === true && { repeats: true },
+        ...fact.optional === true && { optional: true },
+        ...frame && {
+          box: {
+            ...frame.widthPt !== void 0 && { widthPt: frame.widthPt },
+            ...frame.heightPt !== void 0 && { heightPt: frame.heightPt }
+          }
+        }
+      });
+    } else if (format === "pptx" && fact.kind === "pptx/text") {
+      if (fact.slideHidden === true) continue;
+      const turned = typeof fact.rotationDeg === "number" && (fact.rotationDeg % 360 + 360) % 360 !== 0;
+      if (turned) {
+        entries.push({
+          path: fact.path,
+          text: String(fact.text),
+          role: "slide-text",
+          optional: true,
+          ...typeof fact.page === "number" && { page: fact.page }
+        });
+        continue;
+      }
+      const { boxXPt: x, boxYPt: y } = fact;
+      const widthPt = fact.boxWidthPt;
+      const heightPt = fact.boxHeightPt;
+      entries.push({
+        path: fact.path,
+        text: String(fact.text),
+        role: "slide-text",
+        // A slide is its own page and its boxes are where the deck put
+        // them, so the text is looked for there before anywhere else.
+        ...typeof fact.page === "number" && { page: fact.page },
+        ...typeof x === "number" && typeof y === "number" && typeof widthPt === "number" && typeof heightPt === "number" && {
+          region: {
+            xMin: x,
+            yMin: y,
+            xMax: x + widthPt,
+            yMax: y + heightPt
+          }
+        },
+        ...(typeof widthPt === "number" || typeof heightPt === "number") && {
+          box: {
+            ...typeof widthPt === "number" && { widthPt },
+            ...typeof heightPt === "number" && { heightPt }
+          }
+        }
+      });
+    }
+  }
+  return entries;
+}
+function requestedFontsFromFacts(format, facts, resolvedFonts) {
+  const kind = format === "docx" ? "docx/font-family" : "pptx/font-family";
+  const declared = new Set(
+    resolvedFonts.filter((font) => font.declared).map((font) => font.family.trim().toLowerCase())
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const requested = [];
+  const add = (family, path9) => {
+    if (typeof family !== "string" || family.trim() === "") return;
+    const key = family.trim().toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    requested.push({
+      family: family.trim(),
+      ...path9 && { path: path9 },
+      ...declared.has(key) && { declared: true }
+    });
+  };
+  for (const fact of facts) {
+    if (fact.kind === kind) add(fact.family, fact.path);
+  }
+  for (const font of resolvedFonts) if (font.declared) add(font.family);
+  return requested;
+}
+
 // 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" }
@@ -3196,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) {
@@ -3238,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),
@@ -3266,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: {
@@ -3275,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);
@@ -3285,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;
@@ -3300,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;
@@ -3322,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) {
@@ -3350,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"];
@@ -3382,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) {
@@ -3410,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"');
@@ -3428,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");
@@ -3445,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 } });
@@ -3476,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 }
@@ -3556,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,
@@ -3565,6 +4428,8 @@ export {
   MATRIX_IMAGE,
   MacOSCoreTextStager,
   NoopFontStager,
+  PPTX_CANVAS_SIZE,
+  PPTX_FALLBACK_FONTS,
   PptxFormatAdapter,
   RENDERED_QUALITY_RULES,
   VISIBLE_SPILL_PT,
@@ -3575,10 +4440,14 @@ export {
   blockCaseDocument,
   boundaryInvocation,
   boundarySlotValue,
+  buildMatrixInventory,
   clearRasterizerCache,
   createAdapter,
   createLibreOfficePptxBatchRasterizer,
   createLibreOfficePptxRasterizer,
+  deckBlockCaseDocument,
+  deckReportCaseDocument,
+  describeInventory,
   emitDiagnostic,
   enumerateBlockDefinitions,
   extractPdfFonts,
@@ -3586,9 +4455,12 @@ export {
   extractPdfTextGeometry,
   familyRendered,
   generateBlockMatrix,
+  generateMatrixCases,
   getFontStager,
   getRasterizerCacheStats,
   inkedRows,
+  inventoryGaps,
+  matrixUniverse,
   normalizeForMatch,
   overBudgetInvocation,
   pageInkFromPgm,
@@ -3598,9 +4470,12 @@ export {
   pdffontsAvailable,
   pdftotextAvailable,
   readingOrder,
+  renderedInventoryFromFacts,
   reportCaseDocument,
+  requestedFontsFromFacts,
   runWithDiagnosticSink,
   stderrDiagnosticSink,
+  templateFormat,
   widestNumber
 };
 //# sourceMappingURL=index.js.map