@json-to-office/core-pptx 1.4.0 → 1.7.0

package/dist/index.js

@@ -2235,99 +2235,6 @@ function applyFontWeight(params) {
   return { fontFace: synth.family, bold: synth.bold, italic: synth.italic };
 }
 
-// src/utils/componentDefaults.ts
-import { mergeWithDefaults } from "@json-to-office/shared";
-function getComponentDefaults(theme) {
-  return theme.componentDefaults || {};
-}
-function getTextDefaults(theme) {
-  return getComponentDefaults(theme).text || {};
-}
-function getImageDefaults(theme) {
-  return getComponentDefaults(theme).image || {};
-}
-function getShapeDefaults(theme) {
-  return getComponentDefaults(theme).shape || {};
-}
-function getTableDefaults(theme) {
-  return getComponentDefaults(theme).table || {};
-}
-function getHighchartsDefaults(theme) {
-  return getComponentDefaults(theme).highcharts || {};
-}
-function getChartDefaults(theme) {
-  return getComponentDefaults(theme).chart || {};
-}
-function getCustomComponentDefaults(theme, componentName) {
-  const defaults = getComponentDefaults(theme);
-  return defaults?.[componentName] || {};
-}
-function resolveTextProps(props, theme) {
-  return mergeWithDefaults(props, getTextDefaults(theme));
-}
-function resolveImageProps(props, theme) {
-  return mergeWithDefaults(props, getImageDefaults(theme));
-}
-function resolveShapeProps(props, theme) {
-  return mergeWithDefaults(props, getShapeDefaults(theme));
-}
-function resolveTableProps(props, theme) {
-  return mergeWithDefaults(props, getTableDefaults(theme));
-}
-function resolveHighchartsProps(props, theme) {
-  return mergeWithDefaults(props, getHighchartsDefaults(theme));
-}
-function resolveChartProps(props, theme) {
-  return mergeWithDefaults(props, getChartDefaults(theme));
-}
-function resolveCustomComponentProps(props, theme, componentName) {
-  const defaults = getCustomComponentDefaults(theme, componentName);
-  return mergeWithDefaults(props, defaults);
-}
-var TYPE_GETTERS = {
-  text: getTextDefaults,
-  image: getImageDefaults,
-  shape: getShapeDefaults,
-  table: getTableDefaults,
-  highcharts: getHighchartsDefaults,
-  chart: getChartDefaults
-};
-function getDefaultsForType(componentName, theme) {
-  const getter = TYPE_GETTERS[componentName];
-  return getter ? getter(theme) : getCustomComponentDefaults(theme, componentName);
-}
-
-// src/utils/resolveComponentTree.ts
-var RESOLVER_MAP = {
-  text: resolveTextProps,
-  image: resolveImageProps,
-  shape: resolveShapeProps,
-  table: resolveTableProps,
-  highcharts: resolveHighchartsProps,
-  chart: resolveChartProps
-};
-function resolveComponentDefaults(component, theme) {
-  const resolver = RESOLVER_MAP[component.name];
-  const resolvedProps = resolver ? resolver(component.props, theme) : resolveCustomComponentProps(
-    component.props,
-    theme,
-    component.name
-  );
-  return { ...component, props: resolvedProps };
-}
-function resolveComponentTree(components, theme) {
-  return components.map((component) => {
-    const resolved = resolveComponentDefaults(component, theme);
-    if (resolved.children && resolved.children.length > 0) {
-      return {
-        ...resolved,
-        children: resolveComponentTree(resolved.children, theme)
-      };
-    }
-    return resolved;
-  });
-}
-
 // src/utils/imageSource.ts
 import path from "path";
 var hasValue = (v) => typeof v === "string" && v.trim().length > 0;
@@ -2400,7 +2307,8 @@ var DEFAULT_GRID_CONFIG = {
 };
 function resolveMargin(margin) {
   if (margin == null) return DEFAULT_GRID_CONFIG.margin;
-  if (typeof margin === "number") return { top: margin, right: margin, bottom: margin, left: margin };
+  if (typeof margin === "number")
+    return { top: margin, right: margin, bottom: margin, left: margin };
   return margin;
 }
 function resolveGutter(gutter) {
@@ -2464,24 +2372,198 @@ function resolveGridPosition(gridPos, gridConfig, slideWidth, slideHeight, warni
 function resolveComponentGridPosition(component, gridConfig, slideWidth, slideHeight, warnings) {
   const gridPos = component.props.grid;
   if (!gridPos) return component;
-  const resolved = resolveGridPosition(gridPos, gridConfig, slideWidth, slideHeight, warnings);
+  const resolved = resolveGridPosition(
+    gridPos,
+    gridConfig,
+    slideWidth,
+    slideHeight,
+    warnings
+  );
   const { grid: _grid, ...restProps } = component.props;
   const newProps = { ...restProps };
   const hasPercentX = typeof newProps.x === "string" || typeof newProps.w === "string";
   const hasPercentY = typeof newProps.y === "string" || typeof newProps.h === "string";
   const toPercX = (v) => `${+(v / slideWidth * 100).toFixed(2)}%`;
   const toPercY = (v) => `${+(v / slideHeight * 100).toFixed(2)}%`;
-  if (newProps.x == null) newProps.x = hasPercentX ? toPercX(resolved.x) : resolved.x;
-  if (newProps.y == null) newProps.y = hasPercentY ? toPercY(resolved.y) : resolved.y;
-  if (newProps.w == null) newProps.w = hasPercentX ? toPercX(resolved.w) : resolved.w;
-  if (newProps.h == null) newProps.h = hasPercentY ? toPercY(resolved.h) : resolved.h;
+  if (newProps.x == null)
+    newProps.x = hasPercentX ? toPercX(resolved.x) : resolved.x;
+  if (newProps.y == null)
+    newProps.y = hasPercentY ? toPercY(resolved.y) : resolved.y;
+  if (newProps.w == null)
+    newProps.w = hasPercentX ? toPercX(resolved.w) : resolved.w;
+  if (newProps.h == null)
+    newProps.h = hasPercentY ? toPercY(resolved.h) : resolved.h;
   return { ...component, props: newProps };
 }
 
 // src/ir/compiler.ts
 init_warn();
+
+// src/core/placeholders.ts
 import { mergeWithDefaults as mergeWithDefaults2 } from "@json-to-office/shared";
 
+// src/utils/componentDefaults.ts
+import { mergeWithDefaults } from "@json-to-office/shared";
+function getComponentDefaults(theme) {
+  return theme.componentDefaults || {};
+}
+function getTextDefaults(theme) {
+  return getComponentDefaults(theme).text || {};
+}
+function getImageDefaults(theme) {
+  return getComponentDefaults(theme).image || {};
+}
+function getShapeDefaults(theme) {
+  return getComponentDefaults(theme).shape || {};
+}
+function getTableDefaults(theme) {
+  return getComponentDefaults(theme).table || {};
+}
+function getHighchartsDefaults(theme) {
+  return getComponentDefaults(theme).highcharts || {};
+}
+function getChartDefaults(theme) {
+  return getComponentDefaults(theme).chart || {};
+}
+function getCustomComponentDefaults(theme, componentName) {
+  const defaults = getComponentDefaults(theme);
+  return defaults?.[componentName] || {};
+}
+function resolveTextProps(props, theme) {
+  return mergeWithDefaults(props, getTextDefaults(theme));
+}
+function resolveImageProps(props, theme) {
+  return mergeWithDefaults(props, getImageDefaults(theme));
+}
+function resolveShapeProps(props, theme) {
+  return mergeWithDefaults(props, getShapeDefaults(theme));
+}
+function resolveTableProps(props, theme) {
+  return mergeWithDefaults(props, getTableDefaults(theme));
+}
+function resolveHighchartsProps(props, theme) {
+  return mergeWithDefaults(props, getHighchartsDefaults(theme));
+}
+function resolveChartProps(props, theme) {
+  return mergeWithDefaults(props, getChartDefaults(theme));
+}
+function resolveCustomComponentProps(props, theme, componentName) {
+  const defaults = getCustomComponentDefaults(theme, componentName);
+  return mergeWithDefaults(props, defaults);
+}
+var TYPE_GETTERS = {
+  text: getTextDefaults,
+  image: getImageDefaults,
+  shape: getShapeDefaults,
+  table: getTableDefaults,
+  highcharts: getHighchartsDefaults,
+  chart: getChartDefaults
+};
+function getDefaultsForType(componentName, theme) {
+  const getter = TYPE_GETTERS[componentName];
+  return getter ? getter(theme) : getCustomComponentDefaults(theme, componentName);
+}
+
+// src/utils/resolveComponentTree.ts
+var RESOLVER_MAP = {
+  text: resolveTextProps,
+  image: resolveImageProps,
+  shape: resolveShapeProps,
+  table: resolveTableProps,
+  highcharts: resolveHighchartsProps,
+  chart: resolveChartProps
+};
+function resolveComponentDefaults(component, theme) {
+  const resolver = RESOLVER_MAP[component.name];
+  const resolvedProps = resolver ? resolver(component.props, theme) : resolveCustomComponentProps(
+    component.props,
+    theme,
+    component.name
+  );
+  return { ...component, props: resolvedProps };
+}
+function resolveComponentTree(components, theme) {
+  return components.map((component) => {
+    const resolved = resolveComponentDefaults(component, theme);
+    if (resolved.children && resolved.children.length > 0) {
+      return {
+        ...resolved,
+        children: resolveComponentTree(resolved.children, theme)
+      };
+    }
+    return resolved;
+  });
+}
+
+// src/core/placeholders.ts
+init_warn();
+function resolvePlaceholderComponents(slide, template, effectiveGrid, options) {
+  if (!slide.placeholders) return [];
+  const out = [];
+  if (!template) {
+    for (const [name, component] of Object.entries(slide.placeholders)) {
+      const defaulted = resolveComponentDefaults(component, options.theme);
+      const positioned = defaulted.props.x != null || defaulted.props.y != null || defaulted.props.grid;
+      if (!positioned) {
+        warn(
+          options.warnings,
+          W.PLACEHOLDER_NO_POSITION,
+          `Placeholder "${name}" has no template and no explicit position \u2014 skipped`,
+          { slide: options.slideIndex }
+        );
+        continue;
+      }
+      out.push({
+        name,
+        component: resolveComponentGridPosition(
+          defaulted,
+          effectiveGrid,
+          options.slideWidth,
+          options.slideHeight,
+          options.warnings
+        )
+      });
+    }
+    return out;
+  }
+  const declared = new Map(
+    (template.placeholders ?? []).map((placeholder) => [
+      placeholder.name,
+      placeholder
+    ])
+  );
+  for (const [name, component] of Object.entries(slide.placeholders)) {
+    const definition = declared.get(name);
+    if (!definition) {
+      warn(
+        options.warnings,
+        W.UNKNOWN_PLACEHOLDER,
+        `Unknown placeholder "${name}" in template "${slide.template}". Available: ${[...declared.keys()].join(", ")}`,
+        { slide: options.slideIndex }
+      );
+      continue;
+    }
+    const gridResolved = resolveComponentGridPosition(
+      component,
+      effectiveGrid,
+      options.slideWidth,
+      options.slideHeight,
+      options.warnings
+    );
+    const typeDefaults = getDefaultsForType(component.name, options.theme);
+    const positionDefaults = {};
+    if (definition.x != null) positionDefaults.x = definition.x;
+    if (definition.y != null) positionDefaults.y = definition.y;
+    if (definition.w != null) positionDefaults.w = definition.w;
+    if (definition.h != null) positionDefaults.h = definition.h;
+    let props = mergeWithDefaults2(positionDefaults, typeDefaults);
+    props = mergeWithDefaults2(definition.defaults?.props ?? {}, props);
+    props = mergeWithDefaults2(gridResolved.props, props);
+    out.push({ name, component: { ...gridResolved, props } });
+  }
+  return out;
+}
+
 // src/ir/resources.ts
 init_units();
 var ResourceTable = class {
@@ -2759,12 +2841,17 @@ function compileSlide(slide, slideIndex, processed, ctx) {
       })
     );
   }
-  for (const component of compilePlaceholderComponents(
+  for (const { component } of resolvePlaceholderComponents(
     slide,
     template,
     effectiveGrid,
-    slideIndex,
-    ctx
+    {
+      theme: ctx.theme,
+      slideWidth: ctx.slideWidthInches,
+      slideHeight: ctx.slideHeightInches,
+      slideIndex,
+      warnings: ctx.warnings
+    }
   )) {
     push(
       compileComponent(component, {
@@ -2825,71 +2912,6 @@ function slideContextFor(slideIndex, processed) {
     language: processed.language
   };
 }
-function compilePlaceholderComponents(slide, template, effectiveGrid, slideIndex, ctx) {
-  if (!slide.placeholders) return [];
-  const out = [];
-  if (!template) {
-    for (const [name, component] of Object.entries(slide.placeholders)) {
-      const defaulted = resolveComponentDefaults(component, ctx.theme);
-      const positioned = defaulted.props.x != null || defaulted.props.y != null || defaulted.props.grid;
-      if (!positioned) {
-        warn(
-          ctx.warnings,
-          W.PLACEHOLDER_NO_POSITION,
-          `Placeholder "${name}" has no template and no explicit position \u2014 skipped`,
-          { slide: slideIndex }
-        );
-        continue;
-      }
-      out.push(
-        resolveComponentGridPosition(
-          defaulted,
-          effectiveGrid,
-          ctx.slideWidthInches,
-          ctx.slideHeightInches,
-          ctx.warnings
-        )
-      );
-    }
-    return out;
-  }
-  const declared = new Map(
-    (template.placeholders ?? []).map((placeholder) => [
-      placeholder.name,
-      placeholder
-    ])
-  );
-  for (const [name, component] of Object.entries(slide.placeholders)) {
-    const definition = declared.get(name);
-    if (!definition) {
-      warn(
-        ctx.warnings,
-        W.UNKNOWN_PLACEHOLDER,
-        `Unknown placeholder "${name}" in template "${slide.template}". Available: ${[...declared.keys()].join(", ")}`,
-        { slide: slideIndex }
-      );
-      continue;
-    }
-    const gridResolved = resolveComponentGridPosition(
-      component,
-      effectiveGrid,
-      ctx.slideWidthInches,
-      ctx.slideHeightInches,
-      ctx.warnings
-    );
-    const typeDefaults = getDefaultsForType(component.name, ctx.theme);
-    const positionDefaults = {};
-    if (definition.x != null) positionDefaults.x = definition.x;
-    if (definition.y != null) positionDefaults.y = definition.y;
-    if (definition.w != null) positionDefaults.w = definition.w;
-    if (definition.h != null) positionDefaults.h = definition.h;
-    let props = mergeWithDefaults2(positionDefaults, typeDefaults);
-    props = mergeWithDefaults2(definition.defaults?.props ?? {}, props);
-    props = mergeWithDefaults2(gridResolved.props, props);
-    out.push({ ...gridResolved, props });
-  }
-  return out;
-}
 function compileComponent(component, scope) {
   if (component.enabled === false) return void 0;
   switch (component.name) {
@@ -4124,141 +4146,6 @@ async function resolveDocumentFonts(document, theme, warnings, fonts) {
   return resolved;
 }
 
-// src/core/generationContext.ts
-import { applyExportMode } from "@json-to-office/shared";
-
-// src/themes/defaults.ts
-var DEFAULT_TABLE = {
-  border: { type: "solid", pt: 1, color: "background2" },
-  headerRow: true
-};
-var DEFAULT_STYLES = {
-  title: { fontSize: 36, bold: true, fontColor: "text", align: "center" },
-  subtitle: { fontSize: 20, italic: true, fontColor: "text2", align: "center" },
-  heading1: { fontSize: 28, bold: true, fontColor: "primary" },
-  heading2: { fontSize: 22, bold: true, fontColor: "primary" },
-  heading3: { fontSize: 18, bold: true, fontColor: "text" },
-  body: { fontSize: 14 },
-  caption: { fontSize: 10, italic: true, fontColor: "text2" }
-};
-var DEFAULT_PPTX_THEME = {
-  name: "default",
-  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 PPTX_THEMES = {
-  default: DEFAULT_PPTX_THEME,
-  dark: {
-    name: "dark",
-    colors: {
-      primary: "#5B9BD5",
-      secondary: "#FF6F61",
-      accent: "#6BCB77",
-      background: "#2D2D2D",
-      text: "#FFFFFF",
-      text2: "#CCCCCC",
-      background2: "#3D3D3D",
-      accent4: "#FFB347",
-      accent5: "#77DD77",
-      accent6: "#AEC6CF"
-    },
-    fonts: {
-      heading: "Arial",
-      body: "Arial"
-    },
-    defaults: {
-      fontSize: 18,
-      fontColor: "#FFFFFF"
-    },
-    styles: DEFAULT_STYLES,
-    componentDefaults: { table: DEFAULT_TABLE }
-  },
-  minimal: {
-    name: "minimal",
-    colors: {
-      primary: "#000000",
-      secondary: "#666666",
-      accent: "#999999",
-      background: "#FFFFFF",
-      text: "#000000",
-      text2: "#444444",
-      background2: "#F5F5F5",
-      accent4: "#BBBBBB",
-      accent5: "#DDDDDD",
-      accent6: "#888888"
-    },
-    fonts: {
-      heading: "Helvetica",
-      body: "Helvetica"
-    },
-    defaults: {
-      fontSize: 18,
-      fontColor: "#000000"
-    },
-    styles: DEFAULT_STYLES,
-    componentDefaults: { table: DEFAULT_TABLE }
-  }
-};
-function getPptxTheme(name) {
-  return PPTX_THEMES[name] || DEFAULT_PPTX_THEME;
-}
-function hasPptxTheme(name) {
-  return Object.prototype.hasOwnProperty.call(PPTX_THEMES, name);
-}
-var pptxThemes = PPTX_THEMES;
-
-// src/core/generationContext.ts
-function resolveThemeContext(documentIn, options = {}) {
-  const { customThemes, fonts, warnings, defaultThemeName, resolveNamedTheme } = options;
-  if (documentIn.props === null) {
-    throw new Error(
-      "Document `props` is null. Omit it, or provide an object \u2014 a null props cannot carry a theme."
-    );
-  }
-  let document = documentIn.props === void 0 ? { ...documentIn, props: {} } : documentIn;
-  let inlineTheme;
-  if (typeof document.props.theme === "object" && document.props.theme !== null) {
-    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";
-  let theme = inlineTheme ?? (resolveNamedTheme ? resolveNamedTheme(baseThemeName, authoredThemeName !== void 0) : customThemes?.[baseThemeName] ?? getPptxTheme(baseThemeName));
-  const mode = applyExportMode({ doc: document, theme, fonts });
-  document = mode.doc;
-  theme = mode.theme;
-  for (const w of mode.warnings) {
-    warnings?.push({
-      code: w.code,
-      message: w.message,
-      component: "fontRegistry"
-    });
-  }
-  return {
-    document,
-    theme
-  };
-}
-
 // src/core/generationOptions.ts
 import {
   collectImageSourceConflicts,
@@ -4618,6 +4505,144 @@ async function probeIntrinsicSize(source, warnings) {
   }
 }
 
+// src/quality/facts.ts
+import { DEFAULT_PPTX_RENDERER_ID as DEFAULT_PPTX_RENDERER_ID2 } from "@json-to-office/shared-pptx";
+
+// src/core/generationContext.ts
+import { applyExportMode } from "@json-to-office/shared";
+
+// src/themes/defaults.ts
+var DEFAULT_TABLE = {
+  border: { type: "solid", pt: 1, color: "background2" },
+  headerRow: true
+};
+var DEFAULT_STYLES = {
+  title: { fontSize: 36, bold: true, fontColor: "text", align: "center" },
+  subtitle: { fontSize: 20, italic: true, fontColor: "text2", align: "center" },
+  heading1: { fontSize: 28, bold: true, fontColor: "primary" },
+  heading2: { fontSize: 22, bold: true, fontColor: "primary" },
+  heading3: { fontSize: 18, bold: true, fontColor: "text" },
+  body: { fontSize: 14 },
+  caption: { fontSize: 10, italic: true, fontColor: "text2" }
+};
+var DEFAULT_PPTX_THEME = {
+  name: "default",
+  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 PPTX_THEMES = {
+  default: DEFAULT_PPTX_THEME,
+  dark: {
+    name: "dark",
+    colors: {
+      primary: "#5B9BD5",
+      secondary: "#FF6F61",
+      accent: "#6BCB77",
+      background: "#2D2D2D",
+      text: "#FFFFFF",
+      text2: "#CCCCCC",
+      background2: "#3D3D3D",
+      accent4: "#FFB347",
+      accent5: "#77DD77",
+      accent6: "#AEC6CF"
+    },
+    fonts: {
+      heading: "Arial",
+      body: "Arial"
+    },
+    defaults: {
+      fontSize: 18,
+      fontColor: "#FFFFFF"
+    },
+    styles: DEFAULT_STYLES,
+    componentDefaults: { table: DEFAULT_TABLE }
+  },
+  minimal: {
+    name: "minimal",
+    colors: {
+      primary: "#000000",
+      secondary: "#666666",
+      accent: "#999999",
+      background: "#FFFFFF",
+      text: "#000000",
+      text2: "#444444",
+      background2: "#F5F5F5",
+      accent4: "#BBBBBB",
+      accent5: "#DDDDDD",
+      accent6: "#888888"
+    },
+    fonts: {
+      heading: "Helvetica",
+      body: "Helvetica"
+    },
+    defaults: {
+      fontSize: 18,
+      fontColor: "#000000"
+    },
+    styles: DEFAULT_STYLES,
+    componentDefaults: { table: DEFAULT_TABLE }
+  }
+};
+function getPptxTheme(name) {
+  return PPTX_THEMES[name] || DEFAULT_PPTX_THEME;
+}
+function hasPptxTheme(name) {
+  return Object.prototype.hasOwnProperty.call(PPTX_THEMES, name);
+}
+var pptxThemes = PPTX_THEMES;
+
+// src/core/generationContext.ts
+function resolveThemeContext(documentIn, options = {}) {
+  const { customThemes, fonts, warnings, defaultThemeName, resolveNamedTheme } = options;
+  if (documentIn.props === null) {
+    throw new Error(
+      "Document `props` is null. Omit it, or provide an object \u2014 a null props cannot carry a theme."
+    );
+  }
+  let document = documentIn.props === void 0 ? { ...documentIn, props: {} } : documentIn;
+  let inlineTheme;
+  if (typeof document.props.theme === "object" && document.props.theme !== null) {
+    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";
+  let theme = inlineTheme ?? (resolveNamedTheme ? resolveNamedTheme(baseThemeName, authoredThemeName !== void 0) : customThemes?.[baseThemeName] ?? getPptxTheme(baseThemeName));
+  const mode = applyExportMode({ doc: document, theme, fonts });
+  document = mode.doc;
+  theme = mode.theme;
+  for (const w of mode.warnings) {
+    warnings?.push({
+      code: w.code,
+      message: w.message,
+      component: "fontRegistry"
+    });
+  }
+  return {
+    document,
+    theme
+  };
+}
+
 // src/core/structure.ts
 import { mergeWithDefaults as mergeWithDefaults3 } from "@json-to-office/shared";
 function isSlideEnabled(child) {
@@ -4740,6 +4765,458 @@ function processPresentation(document, options) {
   };
 }
 
+// src/quality/facts.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function dimToPt(value, axisIn) {
+  if (typeof value === "number" && Number.isFinite(value)) return value * 72;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.endsWith("%")) {
+      const pct = Number(trimmed.slice(0, -1));
+      return Number.isFinite(pct) ? pct / 100 * axisIn * 72 : void 0;
+    }
+    const inches = Number(trimmed);
+    return Number.isFinite(inches) ? inches * 72 : void 0;
+  }
+  return void 0;
+}
+function resolveBox(props, grid, slideWidthIn, slideHeightIn) {
+  let xPt = dimToPt(props.x, slideWidthIn);
+  let yPt = dimToPt(props.y, slideHeightIn);
+  let widthPt = dimToPt(props.w, slideWidthIn);
+  let heightPt = dimToPt(props.h, slideHeightIn);
+  const gridPos = asRecord(props.grid);
+  if (gridPos !== void 0 && asNumber(gridPos.column) !== void 0 && asNumber(gridPos.row) !== void 0 && (xPt === void 0 || yPt === void 0 || widthPt === void 0 || heightPt === void 0)) {
+    const resolved = resolveGridPosition(
+      gridPos,
+      grid,
+      slideWidthIn,
+      slideHeightIn
+    );
+    xPt ??= resolved.x * 72;
+    yPt ??= resolved.y * 72;
+    widthPt ??= resolved.w * 72;
+    heightPt ??= resolved.h * 72;
+  }
+  return { xPt, yPt, widthPt, heightPt };
+}
+function isCompleteBox(box) {
+  return box.xPt !== void 0 && box.yPt !== void 0 && box.widthPt !== void 0 && box.heightPt !== void 0 && box.widthPt > 0 && box.heightPt > 0;
+}
+function containsCentre(surface, text) {
+  const cx = text.xPt + text.widthPt / 2;
+  const cy = text.yPt + text.heightPt / 2;
+  return cx >= surface.xPt && cx <= surface.xPt + surface.widthPt && cy >= surface.yPt && cy <= surface.yPt + surface.heightPt;
+}
+function themeContext(theme) {
+  return {
+    styles: theme.styles ?? {},
+    defaultFontSize: asNumber(theme.defaults?.fontSize) ?? 18
+  };
+}
+function fillColorHexes(fill2, theme) {
+  const found = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    const rec = asRecord(node);
+    if (!rec) return;
+    if (typeof rec.color === "string") {
+      const hex = resolveColor(rec.color, theme);
+      if (hex) found.push(hex.toUpperCase());
+    }
+    for (const value of Object.values(rec)) {
+      if (typeof value === "object" && value !== null) visit(value);
+    }
+  };
+  visit(fill2);
+  return [...new Set(found)];
+}
+var FOCUS_CORNERS = {
+  topLeft: [0, 0],
+  topRight: [1, 0],
+  bottomLeft: [0, 1],
+  bottomRight: [1, 1]
+};
+function lerpHex(a, b, t) {
+  const pa = parseInt(a, 16);
+  const pb = parseInt(b, 16);
+  const mix = (shift) => Math.round(
+    (pa >> shift & 255) + ((pb >> shift & 255) - (pa >> shift & 255)) * t
+  );
+  return [mix(16), mix(8), mix(0)].map((c) => c.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function gradientPosition(gradient, fx, fy, widthUnits, heightUnits) {
+  if (gradient.type === "radial") {
+    const focus = FOCUS_CORNERS[typeof gradient.focus === "string" ? gradient.focus : "topLeft"] ?? FOCUS_CORNERS.topLeft;
+    const radius = Math.hypot(widthUnits, heightUnits) / 2;
+    if (radius === 0) return 0;
+    const distance = Math.hypot(
+      (fx - focus[0]) * widthUnits,
+      (fy - focus[1]) * heightUnits
+    );
+    return Math.min(1, distance / radius);
+  }
+  const angle = (asNumber(gradient.angle) ?? 0) * Math.PI / 180;
+  const dx = Math.cos(angle);
+  const dy = Math.sin(angle);
+  const min = Math.min(0, dx) + Math.min(0, dy);
+  const max = Math.max(0, dx) + Math.max(0, dy);
+  if (max === min) return 0;
+  return Math.min(1, Math.max(0, (fx * dx + fy * dy - min) / (max - min)));
+}
+function paintedColorHexes(fill2, theme, fx, fy, widthUnits, heightUnits) {
+  const rec = asRecord(fill2);
+  const gradient = asRecord(rec?.gradient);
+  const stops = Array.isArray(gradient?.stops) ? gradient.stops : void 0;
+  if (gradient && stops && stops.length > 0) {
+    const parsed = stops.flatMap((stop) => {
+      const entry = asRecord(stop);
+      const color2 = typeof entry?.color === "string" ? entry.color : void 0;
+      if (!color2) return [];
+      const hex = resolveColor(color2, theme);
+      if (!hex) return [];
+      return [{ pos: asNumber(entry?.pos) ?? 0, hex: hex.toUpperCase() }];
+    }).sort((a, b) => a.pos - b.pos);
+    if (parsed.length === 0) return [];
+    const target = gradientPosition(gradient, fx, fy, widthUnits, heightUnits) * 100;
+    if (target <= parsed[0].pos) return [parsed[0].hex];
+    const last = parsed[parsed.length - 1];
+    if (target >= last.pos) return [last.hex];
+    for (let i = 1; i < parsed.length; i += 1) {
+      const previous = parsed[i - 1];
+      const next = parsed[i];
+      if (target <= next.pos) {
+        const span = next.pos - previous.pos;
+        const t = span === 0 ? 0 : (target - previous.pos) / span;
+        return [lerpHex(previous.hex, next.hex, t)];
+      }
+    }
+    return [last.hex];
+  }
+  return fillColorHexes(fill2, theme);
+}
+function defaultLineHeightPt(fontSize) {
+  if (fontSize >= 60) return fontSize * 1.05;
+  if (fontSize >= 28) return fontSize * 1.15;
+  return fontSize * 1.25;
+}
+function resolveTypography(props, ctx) {
+  const styleName = typeof props.style === "string" ? props.style : void 0;
+  const style = styleName !== void 0 ? ctx.styles[styleName] : void 0;
+  const fontSize = asNumber(props.fontSize) ?? style?.fontSize ?? ctx.defaultFontSize;
+  const multiple = asNumber(props.lineSpacingMultiple);
+  const lineSpacing = multiple !== void 0 ? fontSize * multiple : asNumber(props.lineSpacing) ?? style?.lineSpacing ?? defaultLineHeightPt(fontSize);
+  const weight = asNumber(props.fontWeight) ?? style?.fontWeight;
+  const bold = weight !== void 0 ? weight >= 600 : typeof props.bold === "boolean" ? props.bold : style?.bold ?? false;
+  return {
+    fontSize,
+    lineSpacing,
+    paraSpaceBefore: asNumber(props.paraSpaceBefore) ?? 0,
+    paraSpaceAfter: asNumber(props.paraSpaceAfter) ?? style?.paraSpaceAfter ?? 0,
+    bold,
+    ...styleName && { styleName }
+  };
+}
+function collectSlideNodes(component, path4, text, surfaces, counter) {
+  const rec = asRecord(component);
+  if (!rec || rec.enabled === false) return;
+  const props = asRecord(rec.props) ?? {};
+  const order = counter.next++;
+  if (rec.name === "image" || rec.name === "visual" || rec.name === "chart") {
+    surfaces.push({ order, props, isImage: true });
+  } else if (rec.name === "shape" && props.fill !== void 0) {
+    surfaces.push({ order, props, isImage: false });
+  }
+  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 });
+    }
+  }
+  const children = Array.isArray(rec.children) ? rec.children : [];
+  children.forEach(
+    (child, index) => collectSlideNodes(
+      child,
+      `${path4}/children/${index}`,
+      text,
+      surfaces,
+      counter
+    )
+  );
+}
+function pointerSegment(value) {
+  return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function addSlideFacts(roots, slidePath, renderedIndex, grid, slideWidthIn, slideHeightIn, ctx, theme, slideBackground, analyzedTextPaths, addFact) {
+  const nodes = [];
+  const surfaces = [];
+  const counter = { next: 0 };
+  for (const root of roots) {
+    collectSlideNodes(root.component, root.path, nodes, surfaces, counter);
+  }
+  const surfaceBoxes = surfaces.flatMap((surface) => {
+    const box = resolveBox(surface.props, grid, slideWidthIn, slideHeightIn);
+    return isCompleteBox(box) ? [{ ...surface, box }] : [];
+  });
+  let bodyWords = 0;
+  nodes.forEach((node, nodeIndex) => {
+    const typography = resolveTypography(node.props, ctx);
+    if (typography.styleName !== "title" && typography.styleName !== "subtitle") {
+      bodyWords += node.text.split(/\s+/).filter(Boolean).length;
+    }
+    if (analyzedTextPaths.has(node.path)) return;
+    analyzedTextPaths.add(node.path);
+    const gridPos = asRecord(node.props.grid);
+    const nodeBox = resolveBox(node.props, grid, slideWidthIn, slideHeightIn);
+    const {
+      xPt: boxXPt,
+      yPt: boxYPt,
+      widthPt: boxWidthPt,
+      heightPt: boxHeightPt
+    } = nodeBox;
+    const sampleFractions = (box, originX, originY, widthPt, heightPt) => {
+      if (!isCompleteBox(box) || widthPt <= 0 || heightPt <= 0) {
+        return [[0.5, 0.5]];
+      }
+      const x0 = (box.xPt - originX) / widthPt;
+      const x1 = (box.xPt + box.widthPt - originX) / widthPt;
+      const y0 = (box.yPt - originY) / heightPt;
+      const y1 = (box.yPt + box.heightPt - originY) / heightPt;
+      return [
+        [(x0 + x1) / 2, (y0 + y1) / 2],
+        [x0, y0],
+        [x1, y0],
+        [x0, y1],
+        [x1, y1]
+      ];
+    };
+    const slideSamples = sampleFractions(
+      nodeBox,
+      0,
+      0,
+      slideWidthIn * 72,
+      slideHeightIn * 72
+    );
+    const ownFill = [
+      ...new Set(
+        sampleFractions(
+          nodeBox,
+          boxXPt ?? 0,
+          boxYPt ?? 0,
+          boxWidthPt ?? 0,
+          boxHeightPt ?? 0
+        ).flatMap(
+          ([fx, fy]) => paintedColorHexes(
+            node.props.fill,
+            theme,
+            fx,
+            fy,
+            (boxWidthPt ?? 0) / 72,
+            (boxHeightPt ?? 0) / 72
+          )
+        )
+      )
+    ];
+    let backgroundHexes = [
+      ...new Set(slideSamples.flatMap(([fx, fy]) => slideBackground(fx, fy)))
+    ];
+    let backgroundUnknown = false;
+    if (ownFill.length > 0) {
+      backgroundHexes = ownFill;
+    } else if (isCompleteBox(nodeBox)) {
+      const covering = surfaceBoxes.filter(
+        (surface) => surface.order < node.order && containsCentre(surface.box, nodeBox)
+      ).pop();
+      if (covering?.isImage) {
+        backgroundUnknown = true;
+      } else if (covering) {
+        const fill2 = [
+          ...new Set(
+            sampleFractions(
+              nodeBox,
+              covering.box.xPt,
+              covering.box.yPt,
+              covering.box.widthPt,
+              covering.box.heightPt
+            ).flatMap(
+              ([fx, fy]) => paintedColorHexes(
+                covering.props.fill,
+                theme,
+                fx,
+                fy,
+                covering.box.widthPt / 72,
+                covering.box.heightPt / 72
+              )
+            )
+          )
+        ];
+        if (fill2.length > 0) backgroundHexes = fill2;
+        else backgroundUnknown = true;
+      }
+    }
+    const colorHex = typeof node.props.color === "string" ? resolveColor(node.props.color, theme)?.toUpperCase() : void 0;
+    addFact({
+      id: `pptx:text:${renderedIndex}:${nodeIndex}:${node.path}`,
+      kind: "pptx/text",
+      path: node.path,
+      slidePath,
+      text: node.text,
+      fontSizePt: typography.fontSize,
+      lineSpacingPt: typography.lineSpacing,
+      paraSpaceBeforePt: typography.paraSpaceBefore,
+      paraSpaceAfterPt: typography.paraSpaceAfter,
+      ...typography.styleName && { styleName: typography.styleName },
+      ...boxXPt !== void 0 && { boxXPt },
+      ...boxYPt !== void 0 && { boxYPt },
+      ...boxWidthPt !== void 0 && boxWidthPt > 0 && { boxWidthPt },
+      ...boxHeightPt !== void 0 && boxHeightPt > 0 && { boxHeightPt },
+      verticalAlign: node.props.valign === "middle" || node.props.valign === "bottom" ? node.props.valign : "top",
+      rotationDeg: asNumber(node.props.rotate) ?? 0,
+      bold: typography.bold,
+      autoFit: node.props.h === void 0 && gridPos === void 0,
+      ...colorHex !== void 0 && { colorHex },
+      ...!backgroundUnknown && backgroundHexes.length > 0 && { backgroundHexes }
+    });
+  });
+  addFact({
+    id: `pptx:slide:${renderedIndex}:${slidePath}`,
+    kind: "pptx/slide",
+    path: slidePath,
+    bodyWords
+  });
+}
+function preparePptxQualityDocument(document, options = {}) {
+  const facts = [];
+  const provenance = {};
+  const addFact = (fact) => {
+    facts.push(fact);
+    provenance[fact.id] = {
+      path: fact.path,
+      ...fact.relatedPaths && { relatedPaths: fact.relatedPaths }
+    };
+  };
+  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)
+    }
+  });
+  const warnings = options.warnings ?? [];
+  const context = resolveThemeContext(document, {
+    customThemes: options.customThemes,
+    fonts: options.fonts,
+    warnings
+  });
+  const processed = processPresentation(context.document, {
+    theme: context.theme,
+    customThemes: options.customThemes,
+    services: options.services
+  });
+  const ctx = themeContext(processed.theme);
+  const authoredChildren = Array.isArray(document.children) ? document.children : [];
+  const slideIndexes = authoredChildren.flatMap((child, index) => {
+    const slide = asRecord(child);
+    return slide?.name === "slide" && slide.enabled !== false ? [index] : [];
+  });
+  const templateIndexes = /* @__PURE__ */ new Map();
+  const templates = new Map(
+    (processed.templates ?? []).map((template, index) => {
+      templateIndexes.set(template.name, index);
+      return [template.name, template];
+    })
+  );
+  const analyzedTextPaths = /* @__PURE__ */ new Set();
+  processed.slides.forEach((slide, renderedIndex) => {
+    const authoredIndex = slideIndexes[renderedIndex];
+    if (authoredIndex === void 0) return;
+    const slidePath = `/children/${authoredIndex}`;
+    const authoredSlide = asRecord(authoredChildren[authoredIndex]);
+    const authoredComponents = Array.isArray(authoredSlide?.children) ? authoredSlide.children : [];
+    const template = slide.template ? templates.get(slide.template) : void 0;
+    const effectiveGrid = mergeGridConfigs(processed.grid, template?.grid);
+    const roots = [];
+    const templateIndex = template ? templateIndexes.get(template.name) : void 0;
+    if (template && templateIndex !== void 0) {
+      template.objects?.forEach((component, index) => {
+        roots.push({
+          component,
+          path: `/props/templates/${templateIndex}/objects/${index}`
+        });
+      });
+    }
+    slide.components.forEach((component, index) => {
+      if (authoredComponents[index] === void 0) return;
+      roots.push({
+        component,
+        path: `${slidePath}/children/${index}`
+      });
+    });
+    for (const resolved of resolvePlaceholderComponents(
+      slide,
+      template,
+      effectiveGrid,
+      {
+        theme: processed.theme,
+        slideWidth: processed.slideWidth,
+        slideHeight: processed.slideHeight,
+        slideIndex: renderedIndex,
+        warnings
+      }
+    )) {
+      roots.push({
+        component: resolved.component,
+        path: `${slidePath}/props/placeholders/${pointerSegment(resolved.name)}`
+      });
+    }
+    addSlideFacts(
+      roots,
+      slidePath,
+      renderedIndex,
+      effectiveGrid,
+      processed.slideWidth,
+      processed.slideHeight,
+      ctx,
+      processed.theme,
+      (fx, fy) => paintedColorHexes(
+        slide.background ?? template?.background ?? props.background,
+        processed.theme,
+        fx,
+        fy,
+        processed.slideWidth,
+        processed.slideHeight
+      ),
+      analyzedTextPaths,
+      addFact
+    );
+  });
+  return {
+    format: "pptx",
+    model: {
+      authored: document,
+      document: context.document,
+      theme: context.theme,
+      processed
+    },
+    facts,
+    provenance,
+    renderer: options.renderer ?? DEFAULT_PPTX_RENDERER_ID2
+  };
+}
+
 // src/core/generateFromIr.ts
 var UncompiledComponentError = class extends Error {
   code = "UNCOMPILED_COMPONENT";
@@ -4762,29 +5239,24 @@ async function generateBufferViaIr(jsonConfig, options) {
     selectedRenderer && PPTX_RENDERER_IDS.includes(selectedRenderer) ? { ...component, renderer: selectedRenderer } : component,
     options?.validation
   );
+  assertNoContentConflicts(component);
   const warnings = [];
-  const context = resolveThemeContext(component, {
+  const prepared = options?.prepared ?? preparePptxQualityDocument(component, {
     customThemes: options?.customThemes,
     fonts: options?.fonts,
-    warnings
+    warnings,
+    services: options?.services,
+    renderer: selectedRenderer
   });
-  assertNoContentConflicts(context.document);
   await resolveDocumentFonts(
-    context.document,
-    context.theme,
+    prepared.model.document,
+    prepared.model.theme,
     warnings,
     options?.fonts
   );
   const buffer = await runWithBaseDir(
     options?.baseDir,
-    () => renderProcessedViaIr(
-      processPresentation(context.document, {
-        ...effectiveOptions,
-        theme: context.theme
-      }),
-      warnings,
-      effectiveOptions
-    )
+    () => renderProcessedViaIr(prepared.model.processed, warnings, effectiveOptions)
   );
   return { buffer, warnings };
 }
@@ -4853,6 +5325,465 @@ var PresentationGenerator = {
 init_finalizePackage();
 init_warn();
 
+// src/quality/preflight.ts
+import {
+  assertValidQualityPolicy,
+  assertValidQualityProfile
+} from "@json-to-office/quality";
+
+// src/quality/rules.ts
+import {
+  mergeQualityProfiles,
+  QUALITY_CODES,
+  QualityEngine,
+  resolveRuleConfiguration
+} from "@json-to-office/quality";
+var RENDERER_DEFAULT_WIDTH_IN = 10;
+var RENDERER_DEFAULT_HEIGHT_IN = 7.5;
+var DEFAULT_CHAR_WIDTH_FACTOR = 0.46;
+var DEFAULT_SAFETY_BUFFER_PT = 8;
+var DEFAULT_MIN_READABLE_FONT_PT = 7;
+var DEFAULT_MAX_BODY_WORDS_PER_SLIDE = 130;
+var KNOWN_CANVASES = [
+  { w: 13.333, h: 7.5, label: "16:9 standard" },
+  { w: 10, h: 5.625, label: "16:9 small" },
+  { w: 7.5, h: 7.5, label: "1:1 carousel" },
+  { w: 7.5, h: 9.375, label: "4:5 vertical" },
+  { w: 4.5, h: 8, label: "9:16 story" },
+  { w: 10, h: 7.5, label: "4:3 legacy", legacy: true }
+];
+function numberParameter(parameters, name, fallback) {
+  const value = parameters[name];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function textFacts(facts) {
+  return facts.filter(
+    (fact) => fact.kind === "pptx/text"
+  );
+}
+function estimateTextHeightPt(fact, charWidthFactor) {
+  if (fact.boxWidthPt === void 0 || fact.boxHeightPt === void 0) {
+    return void 0;
+  }
+  const paragraphs = fact.text.split("\n");
+  const charsPerLine = Math.max(
+    1,
+    Math.floor(fact.boxWidthPt / (fact.fontSizePt * charWidthFactor))
+  );
+  let lines = 0;
+  for (const paragraph of paragraphs) {
+    const measured = paragraph.trimEnd();
+    lines += measured === "" ? 1 : Math.max(1, Math.ceil(measured.length / charsPerLine));
+  }
+  let heightPt = fact.fontSizePt + Math.max(0, lines - 1) * fact.lineSpacingPt;
+  if (paragraphs.length > 1) {
+    heightPt += (paragraphs.length - 1) * (fact.paraSpaceBeforePt + fact.paraSpaceAfterPt);
+  }
+  return { heightPt, lines };
+}
+var pptxCanvasRule = {
+  id: "pptx/canvas",
+  code: QUALITY_CODES.CANVAS_UNSPECIFIED,
+  category: "composition",
+  defaultSeverity: "info",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  evaluate: ({ facts }) => {
+    const canvas = facts.find(
+      (fact) => fact.kind === "pptx/canvas"
+    );
+    if (!canvas) return [];
+    const { widthIn: width, heightIn: height } = canvas;
+    if (width === void 0 || height === void 0) {
+      const missing = [
+        width === void 0 ? "props.slideWidth" : void 0,
+        height === void 0 ? "props.slideHeight" : void 0
+      ].filter((entry) => entry !== void 0);
+      const state = missing.length === 2 ? "No slide canvas declared" : `Incomplete slide canvas (${missing[0]} missing)`;
+      return [
+        {
+          code: QUALITY_CODES.CANVAS_UNSPECIFIED,
+          severity: "warning",
+          category: "integrity",
+          message: `${state}: the renderer falls back to 4:3 (${RENDERER_DEFAULT_WIDTH_IN}\xD7${RENDERER_DEFAULT_HEIGHT_IN}"), and 16:9 content on that canvas leaves a dead strip at the bottom.`,
+          path: canvas.path,
+          suggestion: "Declare props.slideWidth and props.slideHeight \u2014 13.333 \xD7 7.5 for a standard 16:9 deck.",
+          context: {
+            missing,
+            rendererDefault: {
+              slideWidth: RENDERER_DEFAULT_WIDTH_IN,
+              slideHeight: RENDERER_DEFAULT_HEIGHT_IN
+            }
+          }
+        }
+      ];
+    }
+    const match = KNOWN_CANVASES.find(
+      (known) => Math.abs(known.w - width) < 0.01 && Math.abs(known.h - height) < 0.01
+    );
+    if (match?.legacy) {
+      return [
+        {
+          code: QUALITY_CODES.CANVAS_LEGACY,
+          message: `Canvas is 4:3 legacy (${match.w}\xD7${match.h}") \u2014 modern screens are 16:9.`,
+          path: canvas.path,
+          suggestion: "If 4:3 is not deliberate, use slideWidth 13.333 and slideHeight 7.5."
+        }
+      ];
+    }
+    if (match) return [];
+    return [
+      {
+        code: QUALITY_CODES.CANVAS_NONSTANDARD,
+        message: `Canvas ${width}\xD7${height}" matches no common preset (16:9, 1:1, 4:5, 9:16).`,
+        path: canvas.path,
+        suggestion: "Confirm the size is deliberate; a mistyped canvas distorts every slide.",
+        context: {
+          knownCanvases: KNOWN_CANVASES.map(({ w, h, label }) => ({
+            slideWidth: w,
+            slideHeight: h,
+            label
+          }))
+        }
+      }
+    ];
+  }
+};
+var pptxMinimumFontRule = {
+  id: "pptx/minimum-font-size",
+  code: QUALITY_CODES.FONT_SIZE_MIN,
+  category: "legibility",
+  defaultSeverity: "warning",
+  defaultCertainty: "measured",
+  formats: ["pptx"],
+  defaultParameters: { minimumFontPt: DEFAULT_MIN_READABLE_FONT_PT },
+  evaluate: ({ facts, configuration }) => {
+    const minimum = numberParameter(
+      configuration.parameters,
+      "minimumFontPt",
+      DEFAULT_MIN_READABLE_FONT_PT
+    );
+    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`,
+      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
+        }
+      ]
+    }));
+  }
+};
+function fittingFontSizePt(fact, charWidthFactor, minimumFontPt) {
+  if (fact.autoFit === true) return void 0;
+  const minimumWholeSize = Math.ceil(minimumFontPt);
+  for (let size = Math.floor(fact.fontSizePt) - 1; size >= minimumWholeSize; size--) {
+    const estimate = estimateTextHeightPt(
+      { ...fact, fontSizePt: size },
+      charWidthFactor
+    );
+    if (estimate !== void 0 && fact.boxHeightPt !== void 0 && estimate.heightPt <= fact.boxHeightPt) {
+      return size;
+    }
+  }
+  return void 0;
+}
+var pptxTextFitRule = {
+  id: "pptx/text-fit",
+  code: QUALITY_CODES.TEXT_TIGHT,
+  category: "integrity",
+  defaultSeverity: "info",
+  defaultCertainty: "estimated",
+  formats: ["pptx"],
+  defaultParameters: {
+    characterWidthFactor: DEFAULT_CHAR_WIDTH_FACTOR,
+    safetyBufferPt: DEFAULT_SAFETY_BUFFER_PT
+  },
+  evaluate: ({ facts, configuration, profile, policy }) => {
+    const factor = numberParameter(
+      configuration.parameters,
+      "characterWidthFactor",
+      DEFAULT_CHAR_WIDTH_FACTOR
+    );
+    const safetyBufferPt = numberParameter(
+      configuration.parameters,
+      "safetyBufferPt",
+      DEFAULT_SAFETY_BUFFER_PT
+    );
+    const minimumFontConfiguration = resolveRuleConfiguration(
+      pptxMinimumFontRule,
+      profile,
+      policy
+    );
+    const minimumFontPt = minimumFontConfiguration.enabled ? numberParameter(
+      minimumFontConfiguration.parameters,
+      "minimumFontPt",
+      DEFAULT_MIN_READABLE_FONT_PT
+    ) : DEFAULT_MIN_READABLE_FONT_PT;
+    const findings = [];
+    for (const fact of textFacts(facts)) {
+      const estimate = estimateTextHeightPt(fact, factor);
+      if (!estimate || fact.boxHeightPt === void 0) continue;
+      const marginPt = fact.boxHeightPt - estimate.heightPt;
+      const measured = {
+        estimatedTextPt: Math.round(estimate.heightPt * 10) / 10,
+        availablePt: Math.round(fact.boxHeightPt * 10) / 10,
+        marginPt: Math.round(marginPt * 10) / 10,
+        estimatedLines: estimate.lines,
+        fontSize: fact.fontSizePt,
+        boxWidthPt: Math.round(fact.boxWidthPt * 10) / 10
+      };
+      if (marginPt < -fact.lineSpacingPt) {
+        const fittingSize = fittingFontSizePt(fact, factor, minimumFontPt);
+        findings.push({
+          code: QUALITY_CODES.TEXT_OVERFLOW,
+          severity: "warning",
+          message: `Text is estimated at ${measured.estimatedTextPt}pt tall (${estimate.lines} line${estimate.lines === 1 ? "" : "s"} of ${fact.fontSizePt}pt) in a ${measured.availablePt}pt box \u2014 it will overflow.`,
+          path: fact.path,
+          suggestion: "Shorten the text, reduce fontSize, or enlarge the box (h / rowSpan).",
+          context: measured,
+          evidence: {
+            actual: measured.estimatedTextPt,
+            expected: measured.availablePt,
+            unit: "pt"
+          },
+          // A ready-made patch only when a readable size fits; shortening
+          // the text or growing the box stays the author's call.
+          ...fittingSize !== void 0 && {
+            fixes: [
+              {
+                op: "add",
+                path: `${fact.path}/props/fontSize`,
+                value: fittingSize
+              }
+            ]
+          }
+        });
+        continue;
+      }
+      if (marginPt >= safetyBufferPt) continue;
+      findings.push({
+        code: QUALITY_CODES.TEXT_TIGHT,
+        message: marginPt < 0 ? `Text is estimated to exceed its ${measured.availablePt}pt box by ${-measured.marginPt}pt \u2014 within one line-height, so likely a harmless spill into the gap below.` : `Text fits its box with only ${measured.marginPt}pt to spare \u2014 renderer rounding can push it over.`,
+        path: fact.path,
+        suggestion: `Leave at least ${safetyBufferPt}pt of vertical margin.`,
+        context: measured,
+        evidence: {
+          actual: measured.marginPt,
+          expected: safetyBufferPt,
+          unit: "pt margin"
+        }
+      });
+    }
+    return findings;
+  }
+};
+var pptxSlideDensityRule = {
+  id: "pptx/slide-density",
+  code: QUALITY_CODES.SLIDE_DENSITY,
+  category: "information-design",
+  defaultSeverity: "warning",
+  defaultCertainty: "estimated",
+  formats: ["pptx"],
+  defaultParameters: { maximumBodyWords: DEFAULT_MAX_BODY_WORDS_PER_SLIDE },
+  evaluate: ({ facts, configuration }) => {
+    const threshold = numberParameter(
+      configuration.parameters,
+      "maximumBodyWords",
+      DEFAULT_MAX_BODY_WORDS_PER_SLIDE
+    );
+    return facts.filter((fact) => fact.kind === "pptx/slide").filter((fact) => fact.bodyWords > threshold).map((fact) => ({
+      message: `${fact.bodyWords} words of body text on one slide \u2014 an audience reads a slide, it does not study one.`,
+      path: fact.path,
+      suggestion: "One idea per slide: split the content across more slides.",
+      context: { bodyWords: fact.bodyWords, threshold },
+      evidence: {
+        actual: fact.bodyWords,
+        expected: threshold,
+        unit: "words"
+      }
+    }));
+  }
+};
+var AA_NORMAL_RATIO = 4.5;
+var AA_LARGE_RATIO = 3;
+var LARGE_TEXT_PT = 18;
+var LARGE_BOLD_TEXT_PT = 14;
+function channelLuminance(channel) {
+  const c = channel / 255;
+  return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function relativeLuminance(hex) {
+  const match = /^#?([0-9a-f]{6})$/i.exec(hex);
+  if (!match) return void 0;
+  const value = parseInt(match[1], 16);
+  return 0.2126 * channelLuminance(value >> 16 & 255) + 0.7152 * channelLuminance(value >> 8 & 255) + 0.0722 * channelLuminance(value & 255);
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  if (la === void 0 || lb === void 0) return void 0;
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+var pptxTextContrastRule = {
+  id: "pptx/text-contrast",
+  code: QUALITY_CODES.TEXT_CONTRAST,
+  category: "accessibility",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["pptx"],
+  defaultParameters: {
+    normalRatio: AA_NORMAL_RATIO,
+    largeRatio: AA_LARGE_RATIO,
+    largeTextPt: LARGE_TEXT_PT,
+    largeBoldTextPt: LARGE_BOLD_TEXT_PT
+  },
+  evaluate: ({ facts, configuration }) => {
+    const normalRatio = numberParameter(
+      configuration.parameters,
+      "normalRatio",
+      AA_NORMAL_RATIO
+    );
+    const largeRatio = numberParameter(
+      configuration.parameters,
+      "largeRatio",
+      AA_LARGE_RATIO
+    );
+    const largeTextPt = numberParameter(
+      configuration.parameters,
+      "largeTextPt",
+      LARGE_TEXT_PT
+    );
+    const largeBoldTextPt = numberParameter(
+      configuration.parameters,
+      "largeBoldTextPt",
+      LARGE_BOLD_TEXT_PT
+    );
+    return textFacts(facts).flatMap((fact) => {
+      const { colorHex, backgroundHexes } = fact;
+      if (!colorHex || !backgroundHexes?.length) return [];
+      let worst;
+      for (const background2 of backgroundHexes) {
+        const ratio = contrastRatio(colorHex, background2);
+        if (ratio === void 0) continue;
+        if (!worst || ratio < worst.ratio) worst = { ratio, background: background2 };
+      }
+      if (!worst) return [];
+      const isLarge = fact.fontSizePt >= largeTextPt || fact.bold && fact.fontSizePt >= largeBoldTextPt;
+      const required = isLarge ? largeRatio : normalRatio;
+      if (worst.ratio >= required) return [];
+      const rounded = Math.round(worst.ratio * 100) / 100;
+      return [
+        {
+          message: `Text at #${colorHex} on #${worst.background} has ${rounded}:1 contrast \u2014 below the ${required}:1 needed at ${fact.fontSizePt}pt${fact.bold ? " bold" : ""}.`,
+          path: fact.path,
+          suggestion: "Darken the text, lighten it further, or change the surface behind it.",
+          context: {
+            colorHex,
+            backgroundHex: worst.background,
+            ratio: rounded,
+            required,
+            fontSizePt: fact.fontSizePt,
+            bold: fact.bold,
+            backgroundHexes
+          },
+          evidence: {
+            actual: rounded,
+            expected: required,
+            unit: ":1"
+          }
+        }
+      ];
+    });
+  }
+};
+var PPTX_QUALITY_RULES = {
+  id: "pptx/default",
+  rules: [
+    pptxCanvasRule,
+    pptxMinimumFontRule,
+    pptxTextFitRule,
+    pptxSlideDensityRule,
+    pptxTextContrastRule
+  ]
+};
+var PPTX_QUALITY_PROFILES = {
+  "executive-presentation": {
+    id: "executive-presentation",
+    formats: ["pptx"],
+    description: "Decision deck optimized for scan speed and projection.",
+    rules: {
+      "pptx/minimum-font-size": { parameters: { minimumFontPt: 14 } },
+      "pptx/slide-density": { parameters: { maximumBodyWords: 70 } }
+    }
+  },
+  "technical-presentation": {
+    id: "technical-presentation",
+    formats: ["pptx"],
+    description: "Portable professional presentation defaults."
+  }
+};
+var PPTX_DEFAULT_QUALITY_PROFILE = PPTX_QUALITY_PROFILES["technical-presentation"];
+var PPTX_PROFILES_BY_ID = PPTX_QUALITY_PROFILES;
+function resolvePptxQualityProfile(requested) {
+  if (!requested) return void 0;
+  const registered = PPTX_PROFILES_BY_ID[requested.id];
+  if (!registered) return requested;
+  return mergeQualityProfiles(registered, requested);
+}
+var pptxQualityEngine = new QualityEngine(PPTX_QUALITY_RULES.rules);
+
+// src/quality/preflight.ts
+var PREPARE_RULE_ID = "quality/prepare";
+function emptyAnalysis(ruleErrors = [], blocked = false) {
+  return {
+    diagnostics: [],
+    counts: { error: 0, warning: 0, info: 0 },
+    blocked,
+    truncated: false,
+    suppressedCount: 0,
+    evaluatedRuleIds: [],
+    ruleErrors
+  };
+}
+function analyzePptxQuality(doc, options = {}) {
+  assertValidQualityPolicy(options.policy);
+  assertValidQualityProfile(options.profile);
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc) || doc.name !== "pptx") {
+    return emptyAnalysis();
+  }
+  let prepared = options.prepared;
+  try {
+    prepared ??= preparePptxQualityDocument(
+      doc,
+      options
+    );
+  } catch (error) {
+    if (options.policy?.onRuleError === "throw") throw error;
+    const gate = options.policy?.gate;
+    return emptyAnalysis(
+      [
+        {
+          ruleId: PREPARE_RULE_ID,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ],
+      gate !== void 0 && gate !== "none"
+    );
+  }
+  return pptxQualityEngine.analyzeSync(prepared, {
+    profile: resolvePptxQualityProfile(options.profile) ?? PPTX_DEFAULT_QUALITY_PROFILE,
+    policy: options.policy
+  });
+}
+
 // src/plugin/index.ts
 import {
   createComponent,
@@ -5360,10 +6291,14 @@ export {
   DEFAULT_PPTX_RENDERER_ID,
   DEFAULT_PPTX_THEME,
   DuplicateComponentError,
+  PPTX_DEFAULT_QUALITY_PROFILE,
+  PPTX_QUALITY_PROFILES,
+  PPTX_QUALITY_RULES,
   PresentationGenerator,
   PresentationValidationError,
   UncompiledComponentError,
   W as WarningCodes,
+  analyzePptxQuality,
   cleanComponentProps,
   createComponent,
   createPresentationGenerator,
@@ -5380,10 +6315,13 @@ export {
   isPresentationComponent,
   isPresentationComponentDefinition,
   isSlideComponent,
+  pptxQualityEngine,
   pptxRendererIds,
   pptxRendererStatuses,
   pptxThemes,
+  preparePptxQualityDocument,
   resolveComponentVersion3 as resolveComponentVersion,
+  resolvePptxQualityProfile,
   validateComponentProps,
   validatePresentation
 };