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

package/dist/index.js

@@ -2149,6 +2149,14 @@ var RENDERED_QUALITY_RULES = {
       defaultSeverity: "warning",
       formats: ["docx"]
     }),
+    renderedRule({
+      id: "rendered/table-split",
+      code: QUALITY_CODES.RENDERED_TABLE_SPLIT,
+      description: "A table broken across a page badly: its header left alone at the foot of a page (`kind: header-alone`), or one row alone on either side of the break (`kind: orphan-row` or `widow-row`).",
+      category: "composition",
+      defaultSeverity: "info",
+      formats: ["docx"]
+    }),
     renderedRule({
       id: "rendered/paragraph-split",
       code: QUALITY_CODES.RENDERED_PARAGRAPH_SPLIT,
@@ -2176,43 +2184,77 @@ function indexDocument(pages, exclude = /* @__PURE__ */ new Set()) {
   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) => pageOrder(page.words, page.lines));
+  orders.forEach((order, pageIndex) => {
+    for (const index of order.upright) push(pageIndex, index);
+  });
+  const rotatedFrom = cursor;
+  orders.forEach((order, pageIndex) => {
+    for (const index of order.rotated) push(pageIndex, index);
   });
-  return { pages, refs, fragments, positions, stream: fragments.join("") };
+  return {
+    pages,
+    refs,
+    fragments,
+    positions,
+    stream: fragments.join(""),
+    rotatedFrom
+  };
 }
-function readingOrder(words2) {
+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 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(
@@ -2221,7 +2263,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);
@@ -2259,20 +2302,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;
   };
@@ -2286,6 +2334,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) {
@@ -2353,6 +2411,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
@@ -2378,7 +2437,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;
@@ -2386,7 +2449,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;
@@ -2399,14 +2462,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);
@@ -2462,6 +2547,96 @@ 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 assignInventory(pages, inventory) {
   const results = /* @__PURE__ */ new Map();
   const chromeWords = /* @__PURE__ */ new Set();
@@ -2501,7 +2676,8 @@ 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();
+  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;
@@ -2511,10 +2687,31 @@ 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 && 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 };
@@ -2529,18 +2726,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];
       }
     }
@@ -2553,9 +2754,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,
@@ -2587,6 +2789,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 {
@@ -2602,12 +2809,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();
@@ -2723,14 +2933,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],
@@ -2975,6 +3222,79 @@ function draftRenderedFindings(input) {
         })
       );
     }
+    const TABLE_CELL = /^(.*)\/props\/(?:slots\/)?columns\/(\d+)\/(?:header|cells\/(\d+))(?:\/.*)?$/;
+    const tables = /* @__PURE__ */ new Map();
+    for (const match of matches) {
+      if (match.entry.role !== "table-header" && match.entry.role !== "table-cell" || match.status !== "mapped")
+        continue;
+      const parsed = TABLE_CELL.exec(match.entry.path);
+      if (!parsed) continue;
+      const [, table, column, row] = parsed;
+      const rowIndex = row === void 0 ? -1 : Number(row);
+      const entry = tables.get(table) ?? {
+        pages: /* @__PURE__ */ new Map(),
+        paths: /* @__PURE__ */ new Map()
+      };
+      for (const occurrence2 of match.occurrences)
+        for (const part of occurrence2.parts) {
+          const rows = entry.pages.get(part.pageIndex) ?? /* @__PURE__ */ new Set();
+          rows.add(rowIndex);
+          entry.pages.set(part.pageIndex, rows);
+        }
+      const held = entry.paths.get(rowIndex);
+      if (!held || Number(column) < held.column)
+        entry.paths.set(rowIndex, {
+          column: Number(column),
+          path: match.entry.path
+        });
+      tables.set(table, entry);
+    }
+    for (const [table, { pages: onPage, paths }] of tables) {
+      const ordered = [...onPage.keys()].sort((a, b) => a - b);
+      if (ordered.length < 2) continue;
+      const bodyRows = (page) => [...onPage.get(page) ?? []].filter((row) => row >= 0);
+      const report = (kind, page, path9, message, suggestion) => findings.push(
+        finding({
+          ruleId: "rendered/table-split",
+          mapping: "mapped",
+          page: page + 1,
+          path: path9,
+          message,
+          suggestion,
+          context: { kind, table }
+        })
+      );
+      const firstPage = ordered[0];
+      const lastPage = ordered[ordered.length - 1];
+      if (onPage.get(firstPage).has(-1) && bodyRows(firstPage).length === 0) {
+        report(
+          "header-alone",
+          firstPage,
+          paths.get(-1).path,
+          `The table's header is the only part of it on page ${firstPage + 1}; its rows start on the next page.`,
+          "Keep the header with its first rows, or move the table so it starts on the next page."
+        );
+        continue;
+      }
+      const opening = bodyRows(firstPage);
+      const closing = bodyRows(lastPage);
+      if (opening.length === 1)
+        report(
+          "orphan-row",
+          firstPage,
+          paths.get(opening[0]).path,
+          `The table leaves one row alone at the foot of page ${firstPage + 1}.`,
+          "Keep the table together on one page, or edit the rows above it so the break falls elsewhere."
+        );
+      else if (closing.length === 1)
+        report(
+          "widow-row",
+          lastPage,
+          paths.get(closing[0]).path,
+          `The table leaves one row alone at the top of page ${lastPage + 1}.`,
+          "Keep the table together on one page, or edit the rows above it so the break falls elsewhere."
+        );
+    }
   }
   const inventory = {
     mapped: 0,
@@ -3071,6 +3391,93 @@ 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,
@@ -3517,7 +3924,9 @@ export {
   pdffontsAvailable,
   pdftotextAvailable,
   readingOrder,
+  renderedInventoryFromFacts,
   reportCaseDocument,
+  requestedFontsFromFacts,
   runWithDiagnosticSink,
   stderrDiagnosticSink,
   widestNumber