@json-to-office/core-pptx 6.0.0 → 6.2.0

package/dist/index.js

@@ -1014,8 +1014,8 @@ async function repairSvgRasterFallbacks(zip, warnings) {
       const source = zip.file(item.svgPart);
       if (!source) throw new Error(`missing part ${item.svgPart}`);
       const svg = await source.async("string");
-      const probe2 = new Resvg(svg);
-      const fitTo = resolveFitTo(probe2.width / probe2.height, item.cx, item.cy);
+      const probe3 = new Resvg(svg);
+      const fitTo = resolveFitTo(probe3.width / probe3.height, item.cx, item.cy);
       const key = `${fitTo.mode}:${fitTo.value}
 ${svg}`;
       let png = rendered.get(key);
@@ -3937,12 +3937,11 @@ import {
   REMOTE_EXPORT_WARNING,
   chartFamilyResolver,
   chartPointsPerPixel,
-  chartRequestKey,
-  dedupeChartRequest,
-  limitChartRequest,
   postJsonToService,
+  recordChartCollected,
   recordChartRetry,
   resolveServiceUrl,
+  sendChartRequest,
   withChartFontFaceCss,
   withChartTypography
 } from "@json-to-office/shared";
@@ -4001,24 +4000,21 @@ async function expandList(components, path4, scope) {
 }
 async function expandOne(component, path4, scope) {
   const props = component.props;
-  const chart = await limitChartRequest(
-    exportServerUrl(props.serverUrl, scope.services?.serverUrl),
-    scope.services?.concurrency,
-    () => renderChart(
-      withChartFontFaces(
-        withThemeTypography(
-          withThemeColors(props, scope.theme, scope.warnings),
-          scope.theme,
-          scope.slideWidth,
-          scope.warnings
-        ),
+  recordChartCollected();
+  const chart = await renderChart(
+    withChartFontFaces(
+      withThemeTypography(
+        withThemeColors(props, scope.theme, scope.warnings),
         scope.theme,
-        scope.chartFonts
+        scope.slideWidth,
+        scope.warnings
       ),
-      scope.services,
-      scope.warnings,
-      scope.chartCache
-    )
+      scope.theme,
+      scope.chartFonts
+    ),
+    scope.services,
+    scope.warnings,
+    scope.chartCache
   );
   void path4;
   return {
@@ -4063,14 +4059,16 @@ async function renderChart(config, services, warnings, cache) {
     // for callers that omit it.
     ...config.resources ? { resources: config.resources } : {}
   };
-  return dedupeChartRequest(
+  return sendChartRequest({
     cache,
-    chartRequestKey(serverUrl, requestBody),
-    () => postChart(serverUrl, requestBody, config, services)
-  );
+    serverUrl,
+    concurrency: services?.concurrency,
+    requestBody,
+    send: () => postChart(serverUrl, requestBody, config, services)
+  });
 }
 async function postChart(serverUrl, requestBody, config, services) {
-  const response = await postJsonToService({
+  const base64Data = await postJsonToService({
     url: serverUrl,
     path: "/export",
     body: requestBody,
@@ -4082,10 +4080,11 @@ async function postChart(serverUrl, requestBody, config, services) {
     // The code lets a server route report a missing export server as a
     // dependency outage with this message, not as an internal error.
     onUnreachable: (url, cause) => `Highcharts Export Server is not running at ${url}. Start it with: npx highcharts-export-server --enableServer true
-Cause: ${cause}`
+Cause: ${cause}`,
+    decode: (response) => response.text()
   });
   return {
-    dataUri: `data:image/png;base64,${await response.text()}`,
+    dataUri: `data:image/png;base64,${base64Data}`,
     widthPx: config.options.chart?.width ?? DEFAULT_CHART_WIDTH_PX,
     heightPx: config.options.chart?.height ?? 720
   };
@@ -4332,7 +4331,12 @@ import {
   DEFAULT_PPTX_RENDERER_ID as DEFAULT_PPTX_RENDERER_ID2,
   SEMANTIC_COLOR_NAMES as SEMANTIC_COLOR_NAMES2
 } from "@json-to-office/shared-pptx";
-import { designColors as designColors2 } from "@json-to-office/shared";
+import {
+  designCanvas as designCanvas2,
+  designColors as designColors2,
+  typeScaleSizes
+} from "@json-to-office/shared";
+import probe2 from "probe-image-size";
 
 // src/core/generationContext.ts
 import { applyExportMode } from "@json-to-office/shared";
@@ -5971,6 +5975,30 @@ 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";
 }
+function bulletItems(props) {
+  const runs = Array.isArray(props.runs) ? props.runs : void 0;
+  const whole = props.bullet !== void 0 && props.bullet !== false;
+  if (runs) {
+    const bulleted = runs.map(asRecord).filter(
+      (run) => run !== void 0 && (whole || run.bullet !== void 0 && run.bullet !== false)
+    ).map((run) => typeof run.text === "string" ? run.text : "");
+    return bulleted.filter((item) => item.trim() !== "");
+  }
+  if (!whole || typeof props.text !== "string") return [];
+  return props.text.split("\n").filter((line) => line.trim() !== "");
+}
+function readablePptxRatio(props) {
+  const source = typeof props.base64 === "string" ? props.base64 : typeof props.path === "string" && props.path.startsWith("data:") ? props.path : void 0;
+  if (source === void 0) return void 0;
+  const comma = source.indexOf(",");
+  if (comma < 0) return void 0;
+  try {
+    const size = probe2.sync(Buffer.from(source.slice(comma + 1), "base64"));
+    return size && size.height > 0 ? size.width / size.height : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function themeContext(theme) {
   return {
     styles: theme.styles ?? {},
@@ -6310,7 +6338,7 @@ function authoredPropsAtPointer(root, pointer) {
   }
   return asRecord(asRecord(node)?.props);
 }
-function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slideHeightIn, ctx, theme, slideBackground, analyzedTextPaths, analyzedContentPaths, paletteTokens, authoredPropsAt, addFact) {
+function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slideHeightIn, ctx, theme, slideBackground, analyzedTextPaths, analyzedContentPaths, paletteTokens, authoredPropsAt, authoredPath, addFact) {
   const nodes = [];
   const surfaces = [];
   const boxes = [];
@@ -6470,17 +6498,61 @@ function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slid
       align: horizontalAlign(node.props, ctx),
       rotationDeg: asNumber(node.props.rotate) ?? 0,
       bold: typography.bold,
+      ...asNumber(node.props.fontSize) !== void 0 && {
+        sizePath: `${node.path}/props/fontSize`
+      },
+      generated: authoredPath(node.path) !== node.path,
       autoFit: node.props.h === void 0 && gridPos === void 0,
       ...colorHex !== void 0 && { colorHex },
       ...!backgroundUnknown && backgroundHexes.length > 0 && { backgroundHexes }
     });
   });
+  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({
     id: `pptx:slide:${renderedIndex}:${slidePath}`,
     kind: "pptx/slide",
     path: slidePath,
-    bodyWords
+    bodyWords,
+    contentBoxes: boxes.filter(
+      (box) => ["text", "shape", "table", "chart", "highcharts", "image"].includes(
+        box.componentName
+      ) && carriesContent(box) && !CHROME_STYLES.has(String(box.props.style ?? ""))
+    ).length
   });
+  for (const box of boxes) {
+    if (box.componentName === "image") {
+      const resolved = resolveBox(box.props, grid, slideWidthIn, slideHeightIn);
+      const alt = box.props.alt;
+      const natural = readablePptxRatio(box.props);
+      const authored = authoredPropsAt(box.path) ?? box.props;
+      const stretched = authored.w !== void 0 && authored.h !== void 0 && !["contain", "cover"].includes(
+        String(asRecord(authored.sizing)?.type ?? "")
+      );
+      addFact({
+        id: `pptx:image:${renderedIndex}:${box.path}`,
+        kind: "pptx/image",
+        path: box.path,
+        ...typeof alt === "string" && alt.trim() !== "" && { alt },
+        ...stretched && isCompleteBox(resolved) && resolved.heightPt > 0 && {
+          drawnRatio: resolved.widthPt / resolved.heightPt
+        },
+        ...natural !== void 0 && { naturalRatio: natural }
+      });
+    }
+    const bullets = bulletItems(box.props);
+    if (bullets.length > 1)
+      addFact({
+        id: `pptx:bullets:${renderedIndex}:${box.path}`,
+        kind: "pptx/bullets",
+        path: box.path,
+        slidePath,
+        items: bullets.length,
+        longestWords: Math.max(
+          ...bullets.map((item) => item.split(/\s+/).filter(Boolean).length)
+        )
+      });
+  }
 }
 function preparePptxQualityDocument(document, options = {}) {
   const facts = [];
@@ -6502,17 +6574,6 @@ function preparePptxQualityDocument(document, options = {}) {
     };
   };
   const props = asRecord(document.props) ?? {};
-  addFact({
-    id: "pptx:canvas",
-    kind: "pptx/canvas",
-    path: "/props",
-    ...asNumber(props.slideWidth) !== void 0 && {
-      widthIn: asNumber(props.slideWidth)
-    },
-    ...asNumber(props.slideHeight) !== void 0 && {
-      heightIn: asNumber(props.slideHeight)
-    }
-  });
   collectPlaceholders(document).forEach((occurrence, index) => {
     addFact({
       id: `pptx:placeholder:${index}:${occurrence.path}`,
@@ -6557,6 +6618,26 @@ function preparePptxQualityDocument(document, options = {}) {
     warnings
   });
   const ctx = themeContext(processed.theme);
+  const safeAreaIn = asNumber(
+    processed.theme.spacing?.canvas?.[designCanvas2("pptx", {
+      width: processed.slideWidth,
+      height: processed.slideHeight
+    })]?.safeAreaIn
+  );
+  addFact({
+    id: "pptx:canvas",
+    kind: "pptx/canvas",
+    path: "/props",
+    ...asNumber(props.slideWidth) !== void 0 && {
+      widthIn: asNumber(props.slideWidth)
+    },
+    ...asNumber(props.slideHeight) !== void 0 && {
+      heightIn: asNumber(props.slideHeight)
+    },
+    widthPt: processed.slideWidth * 72,
+    heightPt: processed.slideHeight * 72,
+    ...safeAreaIn !== void 0 && { safeAreaPt: safeAreaIn * 72 }
+  });
   const paletteHexes = {};
   const visualColors = designColors2(
     processed.theme.colors,
@@ -6577,12 +6658,31 @@ function preparePptxQualityDocument(document, options = {}) {
     if (hex)
       paletteHexes[SEMANTIC_COLOR_NAMES2.includes(token) ? token : hex] = hex;
   }
+  const roleSizesPt = {};
+  for (const [name, style] of Object.entries(processed.theme.styles ?? {})) {
+    const size = asNumber(style?.fontSize);
+    if (size !== void 0) roleSizesPt[name] = size;
+  }
+  const defaultFontSize = asNumber(processed.theme.defaults?.fontSize);
+  const scale = processed.theme.typography?.scale?.[designCanvas2("pptx", {
+    width: processed.slideWidth,
+    height: processed.slideHeight
+  })];
+  const typeScalePt = [
+    .../* @__PURE__ */ new Set([
+      ...Object.values(roleSizesPt),
+      ...defaultFontSize === void 0 ? [] : [defaultFontSize],
+      ...scale ? typeScaleSizes(scale) : []
+    ])
+  ].sort((a, b) => a - b);
   addFact({
     id: "pptx:theme",
     kind: "pptx/theme",
     path: "/props",
     themeName: processed.theme.name,
     paletteHexes,
+    typeScalePt,
+    roleSizesPt,
     fontFamilies: [
       ...new Set(
         [processed.theme.fonts?.heading, processed.theme.fonts?.body].filter(
@@ -6633,6 +6733,7 @@ function preparePptxQualityDocument(document, options = {}) {
       analyzedContentPaths,
       paletteTokens,
       authoredPropsAt,
+      authoredPath,
       addFact
     );
   });
@@ -6673,6 +6774,9 @@ function preparePptxQualityDocument(document, options = {}) {
       relatedPaths: [role.invocation],
       block: role.block,
       invocation: role.invocation,
+      // The invocation is a slide child, so its slide is the first two
+      // segments of its pointer — the one place that has to know that.
+      slidePath: role.invocation.split("/").slice(0, 3).join("/"),
       slot: role.slot,
       role: role.role,
       present,
@@ -7475,7 +7579,13 @@ import {
   nearestPaletteToken,
   offPaletteFinding,
   placeholderFinding,
+  DEFAULT_IMAGE_ASPECT_TOLERANCE,
+  imageAspectFinding,
+  driftingSizes,
+  offScaleFindings,
   QUALITY_CODES,
+  roleDriftFindings,
+  sizeCountFinding,
   QualityEngine,
   resolveRuleConfiguration,
   tableInfoDesignFindings
@@ -8255,6 +8365,383 @@ var pptxActionTitleRule = {
     }));
   }
 };
+var TITLE_DRIFT_TOLERANCE_PT = 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."
+};
+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
+  }));
+}
+var pptxTypeScaleRule = {
+  id: "pptx/type-scale",
+  description: "An authored size the theme never paints: not a style, not a type role, not a step of its scale. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.TYPE_OFF_SCALE,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => {
+    const theme = pptxThemeFact(facts);
+    if (!theme) return [];
+    const sizes = paintedSizes(facts);
+    return offScaleFindings(
+      sizes,
+      theme.typeScalePt,
+      theme.themeName,
+      PPTX_TYPE_VOCABULARY,
+      driftingSizes(sizes, theme.roleSizesPt)
+    );
+  }
+};
+var pptxSizeCountRule = {
+  id: "pptx/size-count",
+  description: "More distinct text sizes than maximumSizes allows, blocks 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
+  )
+};
+var pptxRoleDriftRule = {
+  id: "pptx/role-drift",
+  description: "One named style or type role painted at two sizes across the deck; the theme size is the fix. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.TYPE_ROLE_DRIFT,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => {
+    const theme = pptxThemeFact(facts);
+    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
+  );
+  const groups = /* @__PURE__ */ new Map();
+  const claimed = /* @__PURE__ */ new Set();
+  const push = (key, fact) => {
+    if (claimed.has(fact)) return;
+    claimed.add(fact);
+    groups.set(key, [...groups.get(key) ?? [], fact]);
+  };
+  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 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;
+    }
+  }
+  return best;
+}
+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.",
+  code: QUALITY_CODES.TITLE_DRIFT,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultEnabled: false,
+  defaultParameters: {
+    titleStyles: ["title"],
+    tolerancePt: TITLE_DRIFT_TOLERANCE_PT
+  },
+  evaluate: ({ facts, configuration }) => {
+    const styles = stringListParameter(configuration.parameters, "titleStyles");
+    const tolerance = numberParameter(
+      configuration.parameters,
+      "tolerancePt",
+      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
+        );
+        if (off.length === 0) continue;
+        const [first] = off;
+        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.",
+          context: {
+            kind,
+            axes: off.map((axis) => axis.key),
+            slide: fact.slidePath
+          },
+          evidence: {
+            actual: round(fact[first.prop]),
+            expected: round(first.value),
+            unit: "pt",
+            values: { axis: first.key, source: "profile" }
+          }
+        });
+      }
+    }
+    return findings;
+  }
+};
+var round = (value) => Math.round(value * 10) / 10;
+var pptxBulletRule = {
+  id: "pptx/bullet-density",
+  description: "More bullets in one box, or more words in one bullet, than the profile allows. Off at 0.",
+  code: QUALITY_CODES.BULLET_COUNT,
+  category: "information-design",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultParameters: { maximumBullets: 0, maximumWordsPerBullet: 0 },
+  evaluate: ({ facts, configuration }) => {
+    const maximumBullets = numberParameter(
+      configuration.parameters,
+      "maximumBullets",
+      0
+    );
+    const maximumWords = numberParameter(
+      configuration.parameters,
+      "maximumWordsPerBullet",
+      0
+    );
+    const worst = /* @__PURE__ */ new Map();
+    for (const fact of facts) {
+      if (fact.kind !== "pptx/bullets") continue;
+      const bullets = fact;
+      const held = worst.get(bullets.path);
+      worst.set(bullets.path, {
+        ...bullets,
+        items: Math.max(bullets.items, held?.items ?? 0),
+        longestWords: Math.max(bullets.longestWords, held?.longestWords ?? 0)
+      });
+    }
+    const findings = [];
+    for (const bullets of worst.values()) {
+      if (maximumBullets > 0 && bullets.items > maximumBullets)
+        findings.push({
+          path: bullets.path,
+          code: QUALITY_CODES.BULLET_COUNT,
+          message: `${bullets.items} bullets in one box; a slide carries at most ${maximumBullets}.`,
+          suggestion: "Keep the ones that carry the argument and move the rest to the notes, or split the slide.",
+          context: { items: bullets.items, maximum: maximumBullets },
+          evidence: {
+            actual: bullets.items,
+            expected: maximumBullets,
+            unit: "bullets",
+            values: { source: "profile" }
+          }
+        });
+      if (maximumWords > 0 && bullets.longestWords > maximumWords)
+        findings.push({
+          path: bullets.path,
+          code: QUALITY_CODES.BULLET_LENGTH,
+          message: `The longest bullet here runs to ${bullets.longestWords} words; a bullet states its point in at most ${maximumWords}.`,
+          suggestion: "Cut each bullet to a claim. What is left is the speaker\u2019s to say.",
+          context: { words: bullets.longestWords, maximum: maximumWords },
+          evidence: {
+            actual: bullets.longestWords,
+            expected: maximumWords,
+            unit: "words",
+            values: { source: "profile" }
+          }
+        });
+    }
+    return findings;
+  }
+};
+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.",
+  code: QUALITY_CODES.SAFE_AREA,
+  category: "composition",
+  defaultSeverity: "warning",
+  defaultCertainty: "measured",
+  formats: ["pptx"],
+  defaultEnabled: false,
+  defaultParameters: { tolerancePt: 2 },
+  evaluate: ({ facts, configuration }) => {
+    const tolerance = numberParameter(
+      configuration.parameters,
+      "tolerancePt",
+      2
+    );
+    const canvas = facts.find(
+      (fact) => fact.kind === "pptx/canvas"
+    );
+    const safe = canvas?.safeAreaPt;
+    if (canvas === void 0 || safe === void 0 || safe <= 0) return [];
+    const chromePaths = 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)
+    );
+    return facts.filter((fact) => fact.kind === "pptx/box").filter(
+      (fact) => !chromePaths.has(fact.path) && !styledChrome.has(fact.path)
+    ).flatMap((fact) => {
+      const right = fact.xPt + fact.widthPt;
+      const bottom = fact.yPt + fact.heightPt;
+      const spansWidth = fact.xPt <= tolerance && right >= canvas.widthPt - tolerance;
+      const spansHeight = fact.yPt <= tolerance && bottom >= canvas.heightPt - tolerance;
+      if (spansWidth || spansHeight) return [];
+      const breaches = [];
+      if (fact.xPt < safe - tolerance) breaches.push("left");
+      if (fact.yPt < safe - tolerance) breaches.push("top");
+      if (right > canvas.widthPt - safe + tolerance) breaches.push("right");
+      if (bottom > canvas.heightPt - safe + tolerance)
+        breaches.push("bottom");
+      if (breaches.length === 0) return [];
+      const worst = Math.max(
+        safe - fact.xPt,
+        safe - fact.yPt,
+        right - (canvas.widthPt - safe),
+        bottom - (canvas.heightPt - safe)
+      );
+      return [
+        {
+          path: fact.path,
+          message: `This ${fact.componentName} crosses the theme's ${Math.round(safe)}pt safe area at the ${breaches.join(" and ")}, by ${Math.round(worst * 10) / 10}pt.`,
+          suggestion: "Move it inside the margin, or make it a full bleed that runs edge to edge.",
+          context: { edges: breaches, safeAreaPt: safe },
+          evidence: {
+            actual: Math.round(worst * 10) / 10,
+            expected: 0,
+            unit: "pt",
+            values: { source: "theme" }
+          }
+        }
+      ];
+    });
+  }
+};
+var pptxSlideTitleRule = {
+  id: "pptx/slide-title",
+  description: "A content slide with no title: no actionTitle slot, no box in a title style. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.SLIDE_UNTITLED,
+  category: "hierarchy",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultEnabled: false,
+  defaultParameters: { titleStyles: ["title", "display", "heading1"] },
+  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))
+        titledSlides.add(fact.slidePath);
+    for (const fact of facts)
+      if (fact.kind === "pptx/chrome-slot" && fact.role === "actionTitle" && fact.present)
+        titledSlides.add(fact.slidePath);
+    return facts.filter(
+      (fact) => fact.kind === "pptx/slide" && fact.contentBoxes > 0 && !titledSlides.has(fact.path)
+    ).map((fact) => ({
+      path: fact.path,
+      message: "This slide carries content under no title, so nothing tells the reader what it is for.",
+      suggestion: "Lead the slide with a claim: an action title in a block, or a box in the theme\u2019s title style.",
+      context: { contentBoxes: fact.contentBoxes },
+      evidence: {
+        actual: 0,
+        expected: 1,
+        unit: "titles",
+        values: { source: "profile" }
+      }
+    }));
+  }
+};
+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.",
+  code: QUALITY_CODES.IMAGE_ASPECT,
+  category: "integrity",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultParameters: { tolerance: DEFAULT_IMAGE_ASPECT_TOLERANCE },
+  evaluate: ({ facts, configuration }) => {
+    const tolerance = numberParameter(
+      configuration.parameters,
+      "tolerance",
+      DEFAULT_IMAGE_ASPECT_TOLERANCE
+    );
+    return facts.filter(
+      (fact) => fact.kind === "pptx/image" && fact.drawnRatio !== void 0 && fact.naturalRatio !== void 0
+    ).flatMap((fact) => {
+      const finding = imageAspectFinding(
+        {
+          path: fact.path,
+          drawn: fact.drawnRatio,
+          natural: fact.naturalRatio
+        },
+        "slide",
+        tolerance
+      );
+      return finding ? [finding] : [];
+    });
+  }
+};
 var PPTX_QUALITY_RULES = {
   id: "pptx/default",
   rules: [
@@ -8272,7 +8759,15 @@ var PPTX_QUALITY_RULES = {
     pptxOffCanvasRule,
     pptxSlotBudgetRule,
     pptxRequiredChromeRule,
-    pptxActionTitleRule
+    pptxActionTitleRule,
+    pptxTypeScaleRule,
+    pptxSizeCountRule,
+    pptxRoleDriftRule,
+    pptxTitleDriftRule,
+    pptxBulletRule,
+    pptxSafeAreaRule,
+    pptxSlideTitleRule,
+    pptxImageAspectRule
   ]
 };
 var PPTX_QUALITY_PROFILES = {
@@ -8282,7 +8777,11 @@ var PPTX_QUALITY_PROFILES = {
     description: "Decision deck optimized for scan speed and projection.",
     rules: {
       "pptx/minimum-font-size": { parameters: { minimumFontPt: 14 } },
-      "pptx/slide-density": { parameters: { maximumBodyWords: 70 } }
+      "pptx/slide-density": { parameters: { maximumBodyWords: 70 } },
+      "pptx/bullet-density": {
+        parameters: { maximumBullets: 5, maximumWordsPerBullet: 12 }
+      },
+      "pptx/slide-title": { enabled: true }
     }
   },
   "technical-presentation": {
@@ -8293,13 +8792,25 @@ 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.",
+    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.",
     rules: {
       "pptx/required-chrome": {
         parameters: { required: ["takeaway", "source"] }
       },
       "pptx/action-title": { parameters: { maxLines: 2 } },
-      "pptx/slide-density": { parameters: { maximumBodyWords: 90 } }
+      "pptx/slide-density": { parameters: { maximumBodyWords: 90 } },
+      "pptx/type-scale": { enabled: true },
+      "pptx/size-count": { enabled: true, parameters: { maximumSizes: 8 } },
+      "pptx/role-drift": { enabled: true },
+      "pptx/title-drift": {
+        enabled: true,
+        parameters: { titleStyles: ["title", "display"] }
+      },
+      "pptx/bullet-density": {
+        parameters: { maximumBullets: 5, maximumWordsPerBullet: 12 }
+      },
+      "pptx/safe-area": { enabled: true },
+      "pptx/slide-title": { enabled: true }
     }
   }
 };