ppt-template-reuse 0.4.0-rc.2

package/src/core/content-audit.mjs

@@ -0,0 +1,573 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  parseArgs,
+  readJson,
+  requireArg,
+  writeJson,
+} from "./planner-lib.mjs";
+
+const DEFAULT_EXEMPT_ROLES = new Set([
+  "opening",
+  "agenda",
+  "roadmap",
+  "closing",
+  "section",
+  "reference",
+  "references",
+]);
+
+function usage() {
+  return [
+    "Usage:",
+    "  node content-audit.mjs --content-plan <plan.json> [--report <audit.json>]",
+  ].join("\n");
+}
+
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function nonWhitespaceChars(value) {
+  return [...String(value ?? "").replace(/\s+/gu, "")].length;
+}
+
+function collectScalarStrings(value, output = []) {
+  if (typeof value === "string") {
+    if (value.trim()) output.push(value.trim());
+    return output;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectScalarStrings(item, output);
+    return output;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (["path", "alt", "contentType", "prompt"].includes(key)) continue;
+      collectScalarStrings(item, output);
+    }
+  }
+  return output;
+}
+
+function visibleStrings(slide) {
+  const values = collectScalarStrings(slide.fields || {});
+  const seen = new Set(values);
+  for (const key of ["title", "subtitle", "body"]) {
+    const value = text(slide[key]);
+    if (value && !seen.has(value)) {
+      seen.add(value);
+      values.push(value);
+    }
+  }
+  for (const value of collectScalarStrings(slide.bullets || [])) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      values.push(value);
+    }
+  }
+  return values;
+}
+
+function hasSubstantiveValue(value) {
+  if (Array.isArray(value)) return value.some(hasSubstantiveValue);
+  if (value && typeof value === "object") {
+    return Object.values(value).some(hasSubstantiveValue);
+  }
+  return text(value).length > 0;
+}
+
+function comparableText(value) {
+  return String(value || "").replace(/\s+/gu, "").trim();
+}
+
+function traceMatchesDestination(slide, record) {
+  const expected = comparableText(record?.text);
+  if (!expected) return false;
+  const destination = String(record?.destination || "");
+  if (destination === "speakerNotes") {
+    return comparableText(slide.speakerNotes).includes(expected);
+  }
+  if (destination.startsWith("fields.")) {
+    const field = destination.slice("fields.".length);
+    return collectScalarStrings(slide.fields?.[field]).some(
+      (value) => comparableText(value) === expected,
+    );
+  }
+  return false;
+}
+
+function normalizePriority(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function normalizedRole(slide) {
+  return String(slide.narrativeRole || "").trim().toLowerCase();
+}
+
+function isExemptSlide(slide, configuredRoles) {
+  const roles = configuredRoles?.length
+    ? new Set(configuredRoles.map((role) => String(role).toLowerCase()))
+    : DEFAULT_EXEMPT_ROLES;
+  return roles.has(normalizedRole(slide));
+}
+
+function boundedNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function ratio(numerator, denominator) {
+  return denominator > 0 ? numerator / denominator : 1;
+}
+
+export function auditContentPlan(contentPlan, { planPath = "" } = {}) {
+  const errors = [];
+  const warnings = [];
+  const slides = Array.isArray(contentPlan?.slides) ? contentPlan.slides : [];
+  const sourceUnits = Array.isArray(contentPlan?.sourceUnits)
+    ? contentPlan.sourceUnits
+    : [];
+  const policy = contentPlan?.deckPolicy?.contentAudit || {};
+  const strictRequested =
+    Object.keys(policy).length > 0 || sourceUnits.length > 0;
+
+  if (!slides.length) {
+    errors.push("Content plan must contain a non-empty slides array");
+  }
+
+  if (!strictRequested) {
+    return {
+      schemaVersion: 1,
+      planPath,
+      passed: errors.length === 0,
+      legacyMode: true,
+      errors,
+      warnings: [
+        "Legacy content plan: source-unit coverage, visible-density, notes, and duration gates were not enabled.",
+      ],
+      metrics: {
+        slideCount: slides.length,
+      },
+    };
+  }
+
+  if (!sourceUnits.length) {
+    errors.push("Strict content audit requires a non-empty sourceUnits array");
+  }
+
+  const unitById = new Map();
+  for (const [index, unit] of sourceUnits.entries()) {
+    const id = text(unit?.id);
+    const priority = normalizePriority(unit?.priority);
+    if (!id) {
+      errors.push(`Source unit ${index + 1} is missing id`);
+      continue;
+    }
+    if (unitById.has(id)) {
+      errors.push(`Duplicate source unit id: ${id}`);
+      continue;
+    }
+    if (!["critical", "supporting", "optional"].includes(priority)) {
+      errors.push(
+        `Source unit ${id} has invalid priority ${JSON.stringify(unit?.priority)}; use critical, supporting, or optional`,
+      );
+    }
+    if (!text(unit?.text) && !text(unit?.summary)) {
+      errors.push(`Source unit ${id} is missing text or summary`);
+    }
+    unitById.set(id, { ...unit, id, priority });
+  }
+
+  const configuredExemptRoles = Array.isArray(policy.exemptNarrativeRoles)
+    ? policy.exemptNarrativeRoles
+    : undefined;
+  const visibleRange = policy.visibleCharsPerContentSlide || {};
+  const notesRange = policy.speakerNotesCharsPerContentSlide || {};
+  const durationRange = policy.durationSeconds || {};
+  const visibleMin = boundedNumber(visibleRange.min, 70);
+  const visibleMax = boundedNumber(visibleRange.max, 140);
+  const notesMin = boundedNumber(notesRange.min, 150);
+  const notesMax = boundedNumber(notesRange.max, 300);
+  const enforceVisibleRange = visibleRange.enforce !== false;
+  const enforceNotesRange = notesRange.enforce !== false;
+  const totalVisibleMin = boundedNumber(policy.totalVisibleCharsMin, 0);
+  const totalSpeakerNotesMin = boundedNumber(
+    policy.totalSpeakerNotesCharsMin,
+    0,
+  );
+  const totalSpeakerNotesMax = boundedNumber(
+    policy.totalSpeakerNotesCharsMax,
+    Number.POSITIVE_INFINITY,
+  );
+  const durationMin = boundedNumber(durationRange.min, 0);
+  const durationMax = boundedNumber(durationRange.max, Number.POSITIVE_INFINITY);
+  const criticalCoverageMin = boundedNumber(policy.criticalCoverageMin, 1);
+  const weightedCoverageMin = boundedNumber(policy.weightedCoverageMin, 0.9);
+  const requireTraceableCoverage = policy.requireTraceableCoverage === true;
+  const criticalVisibleCoverageMin = boundedNumber(
+    policy.criticalVisibleCoverageMin,
+    requireTraceableCoverage ? 1 : 0,
+  );
+  const weightedVisibleCoverageMin = boundedNumber(
+    policy.weightedVisibleCoverageMin,
+    requireTraceableCoverage ? 0.9 : 0,
+  );
+  const sourceTextCoverageMin = boundedNumber(
+    policy.sourceTextCoverageMin,
+    requireTraceableCoverage ? 1 : 0,
+  );
+
+  const mappedUnitIds = new Set();
+  const coveredUnitIds = new Set();
+  const visibleTraceUnitIds = new Set();
+  const notesTraceUnitIds = new Set();
+  const sourceTextTraceUnitIds = new Set();
+  const slideMetrics = [];
+  let totalVisibleChars = 0;
+  let totalSpeakerNotesChars = 0;
+  let totalEstimatedSeconds = 0;
+  let coreEstimatedSeconds = 0;
+
+  for (const [index, slide] of slides.entries()) {
+    const outputSlide = Number(slide.outputSlide || index + 1);
+    const unitIds = Array.isArray(slide.sourceUnitIds)
+      ? slide.sourceUnitIds.map(String)
+      : [];
+    for (const id of unitIds) {
+      if (!unitById.has(id)) {
+        errors.push(`Slide ${outputSlide} references unknown source unit ${id}`);
+      } else {
+        mappedUnitIds.add(id);
+      }
+    }
+
+    if (requireTraceableCoverage) {
+      const visibleTrace = Array.isArray(slide.sourceTrace?.visible)
+        ? slide.sourceTrace.visible
+        : [];
+      const notesTrace = Array.isArray(slide.sourceTrace?.speakerNotes)
+        ? slide.sourceTrace.speakerNotes
+        : [];
+      for (const [traceType, records, destinationSet] of [
+        ["visible", visibleTrace, visibleTraceUnitIds],
+        ["speakerNotes", notesTrace, notesTraceUnitIds],
+      ]) {
+        for (const record of records) {
+          const sourceUnitId = String(record?.sourceUnitId || "");
+          if (!unitById.has(sourceUnitId)) {
+            errors.push(
+              `Slide ${outputSlide} ${traceType} trace references unknown source unit ${sourceUnitId || "(missing)"}`,
+            );
+            continue;
+          }
+          if (!unitIds.includes(sourceUnitId)) {
+            errors.push(
+              `Slide ${outputSlide} ${traceType} trace references ${sourceUnitId} without mapping it in sourceUnitIds`,
+            );
+            continue;
+          }
+          if (!traceMatchesDestination(slide, record)) {
+            errors.push(
+              `Slide ${outputSlide} ${traceType} trace for ${sourceUnitId} does not match its declared destination`,
+            );
+            continue;
+          }
+          destinationSet.add(sourceUnitId);
+          coveredUnitIds.add(sourceUnitId);
+          if (
+            traceType === "speakerNotes" &&
+            String(record?.sourceField || "") === "text"
+          ) {
+            sourceTextTraceUnitIds.add(sourceUnitId);
+          }
+        }
+      }
+      for (const id of unitIds) {
+        if (
+          !visibleTrace.some((record) => String(record?.sourceUnitId) === id) &&
+          !notesTrace.some((record) => String(record?.sourceUnitId) === id)
+        ) {
+          errors.push(
+            `Slide ${outputSlide} maps source unit ${id} without a visible or speaker-notes trace`,
+          );
+        }
+      }
+    } else {
+      for (const id of unitIds) {
+        if (unitById.has(id)) coveredUnitIds.add(id);
+      }
+    }
+
+    const visibleChars = visibleStrings(slide).reduce(
+      (sum, item) => sum + nonWhitespaceChars(item),
+      0,
+    );
+    const notesChars = nonWhitespaceChars(slide.speakerNotes);
+    const estimatedSeconds = boundedNumber(slide.estimatedSeconds, 0);
+    const exempt = isExemptSlide(slide, configuredExemptRoles);
+    totalVisibleChars += visibleChars;
+    totalSpeakerNotesChars += notesChars;
+    totalEstimatedSeconds += estimatedSeconds;
+    if (String(slide.section || "core").toLowerCase() !== "appendix") {
+      coreEstimatedSeconds += estimatedSeconds;
+    }
+
+    if (!exempt) {
+      for (const key of ["claim", "evidence", "whyItMatters"]) {
+        if (!hasSubstantiveValue(slide[key])) {
+          errors.push(
+            `Slide ${outputSlide} is an analysis slide but is missing ${key}`,
+          );
+        }
+      }
+      if (!unitIds.length) {
+        errors.push(`Slide ${outputSlide} does not map any sourceUnitIds`);
+      }
+      if (visibleChars < visibleMin || visibleChars > visibleMax) {
+        const message =
+          `Slide ${outputSlide} visible content has ${visibleChars} non-whitespace characters; ` +
+          `expected ${visibleMin}-${visibleMax}. Split or remap instead of shrinking typography.`;
+        (enforceVisibleRange ? errors : warnings).push(message);
+      }
+      if (notesChars < notesMin || notesChars > notesMax) {
+        const message =
+          `Slide ${outputSlide} speaker notes have ${notesChars} non-whitespace characters; ` +
+          `expected ${notesMin}-${notesMax}.`;
+        (enforceNotesRange ? errors : warnings).push(message);
+      }
+      if (visibleChars < 20) {
+        errors.push(
+          `Slide ${outputSlide} contains only a title or an abstract conclusion`,
+        );
+      }
+    }
+
+    if (hasSubstantiveValue(slide.counterargument) && !hasSubstantiveValue(slide.rebuttal)) {
+      errors.push(
+        `Slide ${outputSlide} includes a counterargument without a mapped rebuttal`,
+      );
+    }
+    if (!Number.isFinite(Number(slide.estimatedSeconds)) || estimatedSeconds <= 0) {
+      errors.push(`Slide ${outputSlide} must declare a positive estimatedSeconds value`);
+    }
+
+    slideMetrics.push({
+      outputSlide,
+      narrativeRole: slide.narrativeRole || "",
+      exempt,
+      visibleChars,
+      speakerNotesChars: notesChars,
+      estimatedSeconds,
+      sourceUnitIds: unitIds,
+    });
+  }
+
+  for (const unit of unitById.values()) {
+    if (
+      String(unit.kind || "").toLowerCase() === "counterargument" &&
+      coveredUnitIds.has(unit.id)
+    ) {
+      const mappedSlides = slides.filter((slide) =>
+        (slide.sourceUnitIds || []).map(String).includes(unit.id),
+      );
+      if (!mappedSlides.some((slide) => hasSubstantiveValue(slide.rebuttal))) {
+        errors.push(
+          `Counterargument source unit ${unit.id} is covered without a rebuttal`,
+        );
+      }
+    }
+  }
+
+  const eligibleUnits = [...unitById.values()].filter(
+    (unit) =>
+      String(unit.presentationRelevance || "core").toLowerCase() !== "exclude",
+  );
+  const criticalUnits = eligibleUnits.filter(
+    (unit) => unit.priority === "critical",
+  );
+  const coveredCritical = criticalUnits.filter((unit) =>
+    coveredUnitIds.has(unit.id),
+  );
+  const visiblyCoveredCritical = criticalUnits.filter((unit) =>
+    visibleTraceUnitIds.has(unit.id),
+  );
+  const unitWeight = (unit) =>
+    unit.priority === "critical" ? 3 : unit.priority === "optional" ? 0.5 : 1;
+  const totalWeight = eligibleUnits.reduce(
+    (sum, unit) => sum + unitWeight(unit),
+    0,
+  );
+  const coveredWeight = eligibleUnits.reduce(
+    (sum, unit) =>
+      sum + (coveredUnitIds.has(unit.id) ? unitWeight(unit) : 0),
+    0,
+  );
+  const criticalCoverage = ratio(coveredCritical.length, criticalUnits.length);
+  const weightedCoverage = ratio(coveredWeight, totalWeight);
+  const criticalVisibleCoverage = requireTraceableCoverage
+    ? ratio(visiblyCoveredCritical.length, criticalUnits.length)
+    : 1;
+  const visibleWeight = eligibleUnits.reduce(
+    (sum, unit) =>
+      sum + (visibleTraceUnitIds.has(unit.id) ? unitWeight(unit) : 0),
+    0,
+  );
+  const weightedVisibleCoverage = requireTraceableCoverage
+    ? ratio(visibleWeight, totalWeight)
+    : 1;
+  const sourceTextCoverage = requireTraceableCoverage
+    ? ratio(
+        eligibleUnits.filter((unit) => sourceTextTraceUnitIds.has(unit.id))
+          .length,
+        eligibleUnits.length,
+      )
+    : 1;
+
+  if (criticalCoverage + Number.EPSILON < criticalCoverageMin) {
+    const missing = criticalUnits
+      .filter((unit) => !coveredUnitIds.has(unit.id))
+      .map((unit) => unit.id);
+    errors.push(
+      `Critical source-unit coverage is ${(criticalCoverage * 100).toFixed(1)}%; ` +
+        `minimum is ${(criticalCoverageMin * 100).toFixed(1)}%. Missing: ${missing.join(", ")}`,
+    );
+  }
+  if (weightedCoverage + Number.EPSILON < weightedCoverageMin) {
+    const missing = eligibleUnits
+      .filter((unit) => !coveredUnitIds.has(unit.id))
+      .map((unit) => unit.id);
+    errors.push(
+      `Weighted source-unit coverage is ${(weightedCoverage * 100).toFixed(1)}%; ` +
+        `minimum is ${(weightedCoverageMin * 100).toFixed(1)}%. Missing: ${missing.join(", ")}`,
+    );
+  }
+  if (
+    criticalVisibleCoverage + Number.EPSILON <
+    criticalVisibleCoverageMin
+  ) {
+    const missing = criticalUnits
+      .filter((unit) => !visibleTraceUnitIds.has(unit.id))
+      .map((unit) => unit.id);
+    errors.push(
+      `Critical visible source coverage is ${(criticalVisibleCoverage * 100).toFixed(1)}%; ` +
+        `minimum is ${(criticalVisibleCoverageMin * 100).toFixed(1)}%. Missing: ${missing.join(", ")}`,
+    );
+  }
+  if (
+    weightedVisibleCoverage + Number.EPSILON <
+    weightedVisibleCoverageMin
+  ) {
+    const missing = eligibleUnits
+      .filter((unit) => !visibleTraceUnitIds.has(unit.id))
+      .map((unit) => unit.id);
+    errors.push(
+      `Weighted visible source coverage is ${(weightedVisibleCoverage * 100).toFixed(1)}%; ` +
+      `minimum is ${(weightedVisibleCoverageMin * 100).toFixed(1)}%. Missing: ${missing.join(", ")}`,
+    );
+  }
+  if (sourceTextCoverage + Number.EPSILON < sourceTextCoverageMin) {
+    const missing = eligibleUnits
+      .filter((unit) => !sourceTextTraceUnitIds.has(unit.id))
+      .map((unit) => unit.id);
+    errors.push(
+      `Source-text trace coverage is ${(sourceTextCoverage * 100).toFixed(1)}%; ` +
+        `minimum is ${(sourceTextCoverageMin * 100).toFixed(1)}%. Missing: ${missing.join(", ")}`,
+    );
+  }
+  if (totalVisibleChars < totalVisibleMin) {
+    errors.push(
+      `Deck visible content has ${totalVisibleChars} non-whitespace characters; minimum is ${totalVisibleMin}`,
+    );
+  }
+  if (
+    totalSpeakerNotesChars < totalSpeakerNotesMin ||
+    totalSpeakerNotesChars > totalSpeakerNotesMax
+  ) {
+    errors.push(
+      `Deck speaker notes have ${totalSpeakerNotesChars} non-whitespace characters; expected ${totalSpeakerNotesMin}-${totalSpeakerNotesMax}`,
+    );
+  }
+  const auditedDuration =
+    String(policy.durationScope || "").toLowerCase() === "core-only"
+      ? coreEstimatedSeconds
+      : totalEstimatedSeconds;
+  if (auditedDuration < durationMin) {
+    warnings.push(
+      `Estimated duration is ${auditedDuration} seconds, below the requested minimum ${durationMin}; keep the shorter deck unless the user explicitly asks for expansion.`,
+    );
+  }
+  if (auditedDuration > durationMax) {
+    errors.push(
+      `Estimated duration is ${auditedDuration} seconds; expected ${durationMin}-${durationMax}`,
+    );
+  }
+
+  return {
+    schemaVersion: 1,
+    planPath,
+    passed: errors.length === 0,
+    legacyMode: false,
+    errors,
+    warnings,
+    metrics: {
+      slideCount: slides.length,
+      sourceUnitCount: unitById.size,
+      coveredSourceUnitCount: [...coveredUnitIds].filter((id) => unitById.has(id))
+        .length,
+      mappedSourceUnitCount: [...mappedUnitIds].filter((id) => unitById.has(id))
+        .length,
+      visiblyCoveredSourceUnitCount: [...visibleTraceUnitIds].filter((id) =>
+        unitById.has(id),
+      ).length,
+      notesCoveredSourceUnitCount: [...notesTraceUnitIds].filter((id) =>
+        unitById.has(id),
+      ).length,
+      criticalCoverage,
+      weightedCoverage,
+      criticalVisibleCoverage,
+      weightedVisibleCoverage,
+      sourceTextCoverage,
+      totalVisibleChars,
+      totalSpeakerNotesChars,
+      totalEstimatedSeconds,
+      coreEstimatedSeconds,
+      auditedDuration,
+      durationScope:
+        String(policy.durationScope || "").toLowerCase() === "core-only"
+          ? "core-only"
+          : "all-slides",
+      slideMetrics,
+    },
+  };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+  const planPath = path.resolve(requireArg(args, "content-plan"));
+  const contentPlan = await readJson(planPath);
+  const report = auditContentPlan(contentPlan, { planPath });
+  if (args.report) {
+    await writeJson(path.resolve(args.report), report);
+  }
+  console.log(JSON.stringify(report, null, 2));
+  if (!report.passed) process.exitCode = 2;
+}
+
+const isMain =
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+if (isMain) {
+  main().catch((error) => {
+    console.error(error.stack || error.message || String(error));
+    console.error(usage());
+    process.exit(1);
+  });
+}

package/src/core/frame-map.mjs

@@ -0,0 +1,91 @@
+import path from "node:path";
+
+import { fingerprint } from "./io.mjs";
+
+export function buildFrameMap(contentPlan, templateProfile, options = {}) {
+  const bySlide = new Map(
+    (templateProfile.slides || []).map((slide) => [
+      Number(slide.sourceSlide),
+      slide,
+    ]),
+  );
+  const outputSlides = (contentPlan.slides || []).map((planned, index) => {
+    const sourceSlide = Number(planned.sourceSlide);
+    const recipe = bySlide.get(sourceSlide);
+    if (!recipe) {
+      throw new Error(`Content plan references unknown source slide ${sourceSlide}`);
+    }
+    if (recipe.safetyStatus !== "automatic") {
+      throw new Error(
+        `Source slide ${sourceSlide} is not approved for automatic editing`,
+      );
+    }
+    const editTargets = [];
+    for (const [slotId, value] of Object.entries(planned.fields || {})) {
+      const slot = (recipe.slotSchema || []).find(
+        (candidate) => candidate.slotId === slotId,
+      );
+      if (!slot) throw new Error(`Unknown slot ${slotId} on slide ${sourceSlide}`);
+      const type = slot.type || "text";
+      editTargets.push({
+        slotId,
+        action:
+          type === "text"
+            ? "rewrite"
+            : ["table", "chart"].includes(type)
+              ? "update-data"
+              : "replace",
+        type,
+        semanticType: slot.semanticType || type,
+        sourceShapeId: slot.sourceShapeId,
+        sourceElementName: slot.sourceElementName,
+        sourceBbox: slot.bbox,
+        originalText: slot.sourceText || "",
+        value,
+      });
+    }
+    const requiredSlots = (recipe.slotSchema || []).filter(
+      (slot) => slot.required === true,
+    );
+    const missing = requiredSlots.filter(
+      (slot) => planned.fields?.[slot.slotId] === undefined,
+    );
+    if (missing.length) {
+      throw new Error(
+        `Output slide ${index + 1} is missing required slots: ${missing
+          .map((slot) => slot.slotId)
+          .join(", ")}`,
+      );
+    }
+    return {
+      outputSlide: index + 1,
+      sourceSlide,
+      narrativeRole: planned.narrativeRole,
+      layoutFamily: planned.layoutFamily,
+      sourceUnitIds: planned.sourceUnitIds || [],
+      speakerNotes: planned.speakerNotes || "",
+      estimatedSeconds: Number(planned.estimatedSeconds || 0),
+      editTargets,
+    };
+  });
+  const frameMap = {
+    schemaVersion: 2,
+    template: {
+      path: templateProfile.source.path,
+      sha256: templateProfile.source.sha256,
+      profileFingerprint: templateProfile.profileFingerprint,
+    },
+    contentPlan: options.contentPlanPath
+      ? path.resolve(options.contentPlanPath)
+      : undefined,
+    contentPlanningFingerprint: contentPlan.planningFingerprint,
+    fidelityMode:
+      contentPlan.deckPolicy?.fidelityMode ||
+      (templateProfile.templateKind === "flattened-deck"
+        ? "hybrid-locked"
+        : "exact-native"),
+    outputSlides,
+  };
+  frameMap.frameMapFingerprint = fingerprint(frameMap);
+  return frameMap;
+}

package/src/core/index.mjs

@@ -0,0 +1,38 @@
+export {
+  engineVersion,
+  createSession,
+  inspectSession,
+  submitSemantics,
+  planSession,
+  supplyAssets,
+  generateSession,
+  startGeneration,
+  validateSession,
+  cancelSession,
+  getSessionStatus,
+  engineDoctor,
+} from "./universal-engine.mjs";
+export {
+  resolveEngineHome,
+  resolveLibraryDir,
+  resolveSessionsDir,
+  migrateLegacyCapsules,
+} from "./paths.mjs";
+export { extractSource } from "./source-extractor.mjs";
+export { inspectTemplate } from "./template-inspector.mjs";
+export { importLegacyCapsule } from "./legacy-capsule-import.mjs";
+export { buildFrameMap } from "./frame-map.mjs";
+export { buildAdaptiveContentPlan } from "./adaptive-planner.mjs";
+export { auditContentPlan } from "./content-audit.mjs";
+export {
+  assessTemplateFit,
+  buildTemplateIntelligence,
+} from "./template-intelligence.mjs";
+export { editPptxNative, inspectPptxPackage } from "./ooxml-editor.mjs";
+export {
+  renderPptx,
+  renderPdfPages,
+  rendererDoctor,
+  compareProtectedPng,
+  compareRenderedTextFidelity,
+} from "./renderer.mjs";