@json-to-office/core-pptx 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,5 +1,4 @@
 // src/core/generator.ts
-import JSZip from "jszip";
 import { writeFileSync } from "fs";
 
 // src/types.ts
@@ -307,8 +306,82 @@ function resolveComponentTree(components, theme) {
   });
 }
 
+// src/utils/hyperlink.ts
+var HYPERLINK_SLIDE_UNRESOLVED = "HYPERLINK_SLIDE_UNRESOLVED";
+function remapHyperlink(hyperlink, map) {
+  if (hyperlink.url || hyperlink.slide == null) return hyperlink;
+  const rendered = map.get(hyperlink.slide);
+  if (rendered === void 0) {
+    const { slide, ...rest } = hyperlink;
+    return { ...rest, unresolvedSlideRef: slide };
+  }
+  return rendered === hyperlink.slide ? hyperlink : { ...hyperlink, slide: rendered };
+}
+function remapHyperlinkProps(props, map) {
+  const hyperlink = props.hyperlink;
+  if (!hyperlink || typeof hyperlink !== "object") return props;
+  const remapped = remapHyperlink(hyperlink, map);
+  return remapped === hyperlink ? props : { ...props, hyperlink: remapped };
+}
+function remapHyperlinkSlideRefs(component, map) {
+  const hyperlink = component.props?.hyperlink;
+  let next = component;
+  if (hyperlink && typeof hyperlink === "object") {
+    const remapped = remapHyperlink(hyperlink, map);
+    if (remapped !== hyperlink) {
+      next = { ...next, props: { ...next.props, hyperlink: remapped } };
+    }
+  }
+  if (next.children && next.children.length > 0) {
+    next = {
+      ...next,
+      children: next.children.map(
+        (child) => remapHyperlinkSlideRefs(child, map)
+      )
+    };
+  }
+  return next;
+}
+function applyHyperlink(opts, hyperlink, componentName, warnings) {
+  if (!hyperlink) return;
+  if (hyperlink.url) {
+    opts.hyperlink = { url: hyperlink.url, tooltip: hyperlink.tooltip };
+    return;
+  }
+  if (hyperlink.unresolvedSlideRef != null) {
+    const message = `hyperlink.slide ${hyperlink.unresolvedSlideRef} matches no slide in the generated presentation (slide disabled, or index out of range) \u2014 hyperlink dropped`;
+    if (warnings) {
+      warnings.push({
+        code: HYPERLINK_SLIDE_UNRESOLVED,
+        message,
+        component: componentName
+      });
+    } else {
+      console.warn(message);
+    }
+    return;
+  }
+  if (hyperlink.slide) {
+    opts.hyperlink = { slide: hyperlink.slide, tooltip: hyperlink.tooltip };
+  }
+}
+
 // src/core/structure.ts
 import { mergeWithDefaults as mergeWithDefaults2 } from "@json-to-office/shared";
+function isSlideEnabled(child) {
+  return !("enabled" in child && child.enabled === false);
+}
+function buildSlideIndexMap(children) {
+  const map = /* @__PURE__ */ new Map();
+  let authored = 0;
+  let rendered = 0;
+  for (const child of children) {
+    if (!isSlideComponent(child)) continue;
+    authored++;
+    if (isSlideEnabled(child)) map.set(authored, ++rendered);
+  }
+  return map;
+}
 function processPresentation(document, options) {
   const { props, children = [] } = document;
   const baseTheme = typeof props.theme === "object" && props.theme !== null ? props.theme : options?.customThemes?.[props.theme ?? "default"] ?? getPptxTheme(props.theme ?? "default");
@@ -322,34 +395,41 @@ function processPresentation(document, options) {
   } : baseTheme;
   const slideWidth = props.slideWidth ?? 10;
   const slideHeight = props.slideHeight ?? 7.5;
+  const slideIndexMap = buildSlideIndexMap(children);
   let templates;
   if (props.templates && props.templates.length > 0) {
     templates = props.templates.map((m) => {
       const effectiveGrid = mergeGridConfigs(props.grid, m.grid);
       const resolvedPhs = m.placeholders?.map((ph) => {
-        if (!ph.grid) return ph;
+        const phDefaults = ph.defaults;
+        const defaultProps = phDefaults?.props ? remapHyperlinkProps(phDefaults.props, slideIndexMap) : void 0;
+        const base = phDefaults && defaultProps && defaultProps !== phDefaults.props ? { ...ph, defaults: { ...phDefaults, props: defaultProps } } : ph;
+        if (!base.grid) return base;
         const abs = resolveGridPosition(
-          ph.grid,
+          base.grid,
           effectiveGrid,
           slideWidth,
           slideHeight
         );
         return {
-          ...ph,
-          x: ph.x ?? abs.x,
-          y: ph.y ?? abs.y,
-          w: ph.w ?? abs.w,
-          h: ph.h ?? abs.h,
+          ...base,
+          x: base.x ?? abs.x,
+          y: base.y ?? abs.y,
+          w: base.w ?? abs.w,
+          h: base.h ?? abs.h,
           grid: void 0
         };
       });
       const defaultedObjects = m.objects ? resolveComponentTree(m.objects, theme) : void 0;
       const resolvedObjects = defaultedObjects?.map(
-        (obj) => resolveComponentGridPosition(
-          obj,
-          effectiveGrid,
-          slideWidth,
-          slideHeight
+        (obj) => remapHyperlinkSlideRefs(
+          resolveComponentGridPosition(
+            obj,
+            effectiveGrid,
+            slideWidth,
+            slideHeight
+          ),
+          slideIndexMap
         )
       );
       return { ...m, placeholders: resolvedPhs, objects: resolvedObjects };
@@ -358,13 +438,18 @@ function processPresentation(document, options) {
   const slides = [];
   for (const child of children) {
     if (isSlideComponent(child)) {
+      if (!isSlideEnabled(child)) continue;
       const slideComponents = [];
       if (child.children) {
         for (const slideChild of child.children) {
           slideComponents.push(slideChild);
         }
       }
-      const resolvedComponents = resolveComponentTree(slideComponents, theme);
+      const resolvedComponents = resolveComponentTree(
+        slideComponents,
+        theme
+      ).map((component) => remapHyperlinkSlideRefs(component, slideIndexMap));
+      const placeholders = child.props.placeholders;
       slides.push({
         components: resolvedComponents,
         background: child.props.background,
@@ -372,7 +457,12 @@ function processPresentation(document, options) {
         layout: child.props.layout,
         hidden: child.props.hidden,
         template: child.props.template,
-        placeholders: child.props.placeholders
+        placeholders: placeholders ? Object.fromEntries(
+          Object.entries(placeholders).map(([name, component]) => [
+            name,
+            remapHyperlinkSlideRefs(component, slideIndexMap)
+          ])
+        ) : void 0
       });
     }
   }
@@ -401,6 +491,7 @@ import PptxGenJS from "pptxgenjs";
 
 // src/utils/color.ts
 import { SEMANTIC_COLOR_NAMES } from "@json-to-office/shared-pptx";
+import { DEFAULT_CHART_THEME_COLORS } from "@json-to-office/shared";
 var SEMANTIC_TO_THEME_KEY = {
   ...Object.fromEntries(SEMANTIC_COLOR_NAMES.map((n) => [n, n])),
   // Aliases (PowerPoint XML compat)
@@ -412,26 +503,49 @@ var SEMANTIC_TO_THEME_KEY = {
   bg1: "background",
   bg2: "background2"
 };
-var DEFAULT_CHART_THEME_COLORS = [
-  "primary",
-  "secondary",
-  "accent",
-  "accent4",
-  "accent5",
-  "accent6"
-];
+function chainToHex(value, theme, seen) {
+  const bare = value.startsWith("#") ? value.slice(1) : value;
+  if (/^[0-9A-Fa-f]{6}$/.test(bare)) return bare;
+  if (/^[0-9A-Fa-f]{3}$/.test(bare)) {
+    return bare[0] + bare[0] + bare[1] + bare[1] + bare[2] + bare[2];
+  }
+  const themeKey = SEMANTIC_TO_THEME_KEY[value];
+  if (!themeKey || seen.has(themeKey)) return void 0;
+  seen.add(themeKey);
+  const next = theme?.colors?.[themeKey];
+  if (typeof next !== "string" || next.length === 0) return void 0;
+  return chainToHex(next, theme, seen)?.toUpperCase();
+}
+function definedChartColorTokens(theme) {
+  const colors = theme?.colors;
+  if (!colors) return [];
+  return DEFAULT_CHART_THEME_COLORS.filter((token) => {
+    const themeKey = SEMANTIC_TO_THEME_KEY[token] ?? token;
+    const value = colors[themeKey];
+    if (typeof value !== "string" || value.length === 0) return false;
+    return chainToHex(value, theme, /* @__PURE__ */ new Set([themeKey])) !== void 0;
+  });
+}
 function resolveColor(color, theme, warnings) {
   const themeKey = SEMANTIC_TO_THEME_KEY[color];
   if (themeKey) {
     const resolved = theme.colors[themeKey];
-    if (resolved)
-      return resolved.startsWith("#") ? resolved.slice(1) : resolved;
+    if (resolved) {
+      const hex = chainToHex(resolved, theme, /* @__PURE__ */ new Set([themeKey]));
+      if (hex) return hex;
+      warn(
+        warnings,
+        W.UNKNOWN_COLOR,
+        `Theme color "${themeKey}" is "${resolved}", which is not a hex color or a theme color name; falling back to primary`
+      );
+      return resolvePrimary(theme);
+    }
     warn(
       warnings,
       W.THEME_COLOR_FALLBACK,
       `Theme color "${themeKey}" not defined, falling back to primary`
     );
-    return theme.colors.primary.startsWith("#") ? theme.colors.primary.slice(1) : theme.colors.primary;
+    return resolvePrimary(theme);
   }
   const bare = color.startsWith("#") ? color.slice(1) : color;
   if (/^[0-9A-Fa-f]{3}$/.test(bare)) {
@@ -446,6 +560,10 @@ function resolveColor(color, theme, warnings) {
   }
   return bare;
 }
+function resolvePrimary(theme) {
+  const primary = theme.colors.primary;
+  return chainToHex(primary, theme, /* @__PURE__ */ new Set(["primary"])) ?? (primary.startsWith("#") ? primary.slice(1) : primary);
+}
 
 // src/utils/fontAliasContext.ts
 import { synthesizeFamilyName } from "@json-to-office/shared";
@@ -541,19 +659,7 @@ function renderTextComponent(slide, props, theme, warnings, slideCtx) {
       opts.fill.transparency = props.fill.transparency;
     }
   }
-  if (props.hyperlink) {
-    if (props.hyperlink.url) {
-      opts.hyperlink = {
-        url: props.hyperlink.url,
-        tooltip: props.hyperlink.tooltip
-      };
-    } else if (props.hyperlink.slide) {
-      opts.hyperlink = {
-        slide: props.hyperlink.slide,
-        tooltip: props.hyperlink.tooltip
-      };
-    }
-  }
+  applyHyperlink(opts, props.hyperlink, "text", warnings);
   const lineSpacing = props.lineSpacing ?? style?.lineSpacing;
   if (lineSpacing !== void 0) opts.lineSpacing = lineSpacing;
   const charSpacing = props.charSpacing ?? style?.charSpacing;
@@ -731,19 +837,7 @@ async function renderImageComponent(slide, props, theme, warnings, slideWidth =
       opacity: props.shadow.opacity ?? 0.5
     };
   }
-  if (props.hyperlink) {
-    if (props.hyperlink.url) {
-      opts.hyperlink = {
-        url: props.hyperlink.url,
-        tooltip: props.hyperlink.tooltip
-      };
-    } else if (props.hyperlink.slide) {
-      opts.hyperlink = {
-        slide: props.hyperlink.slide,
-        tooltip: props.hyperlink.tooltip
-      };
-    }
-  }
+  applyHyperlink(opts, props.hyperlink, "image", warnings);
   if (props.alt) opts.altText = props.alt;
   slide.addImage(opts);
 }
@@ -1131,9 +1225,10 @@ Cause: ${error instanceof Error ? error.message : String(error)}`
 }
 function withThemeColors(props, theme, warnings) {
   if (!props.options || props.options.colors || !theme?.colors) return props;
-  const palette = DEFAULT_CHART_THEME_COLORS.map(
+  const palette = definedChartColorTokens(theme).map(
     (token) => `#${resolveColor(token, theme, warnings)}`
   );
+  if (palette.length === 0) return props;
   return {
     ...props,
     options: { ...props.options, colors: palette }
@@ -1167,7 +1262,6 @@ var CHART_TYPE_MAP = {
   radar: "radar",
   scatter: "scatter"
 };
-var DEFAULT_THEME_COLORS = DEFAULT_CHART_THEME_COLORS;
 function renderChartComponent(slide, props, theme, _pptx, warnings) {
   const chartType = CHART_TYPE_MAP[props.type];
   if (!chartType) {
@@ -1214,8 +1308,12 @@ function renderChartComponent(slide, props, theme, _pptx, warnings) {
   if (props.y !== void 0) opts.y = props.y;
   if (props.w !== void 0) opts.w = props.w;
   if (props.h !== void 0) opts.h = props.h;
-  const colorSources = props.chartColors ?? DEFAULT_THEME_COLORS;
-  opts.chartColors = colorSources.map((c) => resolveColor(c, theme, warnings));
+  const colorSources = props.chartColors ?? definedChartColorTokens(theme);
+  if (colorSources.length > 0) {
+    opts.chartColors = colorSources.map(
+      (c) => resolveColor(c, theme, warnings)
+    );
+  }
   const themeTextColor = resolveColor("text", theme, warnings);
   opts.titleColor = props.titleColor ? resolveColor(props.titleColor, theme, warnings) : themeTextColor;
   opts.legendColor = props.legendColor ? resolveColor(props.legendColor, theme, warnings) : themeTextColor;
@@ -1612,13 +1710,161 @@ async function resolveDocumentFonts(document, theme, warnings, fonts) {
 
 // src/core/generator.ts
 import { applyExportMode, scopedThemeName } from "@json-to-office/shared";
-import { collectImageSourceConflicts } from "@json-to-office/shared-pptx";
+import {
+  collectImageSourceConflicts,
+  validateJsonPresentationDocument,
+  validatePresentationDocument
+} from "@json-to-office/shared-pptx";
+
+// src/core/packagePresentation.ts
+import JSZip from "jszip";
+var MEDIUM_STYLE_2_ACCENT_1 = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
+var NO_STYLE_NO_GRID = "{2D5ABB26-0587-4C30-8999-92F81FD0307C}";
+var DEFAULT_GENERATED_AT = "2000-01-01T00:00:00.000Z";
+function resolveGeneratedAt(value) {
+  const date = value === void 0 ? new Date(DEFAULT_GENERATED_AT) : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid generatedAt value: ${String(value)}`);
+  }
+  if (date.getUTCFullYear() < 1980) {
+    throw new Error(
+      "generatedAt must be on or after 1980-01-01 for ZIP compatibility"
+    );
+  }
+  return date;
+}
+function replaceCoreTimestamp(xml, tag, value) {
+  const expression = new RegExp(
+    `(<dcterms:${tag}\\b[^>]*>)[^<]*(</dcterms:${tag}>)`,
+    "g"
+  );
+  return xml.replace(expression, `$1${value}$2`);
+}
+var EMBEDDED_OFFICE_PACKAGE = /\.(?:docx|pptx|xlsx|xlsm)$/i;
+function remapChartReferences(value, chartIds) {
+  return value.replace(/chart(\d+)\.xml/g, (match, rawId) => {
+    const id = chartIds.get(Number(rawId));
+    return id === void 0 ? match : `chart${id}.xml`;
+  }).replace(
+    /Microsoft_Excel_Worksheet(\d+)\.xlsx/g,
+    (match, rawId) => {
+      const id = chartIds.get(Number(rawId));
+      return id === void 0 ? match : `Microsoft_Excel_Worksheet${id}.xlsx`;
+    }
+  );
+}
+async function canonicalizeChartIds(zip) {
+  const sourceIds = Object.keys(zip.files).map((path2) => path2.match(/^ppt\/charts\/chart(\d+)\.xml$/)?.[1]).filter((value) => value !== void 0).map(Number).sort((a, b) => a - b);
+  const chartIds = new Map(sourceIds.map((id, index) => [id, index + 1]));
+  if (chartIds.size === 0) return;
+  for (const [path2, entry] of Object.entries(zip.files)) {
+    if (entry.dir || !path2.endsWith(".xml") && !path2.endsWith(".rels")) {
+      continue;
+    }
+    const xml = await entry.async("string");
+    const remapped = remapChartReferences(xml, chartIds);
+    if (remapped !== xml) zip.file(path2, remapped);
+  }
+  const renames = [];
+  for (const [path2, entry] of Object.entries(zip.files)) {
+    if (entry.dir) continue;
+    const remappedPath = remapChartReferences(path2, chartIds);
+    if (remappedPath === path2) continue;
+    renames.push({
+      from: path2,
+      to: remappedPath,
+      data: await entry.async("nodebuffer"),
+      date: entry.date
+    });
+  }
+  for (const entry of renames) zip.remove(entry.from);
+  for (const entry of renames) {
+    zip.file(entry.to, entry.data, { date: entry.date });
+  }
+}
+async function generateZip(zip) {
+  return await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 },
+    platform: "DOS",
+    streamFiles: false
+  });
+}
+async function canonicalizePackage(zip, generatedAt, depth = 0) {
+  const timestamp = generatedAt.toISOString().replace(/\.\d{3}Z$/, "Z");
+  const coreEntry = zip.file("docProps/core.xml");
+  if (coreEntry) {
+    let coreXml = await coreEntry.async("string");
+    coreXml = replaceCoreTimestamp(coreXml, "created", timestamp);
+    coreXml = replaceCoreTimestamp(coreXml, "modified", timestamp);
+    zip.file("docProps/core.xml", coreXml);
+  }
+  if (depth < 3) {
+    for (const [path2, entry] of Object.entries(zip.files)) {
+      if (entry.dir || !EMBEDDED_OFFICE_PACKAGE.test(path2)) continue;
+      try {
+        const nested = await JSZip.loadAsync(await entry.async("nodebuffer"));
+        await canonicalizePackage(nested, generatedAt, depth + 1);
+        zip.file(path2, await generateZip(nested));
+      } catch {
+      }
+    }
+  }
+  for (const entry of Object.values(zip.files)) {
+    entry.date = generatedAt;
+  }
+}
+async function packagePresentationBuffer(buffer, options = {}) {
+  const zip = await JSZip.loadAsync(buffer);
+  let changed = false;
+  for (const [path2, entry] of Object.entries(zip.files)) {
+    if (!path2.match(/^ppt\/slides\/slide\d+\.xml$/)) continue;
+    const xml = await entry.async("string");
+    if (xml.includes(MEDIUM_STYLE_2_ACCENT_1)) {
+      zip.file(path2, xml.replaceAll(MEDIUM_STYLE_2_ACCENT_1, NO_STYLE_NO_GRID));
+      changed = true;
+    }
+  }
+  if (options.deterministic !== false) {
+    const generatedAt = resolveGeneratedAt(options.generatedAt);
+    await canonicalizeChartIds(zip);
+    await canonicalizePackage(zip, generatedAt);
+    changed = true;
+  }
+  if (!changed) return buffer;
+  return generateZip(zip);
+}
+
+// src/core/generator.ts
+var PresentationValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super(
+      `Presentation validation failed:
+${errors.map((error) => `  - ${error.path}: ${error.message}`).join("\n")}`
+    );
+    this.name = "PresentationValidationError";
+    this.errors = errors;
+  }
+};
+function assertValidPresentation(input, validation) {
+  if (validation?.enabled === false) return;
+  const options = {
+    allowUnknownFields: validation?.allowUnknownFields
+  };
+  const result = typeof input === "string" ? validateJsonPresentationDocument(input, options) : validatePresentationDocument(input, options);
+  if (!result.valid) {
+    throw new PresentationValidationError(result.errors);
+  }
+}
 function isPresentationComponentDefinition(definition) {
   if (typeof definition !== "object" || definition === null) return false;
   const def = definition;
   return def.name === "pptx" && "props" in def;
 }
 async function generatePresentation(document, options, warnings) {
+  assertValidPresentation(document, options?.validation);
   if (!document || document.name !== "pptx") {
     throw new Error("Top-level component must be a pptx component");
   }
@@ -1637,6 +1883,7 @@ async function generateBufferFromJson(jsonConfig, options) {
   return result.buffer;
 }
 async function generateBufferWithWarnings(jsonConfig, options) {
+  assertValidPresentation(jsonConfig, options?.validation);
   let component;
   if (typeof jsonConfig === "string") {
     const parsed = JSON.parse(jsonConfig);
@@ -1705,36 +1952,21 @@ async function generateBufferWithWarnings(jsonConfig, options) {
     warnings
   );
   const data = await pptx.write({ outputType: "nodebuffer" });
-  const buffer = await neutralizeTableStyle(data);
+  const buffer = await packagePresentationBuffer(data, options);
   return { buffer, warnings };
 }
 async function generateAndSaveFromJson(jsonConfig, outputPath, options) {
   const buffer = await generateBufferFromJson(jsonConfig, options);
   writeFileSync(outputPath, buffer);
 }
-async function generateFromFile(filePath, outputPath) {
+async function generateFromFile(filePath, outputPath, options) {
   const { readFileSync } = await import("fs");
   const json = readFileSync(filePath, "utf-8");
-  await generateAndSaveFromJson(json, outputPath);
-}
-var MEDIUM_STYLE_2_ACCENT_1 = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
-var NO_STYLE_NO_GRID = "{2D5ABB26-0587-4C30-8999-92F81FD0307C}";
-async function neutralizeTableStyle(buffer) {
-  const zip = await JSZip.loadAsync(buffer);
-  let changed = false;
-  for (const [path2, entry] of Object.entries(zip.files)) {
-    if (!path2.match(/^ppt\/slides\/slide\d+\.xml$/)) continue;
-    const xml = await entry.async("string");
-    if (xml.includes(MEDIUM_STYLE_2_ACCENT_1)) {
-      zip.file(path2, xml.replaceAll(MEDIUM_STYLE_2_ACCENT_1, NO_STYLE_NO_GRID));
-      changed = true;
-    }
-  }
-  return changed ? await zip.generateAsync({ type: "nodebuffer" }) : buffer;
+  await generateAndSaveFromJson(json, outputPath, options);
 }
-async function savePresentation(pptx, outputPath) {
+async function savePresentation(pptx, outputPath, options) {
   const data = await pptx.write({ outputType: "nodebuffer" });
-  const buffer = await neutralizeTableStyle(data);
+  const buffer = await packagePresentationBuffer(data, options);
   writeFileSync(outputPath, buffer);
 }
 var PresentationGenerator = {
@@ -1754,7 +1986,6 @@ import {
 } from "@json-to-office/shared/plugin";
 
 // src/plugin/createPresentationGenerator.ts
-import JSZip2 from "jszip";
 import {
   resolveComponentVersion as resolveComponentVersion2,
   DuplicateComponentError as DuplicateComponentError2,
@@ -1767,23 +1998,33 @@ import {
   validateCustomComponentProps,
   ComponentValidationError
 } from "@json-to-office/shared/plugin";
-import { collectImageSourceConflicts as collectImageSourceConflicts2 } from "@json-to-office/shared-pptx";
+import { validatePresentationDocument as validatePresentationDocument2 } from "@json-to-office/shared-pptx";
 import {
   DuplicateComponentError,
   ComponentValidationError as ComponentValidationError2
 } from "@json-to-office/shared/plugin";
-function validateComponentProps(schema, props, componentName) {
+function validateComponentProps(schema, props, componentName, opts) {
   return validateCustomComponentProps(schema.propsSchema, props, {
-    clean: true,
-    applyDefaults: true,
+    // Render-time cleaning remains the default. The document-validation path
+    // passes clean:false so unknown custom props are rejected when the custom
+    // schema declares additionalProperties:false.
+    clean: opts?.clean ?? true,
+    applyDefaults: opts?.applyDefaults ?? true,
     componentName
   });
 }
-function validatePresentation(document, customComponents) {
-  const errors = [];
-  errors.push(...collectImageSourceConflicts2(document));
+function validatePresentation(document, customComponents, options) {
+  const knownCustomNames = new Set(customComponents.map((c) => c.name));
+  const documentResult = validatePresentationDocument2(document, {
+    knownCustomNames,
+    allowUnknownFields: options?.allowUnknownFields
+  });
+  const errors = [...documentResult.errors];
   function validateComponents(components, pathPrefix = "children") {
     components.forEach((componentData, index) => {
+      if (!componentData || typeof componentData !== "object" || Array.isArray(componentData)) {
+        return;
+      }
       const customComponent = customComponents.find(
         (cc) => cc.name === componentData.name
       );
@@ -1796,7 +2037,8 @@ function validatePresentation(document, customComponents) {
         const validation = validateComponentProps(
           versionEntry,
           componentData.props,
-          customComponent.name
+          customComponent.name,
+          { clean: options?.allowUnknownFields === true }
         );
         if (!validation.valid && validation.errors) {
           const indexedErrors = validation.errors.map(
@@ -1816,7 +2058,7 @@ function validatePresentation(document, customComponents) {
       }
     });
   }
-  if (document.children) {
+  if (document && Array.isArray(document.children)) {
     validateComponents(document.children);
   }
   return errors.length > 0 ? { valid: false, errors } : { valid: true, errors: [] };
@@ -1866,24 +2108,9 @@ async function exportPluginSchema(customComponents, outputPath, options = {}) {
 
 // src/plugin/createPresentationGenerator.ts
 import { applyExportMode as applyExportMode2, scopedThemeName as scopedThemeName2 } from "@json-to-office/shared";
-var MEDIUM_STYLE_2_ACCENT_12 = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
-var NO_STYLE_NO_GRID2 = "{2D5ABB26-0587-4C30-8999-92F81FD0307C}";
-async function neutralizeTableStyle2(buffer) {
-  const zip = await JSZip2.loadAsync(buffer);
-  let changed = false;
-  for (const [path2, entry] of Object.entries(zip.files)) {
-    if (!path2.match(/^ppt\/slides\/slide\d+\.xml$/)) continue;
-    const xml = await entry.async("string");
-    if (xml.includes(MEDIUM_STYLE_2_ACCENT_12)) {
-      zip.file(path2, xml.replaceAll(MEDIUM_STYLE_2_ACCENT_12, NO_STYLE_NO_GRID2));
-      changed = true;
-    }
-  }
-  return changed ? await zip.generateAsync({ type: "nodebuffer" }) : buffer;
-}
 function createBuilderImpl(state) {
   const componentMap = new Map(state.components.map((c) => [c.name, c]));
-  async function processSlideComponents(components, warningsCollector, theme, depth = 0) {
+  async function processSlideComponents(components, warningsCollector, theme, validateEmitted, parentName, depth = 0) {
     if (depth > 20) {
       throw new Error(
         "Maximum component nesting depth exceeded (20). Check for circular component references."
@@ -1915,6 +2142,8 @@ function createBuilderImpl(state) {
               componentWithVersion.children,
               warningsCollector,
               theme,
+              validateEmitted,
+              void 0,
               depth + 1
             );
           }
@@ -1934,10 +2163,13 @@ function createBuilderImpl(state) {
             children: nestedChildren
           });
           const resultComponents = Array.isArray(result) ? result : [result];
+          validateEmitted?.(resultComponents, versionLabel, parentName);
           const processedResult = await processSlideComponents(
             resultComponents,
             warningsCollector,
             theme,
+            validateEmitted,
+            parentName,
             depth + 1
           );
           processed.push(...processedResult);
@@ -1961,6 +2193,8 @@ function createBuilderImpl(state) {
             componentData.children,
             warningsCollector,
             theme,
+            validateEmitted,
+            componentData.name,
             depth + 1
           );
           processed.push({
@@ -1990,16 +2224,31 @@ function createBuilderImpl(state) {
       customThemes: state.customThemes,
       debug: state.debug,
       services: state.services,
-      fonts: state.fonts
+      fonts: state.fonts,
+      validation: state.validation,
+      packaging: state.packaging
     };
     return createBuilderImpl(
       newState
     );
   }
-  async function generate(document) {
+  async function generate(document, options) {
     try {
       let internalDocument = document;
-      if (!internalDocument || internalDocument.name !== "pptx") {
+      const validationOptions = {
+        ...state.validation,
+        ...options?.validation
+      };
+      if (validationOptions.enabled !== false) {
+        const result = validatePresentation(
+          internalDocument,
+          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");
       }
       let inlineTheme;
@@ -2030,7 +2279,39 @@ function createBuilderImpl(state) {
           component: "fontRegistry"
         });
       }
-      const processedChildren = mode.doc.children ? await processAllSlides(mode.doc.children, warnings, resolvedTheme) : [];
+      const validateEmitted = validationOptions.enabled === false ? void 0 : (emitted, componentLabel, parentName) => {
+        let validationDocument;
+        if (parentName === "pptx") {
+          validationDocument = { ...mode.doc, children: emitted };
+        } else if (parentName === "slide") {
+          validationDocument = {
+            ...mode.doc,
+            children: [{ name: "slide", props: {}, children: emitted }]
+          };
+        } else {
+          return;
+        }
+        const result = validatePresentation(
+          validationDocument,
+          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
+          );
+        }
+      };
+      const processedChildren = mode.doc.children ? await processAllSlides(
+        mode.doc.children,
+        warnings,
+        resolvedTheme,
+        validateEmitted
+      ) : [];
       const themeName = scopedThemeName2(baseThemeName, state.fonts?.mode);
       const docWithScopedTheme = themeName !== baseThemeName ? {
         ...mode.doc,
@@ -2038,6 +2319,20 @@ function createBuilderImpl(state) {
         children: processedChildren
       } : { ...mode.doc, children: processedChildren };
       const processedDocument = docWithScopedTheme;
+      if (validationOptions.enabled !== false) {
+        const result = validatePresentation(processedDocument, [], {
+          allowUnknownFields: validationOptions.allowUnknownFields
+        });
+        if (!result.valid) {
+          throw new ComponentValidationError3(
+            result.errors.map((error) => ({
+              ...error,
+              message: `expanded plugin output failed validation \u2014 ${error.message}`
+            })),
+            processedDocument
+          );
+        }
+      }
       await resolveDocumentFonts(
         processedDocument,
         resolvedTheme,
@@ -2054,7 +2349,10 @@ function createBuilderImpl(state) {
       });
       const pptx = await renderPresentation(processed, warnings);
       const data = await pptx.write({ outputType: "nodebuffer" });
-      const buffer = await neutralizeTableStyle2(data);
+      const buffer = await packagePresentationBuffer(data, {
+        deterministic: options?.deterministic ?? state.packaging.deterministic,
+        generatedAt: options?.generatedAt ?? state.packaging.generatedAt
+      });
       return { buffer, warnings };
     } catch (error) {
       if (state.debug) {
@@ -2063,29 +2361,33 @@ function createBuilderImpl(state) {
       throw error;
     }
   }
-  async function processAllSlides(children, warnings, theme) {
+  async function processAllSlides(children, warnings, theme, validateEmitted) {
     const result = [];
     for (const child of children) {
       if (child.name === "slide" && child.children) {
         const processedSlideChildren = await processSlideComponents(
           child.children,
           warnings,
-          theme
+          theme,
+          validateEmitted,
+          "slide"
         );
         result.push({ ...child, children: processedSlideChildren });
       } else {
         const processedTopLevel = await processSlideComponents(
           [child],
           warnings,
-          theme
+          theme,
+          validateEmitted,
+          "pptx"
         );
         result.push(...processedTopLevel);
       }
     }
     return result;
   }
-  async function generateFile(document, outputPath) {
-    const { buffer, warnings } = await generate(document);
+  async function generateFile(document, outputPath, options) {
+    const { buffer, warnings } = await generate(document, options);
     const fs = await import("fs/promises");
     await fs.writeFile(outputPath, new Uint8Array(buffer));
     return { warnings };
@@ -2162,7 +2464,12 @@ function createPresentationGenerator(options = {}) {
     customThemes: options.customThemes,
     debug: options.debug ?? false,
     services: options.services,
-    fonts: options.fonts
+    fonts: options.fonts,
+    validation: options.validation,
+    packaging: {
+      deterministic: options.deterministic,
+      generatedAt: options.generatedAt
+    }
   };
   return createBuilderImpl(initialState);
 }
@@ -2176,9 +2483,11 @@ function getPptxCoreVersion() {
 }
 export {
   ComponentValidationError2 as ComponentValidationError,
+  DEFAULT_GENERATED_AT,
   DEFAULT_PPTX_THEME,
   DuplicateComponentError,
   PresentationGenerator,
+  PresentationValidationError,
   W as WarningCodes,
   cleanComponentProps,
   createComponent,
@@ -2196,6 +2505,7 @@ export {
   isPresentationComponent,
   isPresentationComponentDefinition,
   isSlideComponent,
+  packagePresentationBuffer,
   pptxThemes,
   renderComponent,
   renderHighchartsComponent,