@json-to-office/core-pptx 6.6.0 → 7.0.0

package/dist/index.js

@@ -5163,36 +5163,8 @@ var DEFAULT_STYLES = {
   body: { fontSize: 14 },
   caption: { fontSize: 10, italic: true, fontColor: "text2" }
 };
-var DEFAULT_PPTX_THEME = {
-  name: "default",
-  displayName: "Office Default",
-  description: "The stock Office look: blue primary, orange and green accents, Arial throughout, centred titles",
-  whenToUse: "A deck that has to match a plain PowerPoint look; pick a designed theme for anything a client will see.",
-  colors: {
-    primary: "#4472C4",
-    secondary: "#ED7D31",
-    accent: "#70AD47",
-    background: "#FFFFFF",
-    text: "#333333",
-    text2: "#44546A",
-    background2: "#E7E6E6",
-    accent4: "#FFC000",
-    accent5: "#5B9BD5",
-    accent6: "#70AD47"
-  },
-  fonts: {
-    heading: "Arial",
-    body: "Arial"
-  },
-  defaults: {
-    fontSize: 18,
-    fontColor: "#333333"
-  },
-  styles: DEFAULT_STYLES,
-  componentDefaults: { table: DEFAULT_TABLE }
-};
+var DEFAULT_PPTX_THEME = CONSULTING_PPTX_THEME;
 var PPTX_THEMES = {
-  default: DEFAULT_PPTX_THEME,
   consulting: CONSULTING_PPTX_THEME,
   vermilion: VERMILION_PPTX_THEME,
   devportal: DEVPORTAL_PPTX_THEME,
@@ -5332,7 +5304,7 @@ function resolveThemeContext(documentIn, options = {}) {
     inlineTheme = document.props.theme;
   }
   const authoredThemeName = typeof document.props.theme === "string" ? document.props.theme : void 0;
-  const baseThemeName = inlineTheme ? inlineTheme.name || "inline-theme" : authoredThemeName ?? defaultThemeName ?? "default";
+  const baseThemeName = inlineTheme ? inlineTheme.name || "inline-theme" : authoredThemeName ?? defaultThemeName ?? "consulting";
   let theme = inlineTheme ?? (resolveNamedTheme ? resolveNamedTheme(baseThemeName, authoredThemeName !== void 0) : customThemes?.[baseThemeName] ?? getPptxTheme(baseThemeName));
   theme = resolvePptxDesignSystem(
     theme,
@@ -5913,10 +5885,22 @@ async function expandPptxBlocksWithPlugins(document, theme, plugins, render, pre
     preserve
   });
   const finished = finishPptxBlocks(composed.standard, evaluator, effects2);
-  return { ...finished, preserved: composed.preserved };
+  return {
+    ...finished,
+    preserved: composed.preserved,
+    pluginOutputs: evaluator.pluginOutputs
+  };
 }
 
 // src/quality/facts.ts
+function textInsetsPt(props, componentName) {
+  const margin = props.margin;
+  if (typeof margin === "number" && Number.isFinite(margin))
+    return [margin, margin, margin, margin];
+  if (Array.isArray(margin) && margin.length === 4 && margin.every((side) => typeof side === "number" && Number.isFinite(side)))
+    return margin;
+  return componentName === "shape" ? [3.6, 7.2, 3.6, 7.2] : [0, 0, 0, 0];
+}
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -5972,6 +5956,37 @@ function horizontalAlign(props, ctx) {
   const styled = typeof props.style === "string" ? ctx.styles[props.style]?.align : void 0;
   return styled && HORIZONTAL_ALIGNMENTS.has(styled) ? styled : "left";
 }
+var BLEED_TOLERANCE_PT = 2;
+var NOT_BODY_STYLES = /* @__PURE__ */ new Set([
+  "title",
+  "subtitle",
+  "display",
+  "tracker",
+  "footer",
+  "source"
+]);
+function imageBox(node, box, statedPropsAt) {
+  if (node.componentName !== "image" || !isCompleteBox(box)) return box;
+  const ratio = readablePptxRatio(node.props);
+  if (ratio === void 0 || ratio <= 0) return box;
+  const authored = statedPropsAt(node.path) ?? node.props;
+  const statesWidth = authored.w !== void 0;
+  const statesHeight = authored.h !== void 0;
+  if (statesWidth && !statesHeight)
+    return { ...box, heightPt: box.widthPt / ratio };
+  if (statesHeight && !statesWidth)
+    return { ...box, widthPt: box.heightPt * ratio };
+  return box;
+}
+function slotOrNode(nodePath, authoredPath) {
+  for (const prop of ["text", "runs"]) {
+    const compiled = `${nodePath}/props/${prop}`;
+    const authored = authoredPath(compiled);
+    if (authored !== compiled && authored.includes("/props/slots/"))
+      return authored;
+  }
+  return nodePath;
+}
 function bulletItems(props) {
   const runs = Array.isArray(props.runs) ? props.runs : void 0;
   const whole = props.bullet !== void 0 && props.bullet !== false;
@@ -6130,7 +6145,7 @@ function isOpaqueComponent(componentName, props) {
   const type = typeof props.type === "string" ? props.type : "rect";
   return RECTANGULAR_SHAPES.has(type) && isOpaqueFill(props.fill);
 }
-function collectSlideNodes(component, path4, text, surfaces, boxes, contentNodes, counter) {
+function collectSlideNodes(component, path4, text, richText, surfaces, boxes, contentNodes, counter) {
   const rec = asRecord(component);
   if (!rec || rec.enabled === false) return;
   const props = asRecord(rec.props) ?? {};
@@ -6143,9 +6158,28 @@ function collectSlideNodes(component, path4, text, surfaces, boxes, contentNodes
   const content = typeof props.text === "string" ? props.text : void 0;
   if (content !== void 0 && content.trim() !== "" && props.runs === void 0) {
     if (rec.name === "text" || rec.name === "shape") {
-      text.push({ props, path: path4, text: content, order });
+      text.push({
+        props,
+        path: path4,
+        componentName: rec.name,
+        text: content,
+        order
+      });
     }
   }
+  if (Array.isArray(props.runs) && (rec.name === "text" || rec.name === "shape")) {
+    const joined = props.runs.map(asRecord).map(
+      (run) => run && typeof run.text === "string" ? `${run.text}${run.breakLine === true ? "\n" : ""}` : ""
+    ).join("");
+    if (joined.trim() !== "")
+      richText.push({
+        props,
+        path: path4,
+        componentName: String(rec.name),
+        text: joined,
+        order
+      });
+  }
   const componentName = typeof rec.name === "string" ? rec.name : "";
   if (componentName === "chart" || componentName === "highcharts" || componentName === "table") {
     contentNodes.push({ props, path: path4, componentName });
@@ -6165,6 +6199,7 @@ function collectSlideNodes(component, path4, text, surfaces, boxes, contentNodes
       child,
       `${path4}/children/${index}`,
       text,
+      richText,
       surfaces,
       boxes,
       contentNodes,
@@ -6318,6 +6353,16 @@ function tableFact(node, slidePath, authoredProps) {
   }
   return { ...base, columns };
 }
+function authoredNameAtPointer(root, pointer) {
+  let node = root;
+  for (const token of pointer.split("/").slice(1)) {
+    const key = token.replace(/~1/g, "/").replace(/~0/g, "~");
+    node = Array.isArray(node) ? node[Number(key)] : asRecord(node)?.[key];
+    if (node === void 0) return void 0;
+  }
+  const name = asRecord(node)?.name;
+  return typeof name === "string" ? name : void 0;
+}
 function authoredPropsAtPointer(root, pointer) {
   let node = root;
   for (const token of pointer.split("/").slice(1)) {
@@ -6335,8 +6380,9 @@ function authoredPropsAtPointer(root, pointer) {
   }
   return asRecord(asRecord(node)?.props);
 }
-function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slideHeightIn, ctx, theme, slideBackground, analyzedTextPaths, analyzedContentPaths, paletteTokens, authoredPropsAt, authoredPath, addFact) {
+function addSlideFacts(roots, slidePath, renderedIndex, page, grid, slideWidthIn, slideHeightIn, ctx, theme, slideBackground, analyzedTextPaths, analyzedContentPaths, paletteTokens, authoredPropsAt, statedPropsAt, authoredPath, addFact, ownsProps = () => true) {
   const nodes = [];
+  const richNodes = [];
   const surfaces = [];
   const boxes = [];
   const contentNodes = [];
@@ -6346,6 +6392,7 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
       root.component,
       root.path,
       nodes,
+      richNodes,
       surfaces,
       boxes,
       contentNodes,
@@ -6359,20 +6406,30 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
     if (fact) addFact(fact);
   }
   boxes.forEach((node, boxIndex) => {
-    const box = resolveBox(node.props, grid, slideWidthIn, slideHeightIn);
+    const box = imageBox(
+      node,
+      resolveBox(node.props, grid, slideWidthIn, slideHeightIn),
+      statedPropsAt
+    );
     if (!isCompleteBox(box)) return;
+    const onSlide = /^\/children\/\d+\/children\/\d+$/.test(node.path) && authoredPath(node.path) === node.path;
+    const authored = onSlide ? authoredPropsAt(node.path) : void 0;
     addFact({
       id: `pptx:box:${renderedIndex}:${boxIndex}:${node.path}`,
       kind: "pptx/box",
       path: node.path,
       slidePath,
+      nodePath: node.path,
       componentName: node.componentName,
       order: node.order,
       opaque: node.opaque,
       xPt: box.xPt,
       yPt: box.yPt,
       widthPt: box.widthPt,
-      heightPt: box.heightPt
+      heightPt: box.heightPt,
+      ...typeof authored?.x === "number" && typeof authored?.y === "number" && authored.grid === void 0 && {
+        authoredPositionIn: { x: authored.x, y: authored.y }
+      }
     });
   });
   const surfaceBoxes = surfaces.flatMap((surface) => {
@@ -6382,7 +6439,7 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
   let bodyWords = 0;
   nodes.forEach((node, nodeIndex) => {
     const typography = resolveTypography(node.props, ctx);
-    if (typography.styleName !== "title" && typography.styleName !== "subtitle") {
+    if (!NOT_BODY_STYLES.has(typography.styleName ?? "")) {
       bodyWords += node.text.split(/\s+/).filter(Boolean).length;
     }
     if (analyzedTextPaths.has(node.path)) return;
@@ -6476,13 +6533,18 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
       }
     }
     const colorHex = typeof node.props.color === "string" ? resolveColor(node.props.color, theme)?.toUpperCase() : void 0;
+    const stated = statedPropsAt(node.path);
+    const setSize = stated && node.props.fit !== void 0 ? resolveTypography(stated, ctx).fontSize : void 0;
     addFact({
       id: `pptx:text:${renderedIndex}:${nodeIndex}:${node.path}`,
       kind: "pptx/text",
       path: node.path,
       slidePath,
+      ...page === void 0 ? { slideHidden: true } : { page },
+      nodePath: node.path,
       text: node.text,
       fontSizePt: typography.fontSize,
+      ...setSize !== void 0 && setSize !== typography.fontSize && { fitFromPt: setSize },
       lineSpacingPt: typography.lineSpacing,
       paraSpaceBeforePt: typography.paraSpaceBefore,
       paraSpaceAfterPt: typography.paraSpaceAfter,
@@ -6491,19 +6553,64 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
       ...boxYPt !== void 0 && { boxYPt },
       ...boxWidthPt !== void 0 && boxWidthPt > 0 && { boxWidthPt },
       ...boxHeightPt !== void 0 && boxHeightPt > 0 && { boxHeightPt },
+      insetsPt: textInsetsPt(node.props, node.componentName),
       verticalAlign: node.props.valign === "middle" || node.props.valign === "bottom" ? node.props.valign : "top",
       align: horizontalAlign(node.props, ctx),
       rotationDeg: asNumber(node.props.rotate) ?? 0,
       bold: typography.bold,
-      ...asNumber(node.props.fontSize) !== void 0 && {
+      // Only a size the author wrote has a pointer: component defaults and
+      // the fit pass also write `fontSize` into the processed props, onto a
+      // member the document does not have.
+      ...asNumber(node.props.fontSize) !== void 0 && asNumber(authoredPropsAt(node.path)?.fontSize) !== void 0 && {
         sizePath: `${node.path}/props/fontSize`
       },
       generated: authoredPath(node.path) !== node.path,
+      ownsProps: ownsProps(node.path),
       autoFit: node.props.h === void 0 && gridPos === void 0,
       ...colorHex !== void 0 && { colorHex },
       ...!backgroundUnknown && backgroundHexes.length > 0 && { backgroundHexes }
     });
   });
+  richNodes.forEach((node, nodeIndex) => {
+    if (analyzedTextPaths.has(node.path)) return;
+    analyzedTextPaths.add(node.path);
+    const typography = resolveTypography(node.props, ctx);
+    const box = resolveBox(node.props, grid, slideWidthIn, slideHeightIn);
+    const runs = node.props.runs.map(asRecord);
+    addFact({
+      id: `pptx:rich-text:${renderedIndex}:${nodeIndex}:${node.path}`,
+      kind: "pptx/rich-text",
+      path: node.path,
+      slidePath,
+      ...page === void 0 ? { slideHidden: true } : { page },
+      nodePath: node.path,
+      text: node.text,
+      ...typography.styleName && { styleName: typography.styleName },
+      runSizes: runs.flatMap((run, index) => {
+        if (!run || typeof run.text !== "string" || run.text.trim() === "")
+          return [];
+        const own = asNumber(run.fontSize);
+        return [
+          {
+            fontSizePt: own ?? typography.fontSize,
+            ...own !== void 0 && {
+              sizePath: `${node.path}/props/runs/${index}/fontSize`
+            }
+          }
+        ];
+      }),
+      generated: authoredPath(node.path) !== node.path,
+      ...box.xPt !== void 0 && { boxXPt: box.xPt },
+      ...box.yPt !== void 0 && { boxYPt: box.yPt },
+      ...box.widthPt !== void 0 && box.widthPt > 0 && {
+        boxWidthPt: box.widthPt
+      },
+      ...box.heightPt !== void 0 && box.heightPt > 0 && {
+        boxHeightPt: box.heightPt
+      },
+      rotationDeg: asNumber(node.props.rotate) ?? 0
+    });
+  });
   const CHROME_STYLES = /* @__PURE__ */ new Set(["footer", "tracker", "source", "caption"]);
   const carriesContent = (box) => box.componentName !== "shape" || typeof box.props.text === "string" && box.props.text.trim() !== "";
   addFact({
@@ -6526,23 +6633,31 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
       const stretched = authored.w !== void 0 && authored.h !== void 0 && !["contain", "cover"].includes(
         String(asRecord(authored.sizing)?.type ?? "")
       );
+      const widthPt = slideWidthIn * 72;
+      const heightPt = slideHeightIn * 72;
+      const bleed = isCompleteBox(resolved) && (resolved.xPt <= BLEED_TOLERANCE_PT && resolved.xPt + resolved.widthPt >= widthPt - BLEED_TOLERANCE_PT || resolved.yPt <= BLEED_TOLERANCE_PT && resolved.yPt + resolved.heightPt >= heightPt - BLEED_TOLERANCE_PT);
       addFact({
         id: `pptx:image:${renderedIndex}:${box.path}`,
         kind: "pptx/image",
         path: box.path,
+        slidePath,
+        bleed,
         ...typeof alt === "string" && alt.trim() !== "" && { alt },
         ...stretched && isCompleteBox(resolved) && resolved.heightPt > 0 && {
           drawnRatio: resolved.widthPt / resolved.heightPt
         },
-        ...natural !== void 0 && { naturalRatio: natural }
+        ...natural !== void 0 && { naturalRatio: natural },
+        ...stretched && typeof authored.w === "number" && typeof authored.h === "number" && {
+          authoredSizeIn: { w: authored.w, h: authored.h }
+        }
       });
     }
     const bullets = bulletItems(box.props);
-    if (bullets.length > 1)
+    if (bullets.length > 0)
       addFact({
         id: `pptx:bullets:${renderedIndex}:${box.path}`,
         kind: "pptx/bullets",
-        path: box.path,
+        path: slotOrNode(box.path, authoredPath),
         slidePath,
         items: bullets.length,
         longestWords: Math.max(
@@ -6555,7 +6670,7 @@ function preparePptxQualityDocument(document, options = {}) {
   const facts = [];
   const provenance = {};
   let sourceMap = {};
-  const authoredPath = (path4) => toAuthoredPointer(sourceMap, path4);
+  const authoredPath = (path4) => toAuthoredPointer(sourceMap, path4, options.expanded?.pluginOutputs);
   const addFact = (raw) => {
     const fact = {
       ...raw,
@@ -6602,12 +6717,12 @@ function preparePptxQualityDocument(document, options = {}) {
     });
   });
   const warnings = options.warnings ?? [];
-  const context = resolveThemeContext(document, {
+  const context = options.context ?? resolveThemeContext(document, {
     customThemes: options.customThemes,
     fonts: options.fonts,
     warnings
   });
-  const expanded = expandPptxBlocks(context.document, context.theme);
+  const expanded = options.expanded ?? expandPptxBlocks(context.document, context.theme);
   sourceMap = expanded.sourceMap;
   const processed = processPresentation(expanded.document, {
     theme: context.theme,
@@ -6701,10 +6816,17 @@ function preparePptxQualityDocument(document, options = {}) {
     (value) => `#${resolveColor(value, processed.theme)}`
   ) ?? SERIES_COLOR_TOKENS.filter((token) => paletteHexes[token] !== void 0);
   const authoredPropsAt = (pointer) => authoredPropsAtPointer(document, authoredPath(pointer));
+  const pluginOutputs = options.expanded?.pluginOutputs ?? [];
+  const ownsProps = (pointer) => !pluginOutputs.some(
+    (prefix) => pointer === prefix || pointer.startsWith(`${prefix}/`)
+  ) && authoredNameAtPointer(document, authoredPath(pointer)) !== "block";
+  const statedPropsAt = (pointer) => authoredPropsAtPointer(expanded.document, pointer);
+  let exportedPages = 0;
   processed.slides.forEach((slide, renderedIndex) => {
     const authoredIndex = slideIndexes[renderedIndex];
     if (authoredIndex === void 0) return;
     const slidePath = `/children/${authoredIndex}`;
+    const page = slide.hidden === true ? void 0 : exportedPages++;
     const roots = slide.components.map(
       (component, index) => ({
         component,
@@ -6715,6 +6837,7 @@ function preparePptxQualityDocument(document, options = {}) {
       roots,
       slidePath,
       renderedIndex,
+      page,
       processed.grid,
       processed.slideWidth,
       processed.slideHeight,
@@ -6732,8 +6855,10 @@ function preparePptxQualityDocument(document, options = {}) {
       analyzedContentPaths,
       paletteTokens,
       authoredPropsAt,
+      statedPropsAt,
       authoredPath,
-      addFact
+      addFact,
+      ownsProps
     );
   });
   for (const budget of blockSlotBudgets(context.document, expanded.blocks)) {
@@ -6743,10 +6868,10 @@ function preparePptxQualityDocument(document, options = {}) {
       ...budget
     });
   }
-  const slotTextNodes = textNodesBySlot(processed, slideIndexes, sourceMap);
+  const slotNodes = nodesBySlot(processed, slideIndexes, sourceMap);
   for (const role of blockSlotRoles(context.document, expanded.blocks)) {
-    const present = role.value !== void 0 && role.value !== null && role.value !== "" && role.value !== false && (!Array.isArray(role.value) || role.value.length > 0);
-    const bound = slotTextNodes.get(role.path);
+    const present = role.value !== void 0 && role.value !== null && role.value !== false && (typeof role.value !== "string" || role.value.trim() !== "") && (!Array.isArray(role.value) || role.value.length > 0);
+    const bound = slotNodes.get(role.path);
     let measured;
     if (bound && typeof bound.props.text === "string") {
       const typography = resolveTypography(bound.props, ctx);
@@ -6779,10 +6904,35 @@ function preparePptxQualityDocument(document, options = {}) {
       slot: role.slot,
       role: role.role,
       present,
+      ...bound && { nodePath: bound.path },
       ...typeof role.value === "string" && { text: role.value },
       ...measured
     });
   }
+  const footerType = typeof processed.theme.chrome?.confidentialFooter?.type === "string" ? processed.theme.chrome.confidentialFooter.type : "footer";
+  processed.slides.forEach((slide, renderedIndex) => {
+    const authoredIndex = slideIndexes[renderedIndex];
+    if (authoredIndex === void 0) return;
+    const slidePath = `/children/${authoredIndex}`;
+    const onSlide = (fact) => "slidePath" in fact && fact.slidePath === slidePath;
+    const texts = facts.filter(
+      (fact) => (fact.kind === "pptx/text" || fact.kind === "pptx/rich-text") && onSlide(fact)
+    );
+    addFact({
+      id: `pptx:slide-chrome:${slidePath}`,
+      kind: "pptx/slide-chrome",
+      path: slidePath,
+      index: renderedIndex,
+      ...slide.hidden === true && { hidden: true },
+      blocks: expanded.blocks.filter(
+        (pointer) => pointer.startsWith(`${slidePath}/children/`)
+      ).length,
+      pageNumber: texts.some((fact) => fact.text.includes("{PAGE_NUMBER}")),
+      footer: texts.some((fact) => fact.styleName === footerType) || facts.some(
+        (fact) => fact.kind === "pptx/chrome-slot" && fact.role === "footer" && fact.present && onSlide(fact)
+      )
+    });
+  });
   return {
     format: "pptx",
     model: {
@@ -6805,14 +6955,18 @@ function preparePptxQualityDocument(document, options = {}) {
     }
   };
 }
-function textNodesBySlot(processed, slideIndexes, sourceMap) {
+function nodesBySlot(processed, slideIndexes, sourceMap) {
   const found = /* @__PURE__ */ new Map();
   const visit = (component, path4) => {
     if (component.enabled === false) return;
     if (component.name === "text") {
       const origin = toAuthoredPointer(sourceMap, `${path4}/props/text`);
       if (origin !== `${path4}/props/text` && !found.has(origin))
-        found.set(origin, { props: asRecord(component.props) ?? {} });
+        found.set(origin, { props: asRecord(component.props) ?? {}, path: path4 });
+    } else {
+      const origin = toAuthoredPointer(sourceMap, path4);
+      if (origin !== path4 && origin.includes("/props/slots/") && !found.has(origin))
+        found.set(origin, { props: asRecord(component.props) ?? {}, path: path4 });
     }
     (component.children ?? []).forEach(
       (child, index) => visit(child, `${path4}/children/${index}`)
@@ -7571,6 +7725,8 @@ import {
 // src/quality/rules.ts
 import {
   chartInfoDesignFindings,
+  configurationLabel,
+  configurationSource,
   DEFAULT_MAXIMUM_CHART_SERIES,
   DEFAULT_MAXIMUM_PIE_SLICES,
   fontCountFinding,
@@ -7711,19 +7867,24 @@ var pptxMinimumFontRule = {
     );
     return textFacts(facts).filter((fact) => fact.fontSizePt < minimum).map((fact) => ({
       message: `Effective font size is ${fact.fontSizePt}pt \u2014 unreadable on a projected slide.`,
-      path: `${fact.path}/props`,
+      // Text a definition or a plugin generated reports at the invocation
+      // the author wrote, whose props are the block's or the plugin's: no
+      // fontSize of theirs to lift, so no patch.
+      path: fact.ownsProps ? `${fact.path}/props` : fact.path,
       suggestion: `Use at least ${minimum}pt; captions rarely work below 10pt.`,
       context: { fontSize: fact.fontSizePt, threshold: minimum },
       evidence: { actual: fact.fontSizePt, expected: minimum, unit: "pt" },
       // `add` replaces an existing member, so this lifts an explicit
       // fontSize and overrides an inherited style value alike.
-      fixes: [
-        {
-          op: "add",
-          path: `${fact.path}/props/fontSize`,
-          value: minimum
-        }
-      ]
+      ...fact.ownsProps && {
+        fixes: [
+          {
+            op: "add",
+            path: `${fact.path}/props/fontSize`,
+            value: minimum
+          }
+        ]
+      }
     }));
   }
 };
@@ -8225,7 +8386,8 @@ var pptxOffCanvasRule = {
   code: QUALITY_CODES.OFF_CANVAS,
   category: "integrity",
   defaultSeverity: "warning",
-  defaultCertainty: "measured",
+  // The box is measured; the ink inside it is the width model's estimate.
+  defaultCertainty: "estimated",
   formats: ["pptx"],
   defaultParameters: {
     tolerancePt: DEFAULT_OFF_CANVAS_TOLERANCE_PT,
@@ -8326,13 +8488,67 @@ var pptxRequiredChromeRule = {
     if (required.length === 0) return [];
     return facts.filter(
       (fact) => fact.kind === "pptx/chrome-slot"
-    ).filter((fact) => required.includes(fact.role) && !fact.present).map((fact) => ({
-      path: fact.path,
-      relatedPaths: [fact.invocation],
-      message: `${fact.block} states no ${fact.role} in its "${fact.slot}" slot; the ${profile?.id ?? "selected"} profile expects one on every ${fact.block}.`,
-      suggestion: `Fill the "${fact.slot}" slot. The theme already styles it.`,
-      context: { block: fact.block, slot: fact.slot, role: fact.role }
-    }));
+    ).filter((fact) => required.includes(fact.role) && !fact.present).map((fact) => {
+      const source = configurationSource(configuration, "required");
+      return {
+        path: fact.path,
+        relatedPaths: [fact.invocation],
+        message: `${fact.block} states no ${fact.role} in its "${fact.slot}" slot; ${configurationLabel(source, profile)} expects one on every ${fact.block}.`,
+        suggestion: `Fill the "${fact.slot}" slot. The theme already styles it.`,
+        context: { block: fact.block, slot: fact.slot, role: fact.role },
+        evidence: {
+          actual: "empty",
+          expected: fact.role,
+          values: { source, required }
+        }
+      };
+    });
+  }
+};
+var SLIDE_CHROME_PARTS = ["pageNumber", "footer"];
+var pptxSlideFooterRule = {
+  id: "pptx/slide-footer",
+  description: "A block-built slide without the running chrome a profile or policy expects: a page number, a footer line. Off until one names parts.",
+  code: QUALITY_CODES.CHROME_MISSING,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultParameters: { required: [], fromSlide: 1 },
+  evaluate: ({ facts, configuration, profile }) => {
+    const required = stringListParameter(
+      configuration.parameters,
+      "required"
+    ).filter(
+      (part) => SLIDE_CHROME_PARTS.includes(part)
+    );
+    if (required.length === 0) return [];
+    const from = numberParameter(configuration.parameters, "fromSlide", 1);
+    return facts.filter(
+      (fact) => fact.kind === "pptx/slide-chrome" && fact.blocks > 0 && fact.hidden !== true && fact.index >= from
+    ).flatMap((fact) => {
+      const missing = required.filter((part) => !fact[part]);
+      if (missing.length === 0) return [];
+      const parts = missing.map((part) => part === "pageNumber" ? "page number" : "footer").join(" or ");
+      const source = configurationSource(
+        configuration,
+        "required",
+        "fromSlide"
+      );
+      return [
+        {
+          path: fact.path,
+          message: `Slide ${fact.index + 1} carries no ${parts}; ${configurationLabel(source, profile)} expects one on every slide a block builds from slide ${from + 1} on.`,
+          suggestion: "Build the slide with a block that draws the running footer \u2014 the house blocks set {PAGE_NUMBER} / {PAGE_COUNT} in the footer role \u2014 or add that text to the definition the slide invokes.",
+          context: { slide: fact.index, missing },
+          evidence: {
+            actual: required.filter((part) => fact[part]),
+            expected: required,
+            values: { source, fromSlide: from }
+          }
+        }
+      ];
+    });
   }
 };
 var pptxActionTitleRule = {
@@ -8365,23 +8581,49 @@ var pptxActionTitleRule = {
   }
 };
 var TITLE_DRIFT_TOLERANCE_PT = 2;
+var FIRST_BASELINE_EM = 0.8;
+var TITLE_PLACEMENT_LINES = 2;
 var PPTX_TYPE_VOCABULARY = {
   subject: "deck",
   keepTo: "Keep to the theme styles \u2014 title, heading, body, label, statistic \u2014 and drop the ad-hoc sizes."
 };
+var PPTX_SLIDE_TYPE_VOCABULARY = {
+  subject: "slide",
+  keepTo: "Give the slide fewer levels: let the title, the body and one supporting size carry it, in the theme styles."
+};
 function pptxThemeFact(facts) {
   return facts.find(
     (fact) => fact.kind === "pptx/theme"
   );
 }
 function paintedSizes(facts) {
-  return textFacts(facts).map((fact) => ({
-    path: fact.path,
-    ...fact.styleName !== void 0 && { role: fact.styleName },
-    fontSizePt: fact.fontSizePt,
-    ...fact.sizePath !== void 0 && { sizePath: fact.sizePath },
-    generated: fact.generated
-  }));
+  const sizes = [];
+  for (const fact of textFacts(facts)) {
+    if (fact.slideHidden) continue;
+    sizes.push({
+      path: fact.path,
+      slidePath: fact.slidePath,
+      ...fact.styleName !== void 0 && { role: fact.styleName },
+      fontSizePt: fact.fontSizePt,
+      ...fact.sizePath !== void 0 && { sizePath: fact.sizePath },
+      generated: fact.generated
+    });
+  }
+  for (const fact of facts) {
+    if (fact.kind !== "pptx/rich-text") continue;
+    const rich = fact;
+    if (rich.slideHidden) continue;
+    for (const run of rich.runSizes)
+      sizes.push({
+        path: rich.path,
+        slidePath: rich.slidePath,
+        ...rich.styleName !== void 0 && { role: rich.styleName },
+        fontSizePt: run.fontSizePt,
+        ...run.sizePath !== void 0 && { sizePath: run.sizePath },
+        generated: rich.generated
+      });
+  }
+  return sizes;
 }
 var pptxTypeScaleRule = {
   id: "pptx/type-scale",
@@ -8407,21 +8649,56 @@ var pptxTypeScaleRule = {
 };
 var pptxSizeCountRule = {
   id: "pptx/size-count",
-  description: "More distinct text sizes than maximumSizes allows, blocks included. Off until a profile or policy enables it.",
+  description: "More distinct text sizes than maximumSizes allows across the deck, or than maximumSizesPerSlide allows on one slide (0: no per-slide ceiling), blocks and runs included. Off until a profile or policy enables it.",
   code: QUALITY_CODES.TYPE_SIZE_COUNT,
   category: "consistency",
   defaultSeverity: "warning",
   defaultCertainty: "deterministic",
   formats: ["pptx"],
   defaultEnabled: false,
-  defaultParameters: { maximumSizes: 8 },
-  evaluate: ({ facts, configuration, profile }) => sizeCountFinding(
-    paintedSizes(facts),
-    numberParameter(configuration.parameters, "maximumSizes", 8),
-    pptxThemeFact(facts)?.path ?? "/props",
-    profile?.id,
-    PPTX_TYPE_VOCABULARY
-  )
+  defaultParameters: { maximumSizes: 8, maximumSizesPerSlide: 0 },
+  evaluate: ({ facts, configuration, profile }) => {
+    const sizes = paintedSizes(facts);
+    const setBy = (parameter) => {
+      const source = configurationSource(configuration, parameter);
+      return { source, label: configurationLabel(source, profile) };
+    };
+    const findings = sizeCountFinding(
+      sizes,
+      numberParameter(configuration.parameters, "maximumSizes", 8),
+      pptxThemeFact(facts)?.path ?? "/props",
+      setBy("maximumSizes"),
+      PPTX_TYPE_VOCABULARY
+    ).map((finding) => ({
+      ...finding,
+      context: { ...finding.context, scope: "deck" }
+    }));
+    const perSlide = numberParameter(
+      configuration.parameters,
+      "maximumSizesPerSlide",
+      0
+    );
+    if (perSlide <= 0) return findings;
+    const bySlide = /* @__PURE__ */ new Map();
+    for (const size of sizes)
+      bySlide.set(size.slidePath, [
+        ...bySlide.get(size.slidePath) ?? [],
+        size
+      ]);
+    for (const [slidePath, onSlide] of bySlide)
+      for (const finding of sizeCountFinding(
+        onSlide,
+        perSlide,
+        slidePath,
+        setBy("maximumSizesPerSlide"),
+        PPTX_SLIDE_TYPE_VOCABULARY
+      ))
+        findings.push({
+          ...finding,
+          context: { ...finding.context, scope: "slide" }
+        });
+    return findings;
+  }
 };
 var pptxRoleDriftRule = {
   id: "pptx/role-drift",
@@ -8437,53 +8714,107 @@ var pptxRoleDriftRule = {
     return theme ? roleDriftFindings(paintedSizes(facts), theme.roleSizesPt) : [];
   }
 };
-function titleGroups(facts, styles) {
-  const texts = textFacts(facts).filter(
-    (fact) => fact.boxXPt !== void 0 && fact.boxYPt !== void 0
+var EDGE_NAMES = {
+  left: "left edge",
+  center: "centre line",
+  right: "right edge"
+};
+function laidOutTitle(fact, path4, order) {
+  if (fact.boxXPt === void 0 || fact.boxYPt === void 0 || fact.boxWidthPt === void 0 || fact.rotationDeg % 360 !== 0)
+    return void 0;
+  const [top, right, bottom, left] = fact.insetsPt;
+  const innerWidth = Math.max(1, fact.boxWidthPt - left - right);
+  const { heightPt, lines } = estimateTextHeightPt(
+    fact.text,
+    innerWidth,
+    fact.fontSizePt,
+    fact.lineSpacingPt,
+    fact.paraSpaceBeforePt,
+    fact.paraSpaceAfterPt
+  );
+  let textTop = fact.boxYPt + top;
+  if (fact.boxHeightPt !== void 0 && !fact.autoFit) {
+    const room = fact.boxHeightPt - top - bottom - heightPt;
+    if (fact.verticalAlign === "middle") textTop += room / 2;
+    else if (fact.verticalAlign === "bottom") textTop += room;
+  }
+  const align = fact.align === "justify" ? "left" : fact.align;
+  const edgePt = align === "center" ? fact.boxXPt + left + innerWidth / 2 : align === "right" ? fact.boxXPt + fact.boxWidthPt - right : fact.boxXPt + left;
+  const style = fact.styleName ?? "unstyled";
+  const setSizePt = fact.fitFromPt ?? fact.fontSizePt;
+  return {
+    fact,
+    path: path4,
+    kind: `${style}|${setSizePt}|${align}`,
+    style,
+    setSizePt,
+    align,
+    lines,
+    baselinePt: textTop + FIRST_BASELINE_EM * fact.fontSizePt,
+    edgePt,
+    order
+  };
+}
+function deckTitles(facts, styles) {
+  const texts = textFacts(facts).filter((fact) => !fact.slideHidden);
+  const slideIndex = (fact) => Number(/^\/children\/(\d+)/.exec(fact.slidePath)?.[1] ?? 0);
+  const order = new Map(
+    texts.map((fact, index) => [fact, slideIndex(fact) * 1e4 + index])
   );
-  const groups = /* @__PURE__ */ new Map();
+  const byNode = new Map(texts.map((fact) => [fact.nodePath, fact]));
+  const titles = [];
   const claimed = /* @__PURE__ */ new Set();
-  const push = (key, fact) => {
+  const add = (fact, path4) => {
     if (claimed.has(fact)) return;
     claimed.add(fact);
-    groups.set(key, [...groups.get(key) ?? [], fact]);
+    const title = laidOutTitle(fact, path4, order.get(fact));
+    if (title) titles.push(title);
   };
-  for (const slot of facts) {
-    if (slot.kind !== "pptx/chrome-slot" || slot.role !== "actionTitle")
-      continue;
-    const chrome = slot;
-    if (chrome.text === void 0) continue;
-    const painted = texts.find(
-      (fact) => fact.slidePath === chrome.slidePath && fact.text === chrome.text
-    );
-    if (painted) push(chrome.block, painted);
-  }
+  for (const slot of facts)
+    if (slot.kind === "pptx/chrome-slot" && slot.role === "actionTitle" && slot.nodePath !== void 0) {
+      const painted = byNode.get(slot.nodePath);
+      if (painted) add(painted, slot.path);
+    }
   for (const fact of texts)
     if (fact.styleName !== void 0 && styles.includes(fact.styleName))
-      push(`style:${fact.styleName}`, fact);
-  return groups;
-}
-function prevailing(values) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
-  let best;
-  let bestCount = 0;
-  for (const value of values) {
-    const count = counts.get(value);
-    if (count > bestCount) {
-      best = value;
-      bestCount = count;
+      add(fact, fact.path);
+  return titles.sort((a, b) => a.order - b.order);
+}
+function titlePlacements(titles, tolerance) {
+  const lands = (a, b) => Math.abs(a.baselinePt - b.baselinePt) <= tolerance && Math.abs(a.edgePt - b.edgePt) <= tolerance;
+  const byKind = /* @__PURE__ */ new Map();
+  for (const title of titles)
+    byKind.set(title.kind, [...byKind.get(title.kind) ?? [], title]);
+  const placements = [];
+  for (const kind of byKind.values()) {
+    let pending = kind;
+    while (pending.length > 0) {
+      let reference = pending[0];
+      let most = 0;
+      for (const candidate of pending) {
+        const count = pending.filter((other) => lands(other, candidate)).length;
+        if (count > most) {
+          reference = candidate;
+          most = count;
+        }
+      }
+      const reach = TITLE_PLACEMENT_LINES * reference.fact.lineSpacingPt;
+      const members = pending.filter(
+        (title) => Math.abs(title.baselinePt - reference.baselinePt) <= reach && Math.abs(title.edgePt - reference.edgePt) <= reach
+      );
+      placements.push({ reference, members });
+      pending = pending.filter((title) => !members.includes(title));
     }
   }
-  return best;
+  return placements;
 }
 var pptxTitleDriftRule = {
   id: "pptx/title-drift",
-  description: "A slide title away from the left edge or baseline the deck\u2019s other titles of that kind share. Off until a profile or policy enables it.",
+  description: "A slide title whose laid-out first baseline or aligned edge is away from where the deck\u2019s other titles of that kind land. Off until a profile or policy enables it.",
   code: QUALITY_CODES.TITLE_DRIFT,
   category: "consistency",
   defaultSeverity: "warning",
-  defaultCertainty: "deterministic",
+  defaultCertainty: "estimated",
   formats: ["pptx"],
   defaultEnabled: false,
   defaultParameters: {
@@ -8498,40 +8829,53 @@ var pptxTitleDriftRule = {
       TITLE_DRIFT_TOLERANCE_PT
     );
     const findings = [];
-    for (const [kind, titles] of titleGroups(facts, styles)) {
-      if (titles.length < 2) continue;
-      const axes = [
-        {
-          key: "left edge",
-          prop: "boxXPt",
-          value: prevailing(titles.map((fact) => fact.boxXPt))
-        },
-        {
-          key: "baseline",
-          prop: "boxYPt",
-          value: prevailing(titles.map((fact) => fact.boxYPt))
-        }
-      ];
-      for (const fact of titles) {
-        const off = axes.filter(
-          (axis) => axis.value !== void 0 && Math.abs(fact[axis.prop] - axis.value) > tolerance
+    for (const { reference, members } of titlePlacements(
+      deckTitles(facts, styles),
+      tolerance
+    )) {
+      if (members.length < 2) continue;
+      const agreeing = members.filter(
+        (title) => Math.abs(title.baselinePt - reference.baselinePt) <= tolerance && Math.abs(title.edgePt - reference.edgePt) <= tolerance
+      );
+      for (const title of members) {
+        if (agreeing.includes(title)) continue;
+        const edge = EDGE_NAMES[title.align];
+        const off = [
+          {
+            axis: "first baseline",
+            actual: title.baselinePt,
+            expected: reference.baselinePt
+          },
+          { axis: edge, actual: title.edgePt, expected: reference.edgePt }
+        ].filter(
+          (entry) => Math.abs(entry.actual - entry.expected) > tolerance
         );
-        if (off.length === 0) continue;
         const [first] = off;
+        const size = title.fact.fontSizePt !== reference.fact.fontSizePt ? ` The fit pass sets it at ${title.fact.fontSizePt}pt, where they set at ${reference.fact.fontSizePt}pt.` : "";
         findings.push({
-          path: fact.path,
-          message: `This ${kind.startsWith("style:") ? kind.slice(6) : kind} title sits at ${off.map((axis) => `${axis.key} ${round(fact[axis.prop])}pt`).join(", ")}; the deck's others share ${off.map((axis) => `${axis.key} ${round(axis.value)}pt`).join(", ")}.`,
-          suggestion: "Place every title of one kind with the same block or the same coordinates, so the deck holds one line down the page.",
+          path: title.path,
+          relatedPaths: agreeing.map((other) => other.path),
+          message: `This ${title.style} title lays out at ${off.map((entry) => `${entry.axis} ${round(entry.actual)}pt`).join(", ")}; the deck's other titles of that kind land at ${off.map((entry) => `${entry.axis} ${round(entry.expected)}pt`).join(", ")}.${size}`,
+          suggestion: "Place every title of one kind with the same block or the same coordinates, anchor them alike, and keep each short enough to set at the size the others keep.",
           context: {
-            kind,
-            axes: off.map((axis) => axis.key),
-            slide: fact.slidePath
+            style: title.style,
+            setSizePt: title.setSizePt,
+            align: title.align,
+            axes: off.map((entry) => entry.axis),
+            slide: title.fact.slidePath
           },
           evidence: {
-            actual: round(fact[first.prop]),
-            expected: round(first.value),
+            summary: "estimated first baseline and aligned edge",
+            actual: round(first.actual),
+            expected: round(first.expected),
             unit: "pt",
-            values: { axis: first.key, source: "profile" }
+            values: {
+              axis: first.axis,
+              lines: title.lines,
+              fontSizePt: title.fact.fontSizePt,
+              verticalAlign: title.fact.verticalAlign,
+              source: configurationSource(configuration, "tolerancePt")
+            }
           }
         });
       }
@@ -8584,7 +8928,9 @@ var pptxBulletRule = {
             actual: bullets.items,
             expected: maximumBullets,
             unit: "bullets",
-            values: { source: "profile" }
+            values: {
+              source: configurationSource(configuration, "maximumBullets")
+            }
           }
         });
       if (maximumWords > 0 && bullets.longestWords > maximumWords)
@@ -8598,16 +8944,39 @@ var pptxBulletRule = {
             actual: bullets.longestWords,
             expected: maximumWords,
             unit: "words",
-            values: { source: "profile" }
+            values: {
+              source: configurationSource(
+                configuration,
+                "maximumWordsPerBullet"
+              )
+            }
           }
         });
     }
     return findings;
   }
 };
+function safeAreaFixes(fact, canvas, safe) {
+  const position = fact.authoredPositionIn;
+  if (position === void 0 || fact.widthPt > canvas.widthPt - 2 * safe || fact.heightPt > canvas.heightPt - 2 * safe)
+    return [];
+  const clamp = (valuePt, sizePt, extentPt) => {
+    const low = Math.ceil(safe / 72 * 1e3) / 1e3;
+    const high = Math.floor((extentPt - safe - sizePt) / 72 * 1e3) / 1e3;
+    return Math.min(Math.max(valuePt / 72, low), high);
+  };
+  const fixes = [];
+  const x = clamp(fact.xPt, fact.widthPt, canvas.widthPt);
+  const y = clamp(fact.yPt, fact.heightPt, canvas.heightPt);
+  if (Math.abs(x - position.x) > 5e-4)
+    fixes.push({ op: "replace", path: `${fact.path}/props/x`, value: x });
+  if (Math.abs(y - position.y) > 5e-4)
+    fixes.push({ op: "replace", path: `${fact.path}/props/y`, value: y });
+  return fixes;
+}
 var pptxSafeAreaRule = {
   id: "pptx/safe-area",
-  description: "Content outside the theme\u2019s safe area that is neither chrome nor a full bleed. Off until a profile or policy enables it.",
+  description: "Content outside the theme\u2019s safe area that is neither chrome (a tracker, footer, source or logo) nor a full bleed. Off until a profile or policy enables it.",
   code: QUALITY_CODES.SAFE_AREA,
   category: "composition",
   defaultSeverity: "warning",
@@ -8626,20 +8995,16 @@ var pptxSafeAreaRule = {
     );
     const safe = canvas?.safeAreaPt;
     if (canvas === void 0 || safe === void 0 || safe <= 0) return [];
-    const chromePaths = new Set(
+    const chromeNodes = new Set(
       facts.filter(
-        (fact) => fact.kind === "pptx/chrome-slot" && (fact.role === "tracker" || fact.role === "footer")
-      ).map((fact) => fact.path)
-    );
-    const chromeStyles = /* @__PURE__ */ new Set(["footer", "tracker"]);
-    const styledChrome = new Set(
-      textFacts(facts).filter(
-        (fact) => fact.styleName !== void 0 && chromeStyles.has(fact.styleName)
-      ).map((fact) => fact.path)
+        (fact) => fact.kind === "pptx/chrome-slot" && (fact.role === "tracker" || fact.role === "footer" || fact.role === "source" || fact.role === "logo")
+      ).flatMap((fact) => fact.nodePath ? [fact.nodePath] : [])
     );
-    return facts.filter((fact) => fact.kind === "pptx/box").filter(
-      (fact) => !chromePaths.has(fact.path) && !styledChrome.has(fact.path)
-    ).flatMap((fact) => {
+    const chromeStyles = /* @__PURE__ */ new Set(["footer", "tracker", "source"]);
+    for (const fact of facts)
+      if ((fact.kind === "pptx/text" || fact.kind === "pptx/rich-text") && fact.styleName !== void 0 && chromeStyles.has(fact.styleName))
+        chromeNodes.add(fact.nodePath);
+    return facts.filter((fact) => fact.kind === "pptx/box").filter((fact) => !chromeNodes.has(fact.nodePath)).flatMap((fact) => {
       const right = fact.xPt + fact.widthPt;
       const bottom = fact.yPt + fact.heightPt;
       const spansWidth = fact.xPt <= tolerance && right >= canvas.widthPt - tolerance;
@@ -8658,6 +9023,7 @@ var pptxSafeAreaRule = {
         right - (canvas.widthPt - safe),
         bottom - (canvas.heightPt - safe)
       );
+      const fixes = safeAreaFixes(fact, canvas, safe);
       return [
         {
           path: fact.path,
@@ -8669,7 +9035,8 @@ var pptxSafeAreaRule = {
             expected: 0,
             unit: "pt",
             values: { source: "theme" }
-          }
+          },
+          ...fixes.length > 0 && { fixes }
         }
       ];
     });
@@ -8688,8 +9055,8 @@ var pptxSlideTitleRule = {
   evaluate: ({ facts, configuration }) => {
     const styles = stringListParameter(configuration.parameters, "titleStyles");
     const titledSlides = /* @__PURE__ */ new Set();
-    for (const fact of textFacts(facts))
-      if (fact.styleName !== void 0 && styles.includes(fact.styleName))
+    for (const fact of facts)
+      if ((fact.kind === "pptx/text" || fact.kind === "pptx/rich-text") && fact.styleName !== void 0 && styles.includes(fact.styleName))
         titledSlides.add(fact.slidePath);
     for (const fact of facts)
       if (fact.kind === "pptx/chrome-slot" && fact.role === "actionTitle" && fact.present)
@@ -8705,11 +9072,33 @@ var pptxSlideTitleRule = {
         actual: 0,
         expected: 1,
         unit: "titles",
-        values: { source: "profile" }
+        values: { source: configurationSource(configuration) }
       }
     }));
   }
 };
+var pptxFigureLabelRule = {
+  id: "pptx/figure-label",
+  description: "An image with no alt text, a background that bleeds off the slide aside. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.FIGURE_UNLABELLED,
+  category: "accessibility",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => {
+    const unlabelled = /* @__PURE__ */ new Map();
+    for (const fact of facts)
+      if (fact.kind === "pptx/image" && fact.alt === void 0 && !fact.bleed)
+        unlabelled.set(fact.path, fact);
+    return [...unlabelled.values()].map((fact) => ({
+      path: fact.path,
+      message: "This image carries no alt text, so nothing in the deck says what it shows to a reader who cannot see it.",
+      suggestion: "Write `alt` on the image: what it shows, in a sentence. A decorative background can bleed off the slide instead.",
+      context: { slidePath: fact.slidePath }
+    }));
+  }
+};
 var pptxImageAspectRule = {
   id: "pptx/image-aspect",
   description: "An image drawn at an aspect the asset does not have, where the asset can be read from the document.",
@@ -8732,7 +9121,20 @@ var pptxImageAspectRule = {
         {
           path: fact.path,
           drawn: fact.drawnRatio,
-          natural: fact.naturalRatio
+          natural: fact.naturalRatio,
+          ...fact.authoredSizeIn && {
+            sides: {
+              width: {
+                path: `${fact.path}/props/w`,
+                value: fact.authoredSizeIn.w
+              },
+              height: {
+                path: `${fact.path}/props/h`,
+                value: fact.authoredSizeIn.h
+              },
+              decimals: 3
+            }
+          }
         },
         "slide",
         tolerance
@@ -8758,6 +9160,7 @@ var PPTX_QUALITY_RULES = {
     pptxOffCanvasRule,
     pptxSlotBudgetRule,
     pptxRequiredChromeRule,
+    pptxSlideFooterRule,
     pptxActionTitleRule,
     pptxTypeScaleRule,
     pptxSizeCountRule,
@@ -8766,6 +9169,7 @@ var PPTX_QUALITY_RULES = {
     pptxBulletRule,
     pptxSafeAreaRule,
     pptxSlideTitleRule,
+    pptxFigureLabelRule,
     pptxImageAspectRule
   ]
 };
@@ -8791,15 +9195,23 @@ var PPTX_QUALITY_PROFILES = {
   "consulting-deck": {
     id: "consulting-deck",
     formats: ["pptx"],
-    description: "Consulting readout: every content slide leads with a two-line action title, every chart carries a takeaway and a source, content stays inside the theme\u2019s safe area, bullets stay under five and under twelve words, every size is on the theme scale with at most eight in play, and titles of one kind hold one line.",
+    description: "Consulting readout: every content slide leads with a two-line action title, every chart carries a takeaway and a source, every slide a block builds after the cover carries its page number, content stays inside the theme\u2019s safe area, a box holds at most five bullets of at most twelve words, every figure carries alt text, every size is on the theme scale with at most nine in the deck and six on a slide, and titles of one kind hold one line.",
     rules: {
       "pptx/required-chrome": {
         parameters: { required: ["takeaway", "source"] }
       },
+      "pptx/slide-footer": { parameters: { required: ["pageNumber"] } },
       "pptx/action-title": { parameters: { maxLines: 2 } },
       "pptx/slide-density": { parameters: { maximumBodyWords: 90 } },
       "pptx/type-scale": { enabled: true },
-      "pptx/size-count": { enabled: true, parameters: { maximumSizes: 8 } },
+      // Measured 2026-09-15, runs included: the house deck paints nine sizes
+      // (9, 10, 12, 14, 16, 18, 28, 32, 40) and six on its busiest slide, and
+      // so did every one of the 22 verification decks built from its blocks.
+      // A size past these is one no house block paints.
+      "pptx/size-count": {
+        enabled: true,
+        parameters: { maximumSizes: 9, maximumSizesPerSlide: 6 }
+      },
       "pptx/role-drift": { enabled: true },
       "pptx/title-drift": {
         enabled: true,
@@ -8809,7 +9221,8 @@ var PPTX_QUALITY_PROFILES = {
         parameters: { maximumBullets: 5, maximumWordsPerBullet: 12 }
       },
       "pptx/safe-area": { enabled: true },
-      "pptx/slide-title": { enabled: true }
+      "pptx/slide-title": { enabled: true },
+      "pptx/figure-label": { enabled: true }
     }
   }
 };
@@ -9080,97 +9493,152 @@ function createBuilderImpl(state) {
       newState
     );
   }
-  async function generate(document, options) {
-    try {
-      let internalDocument = document;
-      const renderer = options?.renderer ?? state.renderer ?? internalDocument.renderer;
-      const validationDocument = renderer === void 0 ? internalDocument : { ...internalDocument, renderer };
-      const validationOptions = {
-        ...state.validation,
-        ...options?.validation
-      };
-      if (validationOptions.enabled !== false) {
-        const result = validatePresentation(
-          validationDocument,
-          state.components,
-          { allowUnknownFields: validationOptions.allowUnknownFields }
+  async function expandPresentation(document, options) {
+    let internalDocument = document;
+    const renderer = options?.renderer ?? state.renderer ?? internalDocument.renderer;
+    const validationDocument = renderer === void 0 ? internalDocument : { ...internalDocument, renderer };
+    const validationOptions = {
+      ...state.validation,
+      ...options?.validation
+    };
+    if (validationOptions.enabled !== false) {
+      const result = validatePresentation(
+        validationDocument,
+        state.components,
+        { allowUnknownFields: validationOptions.allowUnknownFields }
+      );
+      if (!result.valid) {
+        throw new ComponentValidationError3(result.errors, internalDocument);
+      }
+    } else if (!internalDocument || internalDocument.name !== "pptx") {
+      throw new Error("Top-level component must be a pptx component");
+    }
+    const warnings = [];
+    const context = resolveThemeContext(internalDocument, {
+      customThemes: state.customThemes,
+      fonts: state.fonts,
+      warnings,
+      defaultThemeName: typeof state.theme === "string" ? state.theme : void 0,
+      resolveNamedTheme: (name, authored) => state.customThemes?.[name] ?? (authored && hasPptxTheme(name) ? getPptxTheme(name) : void 0) ?? (typeof state.theme === "object" && state.theme !== null ? state.theme : getPptxTheme(name))
+    });
+    const modedRoot = context.document;
+    const resolvedTheme = context.theme;
+    const validateEmitted = validationOptions.enabled === false ? void 0 : (emitted, componentLabel, parentName) => {
+      let validationDocument2;
+      if (parentName === "pptx") {
+        validationDocument2 = {
+          ...modedRoot,
+          ...renderer !== void 0 ? { renderer } : {},
+          children: emitted
+        };
+      } else if (parentName === "slide") {
+        validationDocument2 = {
+          ...modedRoot,
+          ...renderer !== void 0 ? { renderer } : {},
+          children: [{ name: "slide", props: {}, children: emitted }]
+        };
+      } else {
+        return;
+      }
+      const result = validatePresentation(
+        validationDocument2,
+        state.components,
+        { allowUnknownFields: validationOptions.allowUnknownFields }
+      );
+      if (!result.valid) {
+        throw new ComponentValidationError3(
+          result.errors.map((error) => ({
+            ...error,
+            message: `custom component '${componentLabel}' emitted invalid output \u2014 ${error.message}`
+          })),
+          emitted
         );
-        if (!result.valid) {
-          throw new ComponentValidationError3(result.errors, internalDocument);
+      }
+    };
+    const expanded = await expandPptxBlocksWithPlugins(
+      modedRoot,
+      resolvedTheme,
+      new Set(componentMap.keys()),
+      pluginRenderer(warnings, resolvedTheme, validateEmitted)
+    );
+    const processedDocument = expanded.document;
+    if (validationOptions.enabled !== false) {
+      const result = validatePresentation(
+        {
+          ...processedDocument,
+          ...renderer !== void 0 ? { renderer } : {}
+        },
+        [],
+        {
+          allowUnknownFields: validationOptions.allowUnknownFields
         }
-      } else if (!internalDocument || internalDocument.name !== "pptx") {
-        throw new Error("Top-level component must be a pptx component");
+      );
+      if (!result.valid) {
+        throw new ComponentValidationError3(
+          result.errors.map((error) => ({
+            ...error,
+            message: `expanded plugin output failed validation \u2014 ${error.message}`
+          })),
+          processedDocument
+        );
       }
-      const warnings = [];
-      const context = resolveThemeContext(internalDocument, {
+    }
+    return { context, expanded, warnings, renderer };
+  }
+  async function prepareQuality(document, options) {
+    const { context, expanded, warnings, renderer } = await expandPresentation(
+      document,
+      options
+    );
+    const prepared = preparePptxQualityDocument(
+      document,
+      {
+        context,
+        expanded,
         customThemes: state.customThemes,
         fonts: state.fonts,
-        warnings,
-        defaultThemeName: typeof state.theme === "string" ? state.theme : void 0,
-        resolveNamedTheme: (name, authored) => state.customThemes?.[name] ?? (authored && hasPptxTheme(name) ? getPptxTheme(name) : void 0) ?? (typeof state.theme === "object" && state.theme !== null ? state.theme : getPptxTheme(name))
-      });
-      const modedRoot = context.document;
-      const resolvedTheme = context.theme;
-      const validateEmitted = validationOptions.enabled === false ? void 0 : (emitted, componentLabel, parentName) => {
-        let validationDocument2;
-        if (parentName === "pptx") {
-          validationDocument2 = {
-            ...modedRoot,
-            ...renderer !== void 0 ? { renderer } : {},
-            children: emitted
-          };
-        } else if (parentName === "slide") {
-          validationDocument2 = {
-            ...modedRoot,
-            ...renderer !== void 0 ? { renderer } : {},
-            children: [{ name: "slide", props: {}, children: emitted }]
-          };
-        } else {
-          return;
-        }
-        const result = validatePresentation(
-          validationDocument2,
-          state.components,
-          { allowUnknownFields: validationOptions.allowUnknownFields }
+        services: state.services,
+        ...renderer !== void 0 && { renderer },
+        warnings
+      }
+    );
+    return { prepared, warnings };
+  }
+  async function generateFromPrepared(options) {
+    const { prepared } = options;
+    const { document: processedDocument, theme, processed } = prepared.model;
+    const warnings = [];
+    const renderer = options.renderer ?? state.renderer ?? prepared.renderer;
+    const hasHighcharts = containsHighcharts(processed);
+    const resolvedFonts = await resolveDocumentFonts(
+      processedDocument,
+      theme,
+      warnings,
+      state.fonts,
+      hasHighcharts
+    );
+    const chartFonts = hasHighcharts ? toChartFontFaces2(resolvedFonts) : [];
+    const buffer = await runWithBaseDir(
+      options.baseDir ?? state.baseDir,
+      () => renderProcessedViaIr(processed, warnings, {
+        renderer,
+        services: state.services,
+        deterministic: options.deterministic ?? state.packaging.deterministic,
+        generatedAt: options.generatedAt ?? state.packaging.generatedAt,
+        ...chartFonts.length > 0 ? { chartFonts } : {}
+      })
+    );
+    return { buffer, warnings };
+  }
+  async function generate(document, options) {
+    try {
+      if (options?.prepared)
+        return await generateFromPrepared(
+          options
         );
-        if (!result.valid) {
-          throw new ComponentValidationError3(
-            result.errors.map((error) => ({
-              ...error,
-              message: `custom component '${componentLabel}' emitted invalid output \u2014 ${error.message}`
-            })),
-            emitted
-          );
-        }
-      };
-      const expanded = await expandPptxBlocksWithPlugins(
-        modedRoot,
-        resolvedTheme,
-        new Set(componentMap.keys()),
-        pluginRenderer(warnings, resolvedTheme, validateEmitted)
-      );
+      const { context, expanded, warnings, renderer } = await expandPresentation(document, options);
+      const resolvedTheme = context.theme;
       const processedDocument = expanded.document;
-      if (validationOptions.enabled !== false) {
-        const result = validatePresentation(
-          {
-            ...processedDocument,
-            ...renderer !== void 0 ? { renderer } : {}
-          },
-          [],
-          {
-            allowUnknownFields: validationOptions.allowUnknownFields
-          }
-        );
-        if (!result.valid) {
-          throw new ComponentValidationError3(
-            result.errors.map((error) => ({
-              ...error,
-              message: `expanded plugin output failed validation \u2014 ${error.message}`
-            })),
-            processedDocument
-          );
-        }
-      }
       const processed = processPresentation(processedDocument, {
         theme: resolvedTheme,
         services: state.services,
@@ -9269,6 +9737,7 @@ function createBuilderImpl(state) {
     generate,
     generateBuffer: generate,
     generateFile,
+    prepareQuality,
     getComponentNames,
     validate,
     generateSchema,