@liustack/pptwise 0.22.0

package/dist/chunk-M35M4QUC.js

@@ -0,0 +1,1167 @@
+import {
+  AssetsSchema,
+  BEAT_VALUES,
+  BrandConfigSchema,
+  BrandSchema,
+  CANONICAL_THEME_IDS,
+  CAPACITY,
+  COMPONENT_TYPES,
+  DeckBrandingSchema,
+  LAYOUT_REGISTRY,
+  MetaSchema,
+  NarrativeProfileInputSchema,
+  PptwiseError,
+  PptxIRSchema,
+  STRATEGY_DEFINITIONS,
+  SlideSchema,
+  THEME_LABELS,
+  ThemeSchema,
+  contrastRatio,
+  getInstalledThemeIds,
+  getThemeDefinition,
+  mixHex,
+  normalizeDeckRootAliases,
+  normalizeNarrativeShape,
+  parseTransform,
+  registerTheme,
+  renderSlideSvg,
+  resolveEffectiveLayoutId,
+  resolveNarrative,
+  resolveStyle
+} from "./chunk-WL5KWYKS.js";
+import {
+  getPlatform
+} from "./chunk-VUOLBHD7.js";
+
+// src/version.ts
+var VERSION = "0.22.0";
+
+// src/ir/legacy-v3.ts
+import { z } from "zod";
+var PptxIRV3Schema = z.object({
+  version: z.literal("3").default("3"),
+  filename: z.string().default("presentation"),
+  // Pre-rename field name and axis vocabulary (mode/delivery/audience) —
+  // frozen as of the 0.3.0 release, spec §9.3. Same open-schema/closed-
+  // semantic split `NarrativeProfileInputSchema` documents: the actual
+  // mode/delivery/audience enum closure happened at `resolveScenario`
+  // runtime, not here, even before this rename.
+  scenario: z.union([z.string(), NarrativeProfileInputSchema]).optional(),
+  theme: ThemeSchema.default({ id: "consulting" }),
+  meta: MetaSchema.default({}),
+  assets: AssetsSchema.default({ images: {} }),
+  brand: BrandSchema.optional(),
+  // Optional so a v3 file that already carried the (then-undocumented)
+  // chrome key still parses. migrateIrV3ToV4 rewrites it to branding.
+  chrome: DeckBrandingSchema.optional(),
+  seed: z.number().int().optional(),
+  slides: z.array(SlideSchema)
+}).strict();
+
+// src/ir/migrate.ts
+function migrateChromeToBranding(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return raw;
+  const obj = raw;
+  const hasChrome = Object.hasOwn(obj, "chrome");
+  const hasBranding = Object.hasOwn(obj, "branding");
+  if (hasChrome && hasBranding) {
+    throw new PptwiseError('cannot migrate: both "chrome" and "branding" are present');
+  }
+  if (!hasChrome) return raw;
+  const next = { ...obj, branding: obj.chrome };
+  delete next.chrome;
+  return next;
+}
+function migrateBloomToClassroom(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return raw;
+  const obj = raw;
+  const theme = obj.theme;
+  if (theme === "bloom") {
+    return { ...obj, theme: "classroom" };
+  }
+  if (typeof theme === "object" && theme !== null && !Array.isArray(theme)) {
+    const themeObj = theme;
+    if (themeObj.id === "bloom") {
+      return { ...obj, theme: { ...themeObj, id: "classroom" } };
+    }
+  }
+  return raw;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLogoWallComponent(value) {
+  return isPlainRecord(value) && value.type === "logo_wall";
+}
+function arrayHasLogoWall(components) {
+  return Array.isArray(components) && components.some(isLogoWallComponent);
+}
+function rewriteLogoWallItem(item) {
+  if (!isPlainRecord(item)) return item;
+  const next = { asset_id: item.asset_id };
+  if (Object.hasOwn(item, "label") && item.label !== void 0) next.caption = item.label;
+  return next;
+}
+function rewriteLogoWallComponent(component) {
+  const items = component.items;
+  if (!Array.isArray(items)) {
+    return { type: "image_grid", items };
+  }
+  return { type: "image_grid", items: items.slice(0, 4).map(rewriteLogoWallItem) };
+}
+function rewriteComponentsArray(components) {
+  return components.map((component) => isLogoWallComponent(component) ? rewriteLogoWallComponent(component) : component);
+}
+function migrateLogoWallToImageGrid(raw) {
+  if (!isPlainRecord(raw)) return raw;
+  let next;
+  const take = () => {
+    if (!next) next = { ...raw };
+    return next;
+  };
+  if (arrayHasLogoWall(raw.components)) {
+    take().components = rewriteComponentsArray(raw.components);
+  }
+  if (Array.isArray(raw.slides)) {
+    let slidesChanged = false;
+    const slides = raw.slides.map((slide) => {
+      if (!isPlainRecord(slide) || !arrayHasLogoWall(slide.components)) return slide;
+      slidesChanged = true;
+      return { ...slide, components: rewriteComponentsArray(slide.components) };
+    });
+    if (slidesChanged) take().slides = slides;
+  }
+  return next ?? raw;
+}
+function rewriteBannerHeadingField(obj, key) {
+  if (obj[key] !== "banner-heading") return void 0;
+  return { ...obj, [key]: "two-column" };
+}
+function migrateBannerHeadingToTwoColumn(raw) {
+  if (!isPlainRecord(raw)) return raw;
+  let next;
+  const take = () => {
+    if (!next) next = { ...raw };
+    return next;
+  };
+  const topLayout = rewriteBannerHeadingField(raw, "layout");
+  const topFocus = rewriteBannerHeadingField(topLayout ?? raw, "focus");
+  if (topLayout || topFocus) {
+    const rewritten = topFocus ?? topLayout;
+    Object.assign(take(), rewritten);
+  }
+  if (Array.isArray(raw.slides)) {
+    let slidesChanged = false;
+    const slides = raw.slides.map((slide) => {
+      if (!isPlainRecord(slide)) return slide;
+      const rewritten = rewriteBannerHeadingField(slide, "layout");
+      if (!rewritten) return slide;
+      slidesChanged = true;
+      return rewritten;
+    });
+    if (slidesChanged) take().slides = slides;
+  }
+  if (Array.isArray(raw.pages)) {
+    let pagesChanged = false;
+    const pages = raw.pages.map((page) => {
+      if (!isPlainRecord(page)) return page;
+      const layoutHit = rewriteBannerHeadingField(page, "layout");
+      const focusHit = rewriteBannerHeadingField(layoutHit ?? page, "focus");
+      const rewritten = focusHit ?? layoutHit;
+      if (!rewritten) return page;
+      pagesChanged = true;
+      return rewritten;
+    });
+    if (pagesChanged) take().pages = pages;
+  }
+  return next ?? raw;
+}
+var STRATEGY_VALUE_MIGRATION = { narrative: "storytelling" };
+var PACING_VALUE_MIGRATION = { text: "dense", presentation: "spacious" };
+function migrateNarrativeInput(scenario) {
+  if (scenario === void 0 || typeof scenario === "string") return scenario;
+  const narrative = {};
+  for (const [key, value] of Object.entries(scenario)) {
+    if (key === "mode") {
+      narrative.strategy = typeof value === "string" ? STRATEGY_VALUE_MIGRATION[value] ?? value : value;
+    } else if (key === "delivery") {
+      narrative.pacing = typeof value === "string" ? PACING_VALUE_MIGRATION[value] ?? value : value;
+    } else if (key === "audience") {
+      narrative.audience = value;
+    } else {
+      narrative[key] = value;
+    }
+  }
+  return narrative;
+}
+function migrateIrV3ToV4(v3) {
+  const narrative = migrateNarrativeInput(v3.scenario);
+  const v4 = {
+    version: "4",
+    filename: v3.filename,
+    ...narrative !== void 0 ? { narrative } : {},
+    theme: v3.theme,
+    meta: v3.meta,
+    assets: v3.assets,
+    ...v3.brand !== void 0 ? { brand: v3.brand } : {},
+    ...v3.chrome !== void 0 ? { chrome: v3.chrome } : {},
+    ...v3.seed !== void 0 ? { seed: v3.seed } : {},
+    slides: v3.slides
+  };
+  return migrateBannerHeadingToTwoColumn(
+    migrateLogoWallToImageGrid(migrateBloomToClassroom(migrateChromeToBranding(v4)))
+  );
+}
+
+// src/themes/brand-extract.ts
+import JSZip from "jszip";
+var ACCENT_SLOTS = ["accent1", "accent2", "accent3", "accent4", "accent5", "accent6"];
+var THEME_PART_RE = /theme\d*\.xml$/;
+var THEME_VARIANTS_SEGMENT = "themeVariants";
+var CLR_SCHEME_RE = /<a:clrScheme name="([^"]*)">([\s\S]*?)<\/a:clrScheme>/;
+var CLR_SLOT_RE = /<a:(dk1|lt1|dk2|lt2|accent[1-6]|hlink|folHlink)>\s*<a:(?:srgbClr val="([0-9A-Fa-f]{6})"|sysClr[^>]*lastClr="([0-9A-Fa-f]{6})")/g;
+var FONT_SCHEME_RE = /<a:fontScheme name="([^"]*)">[\s\S]*?<a:majorFont>\s*<a:latin typeface="([^"]*)"[\s\S]*?<a:minorFont>\s*<a:latin typeface="([^"]*)"/;
+async function findThemePart(zip) {
+  const candidates = Object.keys(zip.files).filter((name) => !zip.files[name].dir && THEME_PART_RE.test(name) && !name.includes(THEME_VARIANTS_SEGMENT)).sort((a, b) => a.length - b.length);
+  const path = candidates[0];
+  if (path === void 0) return void 0;
+  const xml = await zip.files[path].async("string");
+  return { path, xml };
+}
+function parseColors(xml) {
+  const match = CLR_SCHEME_RE.exec(xml);
+  if (!match) return { schemeName: void 0, slots: {} };
+  const slots = {};
+  for (const m of match[2].matchAll(CLR_SLOT_RE)) {
+    const slot = m[1];
+    const hex = m[2] ?? m[3];
+    if (hex) slots[slot] = `#${hex.toUpperCase()}`;
+  }
+  return { schemeName: match[1]?.trim() || void 0, slots };
+}
+function parseFonts(xml) {
+  const m = FONT_SCHEME_RE.exec(xml);
+  if (!m) return { major: void 0, minor: void 0 };
+  return { major: m[2]?.trim() || void 0, minor: m[3]?.trim() || void 0 };
+}
+function isDark(hex) {
+  return contrastRatio(hex, "#FFFFFF") > contrastRatio(hex, "#000000");
+}
+function resolveBgText(dk1, lt1) {
+  return isDark(dk1) === isDark(lt1) ? { bg: lt1, text: dk1 } : isDark(dk1) ? { bg: lt1, text: dk1 } : { bg: dk1, text: lt1 };
+}
+var MUTED_STEPS = 20;
+var MUTED_TARGET_RATIO = 4.5;
+function deriveMuted(text, bg, surface) {
+  for (let step = MUTED_STEPS; step >= 0; step--) {
+    const t = step / MUTED_STEPS;
+    const candidate = mixHex(text, bg, t);
+    if (contrastRatio(candidate, bg) >= MUTED_TARGET_RATIO && contrastRatio(candidate, surface) >= MUTED_TARGET_RATIO) {
+      return candidate;
+    }
+  }
+  return text;
+}
+var SERIF_HINTS = [
+  "times",
+  "georgia",
+  "cambria",
+  "garamond",
+  "palatino",
+  "constantia",
+  "book antiqua",
+  "minion",
+  "serif",
+  "cochin",
+  "didot",
+  "baskerville",
+  "sitka",
+  "century",
+  "goudy",
+  "bodoni",
+  "caslon",
+  "perpetua",
+  "rockwell",
+  "playfair"
+];
+function isSerifName(name) {
+  const n = name.toLowerCase();
+  return SERIF_HINTS.some((hint) => n.includes(hint));
+}
+function buildFontStack(extracted) {
+  if (extracted === void 0) return ["Calibri", "Microsoft YaHei", "sans-serif"];
+  return isSerifName(extracted) ? [extracted, "Georgia", "Source Han Serif SC", "serif"] : [extracted, "Calibri", "Microsoft YaHei", "sans-serif"];
+}
+function slugify(input, fallback = "brand") {
+  const slug = input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || fallback;
+}
+async function extractBrandTheme(bytes, opts = {}) {
+  const zip = await JSZip.loadAsync(bytes);
+  const part = await findThemePart(zip);
+  if (!part) {
+    throw new PptwiseError(
+      "no theme part found in this file \u2014 expected a .thmx/.potx/.pptx OOXML package with a ppt/theme/theme1.xml (or theme/theme/theme1.xml) part"
+    );
+  }
+  const { schemeName, slots } = parseColors(part.xml);
+  if (!slots.dk1 || !slots.lt1) {
+    throw new PptwiseError(`theme part ${part.path} is missing dk1/lt1 colors \u2014 cannot derive bg/text tokens`);
+  }
+  const chartPalette = ACCENT_SLOTS.map((slot) => slots[slot]).filter((c) => c !== void 0);
+  if (chartPalette.length === 0) {
+    throw new PptwiseError(`theme part ${part.path} has no accent colors \u2014 cannot derive a chart palette or primary color`);
+  }
+  const { bg, text } = resolveBgText(slots.dk1, slots.lt1);
+  const surface = slots.lt2 ?? bg;
+  const primary = slots.accent1 ?? slots.dk2 ?? chartPalette[0];
+  const accent = slots.accent2 ?? primary;
+  const muted = deriveMuted(text, bg, surface);
+  const fonts = parseFonts(part.xml);
+  const heading = buildFontStack(fonts.major);
+  const body = buildFontStack(fonts.minor ?? fonts.major);
+  const label = opts.label ?? schemeName ?? "brand";
+  const id = opts.id ?? slugify(opts.label ?? schemeName ?? "brand");
+  const style = {
+    id,
+    colors: { bg, surface, primary, accent, text, muted, chartPalette },
+    fonts: { heading, body },
+    defaultBackgrounds: {
+      cover: { kind: "color", value: bg },
+      chapter: { kind: "color", value: bg },
+      content: { kind: "color", value: bg },
+      ending: { kind: "color", value: bg }
+    }
+  };
+  return { id, label, style, brand: {}, tags: [] };
+}
+
+// src/themes/brand-theme-file.ts
+import { z as z2 } from "zod";
+var HexToken = z2.string().regex(/^#[0-9A-Fa-f]{3,8}$/, "expected a hex color like #RRGGBB");
+var BackgroundSpecFileSchema = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("color"), value: HexToken }).strict(),
+  z2.object({
+    kind: z2.literal("gradient"),
+    from: HexToken,
+    to: HexToken,
+    direction: z2.enum(["tb", "lr", "diagonal"]).optional()
+  }).strict(),
+  z2.object({
+    kind: z2.literal("asset"),
+    asset_id: z2.string(),
+    overlay: z2.object({ color: HexToken, opacity: z2.number().min(0).max(1) }).strict().optional(),
+    fit: z2.enum(["cover", "contain"]).optional()
+  }).strict()
+]);
+var StyleTokensFileSchema = z2.object({
+  id: z2.string().min(1),
+  allowCustomBackground: z2.boolean().optional(),
+  colors: z2.object({
+    bg: HexToken,
+    surface: HexToken,
+    panel: HexToken.optional(),
+    primary: HexToken,
+    accent: HexToken,
+    text: HexToken,
+    muted: HexToken,
+    border: HexToken.optional(),
+    chartPalette: z2.array(HexToken).min(1),
+    accentPool: z2.array(HexToken).min(1).optional(),
+    cardStroke: HexToken.optional()
+  }).strict(),
+  fonts: z2.object({
+    heading: z2.array(z2.string()).min(1),
+    body: z2.array(z2.string()).min(1),
+    mono: z2.array(z2.string()).min(1).optional()
+  }).strict(),
+  shape: z2.object({
+    radius: z2.number().min(0).max(32).optional(),
+    gapScale: z2.number().min(0.8).max(1.3).optional(),
+    typeScale: z2.number().min(0.5).max(2).optional()
+  }).strict().optional(),
+  defaultBackgrounds: z2.object({
+    cover: BackgroundSpecFileSchema,
+    chapter: BackgroundSpecFileSchema,
+    content: BackgroundSpecFileSchema,
+    ending: BackgroundSpecFileSchema
+  }).strict()
+}).strict();
+var BrandThemeFileSchema = z2.object({
+  id: z2.string().min(1),
+  label: z2.string().optional(),
+  style: StyleTokensFileSchema,
+  brand: BrandConfigSchema.optional(),
+  tags: z2.array(z2.string()).optional()
+}).strict();
+function parseBrandThemeFile(raw, source) {
+  const r = BrandThemeFileSchema.safeParse(raw);
+  if (!r.success) {
+    const detail = r.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new PptwiseError(`invalid theme file ${source}:
+${detail}`);
+  }
+  return r.data;
+}
+function registerBrandThemeFile(file) {
+  if (CANONICAL_THEME_IDS.includes(file.id)) {
+    throw new PptwiseError(
+      `theme file id "${file.id}" collides with a built-in pptwise theme \u2014 pick a different id (\`pptwise brand extract --id <id>\`, or edit the theme file's own "id" field)`
+    );
+  }
+  if (!getInstalledThemeIds().includes(file.id)) {
+    registerTheme({ id: file.id, style: file.style, brand: file.brand ?? {}, tags: file.tags ?? [] });
+  }
+  return file.id;
+}
+
+// src/spec/index.ts
+import { z as z3 } from "zod";
+var PAGE_TYPES = ["cover", "chapter", "content", "ending"];
+var PageSpecSchema = z3.object({
+  id: z3.string(),
+  type: z3.enum(PAGE_TYPES),
+  heading: z3.string(),
+  /** One of the three beat values, or omitted entirely — an omitted
+   *  beat is never a hard-gate violation on its own (see
+   *  {@link checkBeatRotation}'s policy functions below). It gets
+   *  auto-alternated at assemble time (W5 task 3, not this task — still
+   *  unimplemented as of the P1 variety wave's task 1). Renamed
+   *  from `rhythm` (vocabulary-v4 rename, spec §4.3/§6/§8.1) — same
+   *  three values, same semantics, page-level term only, distinct from
+   *  the deck-level `pacing` axis. A *declared* value here is no longer
+   *  spec-only advisory material (P1 variety wave, task 1): `assembleDeck`
+   *  (`./assemble.ts`) now carries it straight into the IR's own
+   *  `Slide.beat` field, where it combines with a soft selection-weight
+   *  onto layout picking (`Math.max`, not multiplication — see
+   *  `SlideSchema.beat`'s own doc comment, `../ir/index.ts`, and
+   *  `BEAT_TENDENCY_WEIGHT`'s in `../svg/layout-selection.ts` for why) —
+   *  the checks below (rotation shape) and that downstream weighting
+   *  (which layouts a given beat favors) are two independent consumers
+   *  of the same declared value, not two views of one mechanism. */
+  beat: z3.enum(BEAT_VALUES).optional(),
+  /** Optional authoring hint pointing fill/select at a preferred
+   *  component type or layout id — see {@link checkFocusVocabulary}. */
+  focus: z3.string().optional(),
+  /** Free-text content anchor read by the fill step and never validated or
+   *  interpreted here. Assemble also surfaces it as `subheading` on
+   *  boundary pages, which have no page-content field for that line. On a
+   *  filled content page it remains a fill-only authoring hint. */
+  summary: z3.string().optional()
+}).strict();
+var DeckSpecSchema = z3.object({
+  version: z3.literal("1").default("1"),
+  // Same open-schema/closed-semantic split as PptxIRSchema's `narrative`
+  // field — see `NarrativeProfileInputSchema`'s doc comment in `ir/index.ts`
+  // for the full rationale (reused verbatim here, not redefined, so the
+  // two can't drift apart). Field renamed from `scenario` to `narrative`
+  // this task (spec §8.1's `DeckPlan`→`DeckSpec` rename, task 2) — its
+  // *value* was already in the new strategy/pacing vocabulary as of task 1
+  // (vocabulary-v4 rename) — `resolveNarrative` below is what actually
+  // enforces that.
+  narrative: z3.union([z3.string(), NarrativeProfileInputSchema]).optional(),
+  theme: z3.string().optional(),
+  filename: z3.string().optional(),
+  seed: z3.number().int().optional(),
+  meta: MetaSchema.default({}),
+  /** Deck logo placement — reused verbatim from the IR's own `brand` field
+   *  (`BrandSchema`, `../ir`) so the deck spec and IR can't drift apart on
+   *  shape, same pattern as `meta` just above. Unlike `meta`, no
+   *  `.default({})`: IR's own `brand` field is a bare `.optional()` with no
+   *  default either (`undefined` means "no brand", not "an empty brand
+   *  object") — consumed by `Branding` (`src/svg/branding.tsx`) for
+   *  the deck's logo image and corner position. */
+  brand: BrandSchema.optional(),
+  /**
+   * Where the brand footer and logo appear — reused verbatim from the IR's
+   * own `branding` field (`DeckBrandingSchema`, `../ir`) so the spec and IR
+   * cannot drift. Optional, no default: omitted stays unset and assemble
+   * does not write `"cover-only"` into the IR. The renderer treats that
+   * as `"cover-only"`. Omitted by default. Write `"full"` only when every
+   * content page needs the brand footer. `"full"` also paints confidentiality
+   * and date on cover and ending meta rows. Layout `branding: "none"` still
+   * wins at render.
+   */
+  branding: DeckBrandingSchema.optional(),
+  pages: z3.array(PageSpecSchema)
+}).strict();
+function specJsonSchema() {
+  return z3.toJSONSchema(DeckSpecSchema);
+}
+function formatSpecIssues(errors) {
+  return errors.map((e) => e.pageId ? `page "${e.pageId}" \u2014 ${e.path}: ${e.message}` : `${e.path}: ${e.message}`).join("\n");
+}
+function formatInvalidSpecError(errors) {
+  return `invalid spec (${errors.length} issue${errors.length === 1 ? "" : "s"}):
+${formatSpecIssues(errors)}`;
+}
+function resolveSpecThemeId(spec) {
+  return spec.theme ?? "consulting";
+}
+function checkPagesNonEmpty(spec) {
+  if (spec.pages.length > 0) return [];
+  return [{ path: "pages", message: "spec has no pages \u2014 a spec needs at least a cover page and an ending page" }];
+}
+function checkBoundaryTypes(spec) {
+  const { pages } = spec;
+  const errors = [];
+  const first = pages[0];
+  const last = pages[pages.length - 1];
+  if (first.type !== "cover") {
+    errors.push({
+      path: "pages.0.type",
+      pageId: first.id,
+      message: `first page must be type "cover" (got "${first.type}") \u2014 a spec must open with a cover page`
+    });
+  }
+  if (last.type !== "ending") {
+    errors.push({
+      path: `pages.${pages.length - 1}.type`,
+      pageId: last.id,
+      message: `last page must be type "ending" (got "${last.type}") \u2014 a spec must close with an ending page`
+    });
+  }
+  for (let i = 1; i < pages.length - 1; i++) {
+    const page = pages[i];
+    if (page.type === "cover" || page.type === "ending") {
+      errors.push({
+        path: `pages.${i}.type`,
+        pageId: page.id,
+        message: `page "${page.id}" is type "${page.type}", only allowed as the first (cover) or last (ending) page \u2014 use "content" or "chapter" for interior pages`
+      });
+    }
+  }
+  return errors;
+}
+function isUnsafePageId(id) {
+  return id.includes("/") || id.includes("\\") || id === "..";
+}
+function checkPageIds(spec) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Map();
+  spec.pages.forEach((page, i) => {
+    if (page.id.trim() === "") {
+      errors.push({ path: `pages.${i}.id`, message: `page ${i + 1} has an empty id \u2014 every page needs a non-empty, unique id` });
+      return;
+    }
+    if (isUnsafePageId(page.id)) {
+      errors.push({
+        path: `pages.${i}.id`,
+        pageId: page.id,
+        message: `page id "${page.id}" is not a safe file name \u2014 ids used as page/asset file names must not contain path separators or ".."`
+      });
+      return;
+    }
+    const indices = seen.get(page.id);
+    if (indices) indices.push(i);
+    else seen.set(page.id, [i]);
+  });
+  for (const [id, indices] of seen) {
+    if (indices.length < 2) continue;
+    errors.push({
+      path: "pages",
+      pageId: id,
+      message: `duplicate page id "${id}" used by ${indices.length} pages (positions ${indices.map((i) => i + 1).join(", ")}) \u2014 page ids must be unique within a spec`
+    });
+  }
+  return errors;
+}
+var HEADING_MAX_CHARS = CAPACITY.headingMaxChars;
+function specHeadingLength(heading) {
+  return heading.length;
+}
+function checkHeadings(spec) {
+  const errors = [];
+  spec.pages.forEach((page, i) => {
+    if (page.heading.trim() === "") {
+      errors.push({ path: `pages.${i}.heading`, pageId: page.id, message: `page "${page.id}" is missing a required heading` });
+      return;
+    }
+    const length = specHeadingLength(page.heading);
+    if (length > HEADING_MAX_CHARS) {
+      errors.push({
+        path: `pages.${i}.heading`,
+        pageId: page.id,
+        message: `page "${page.id}" heading is ${length} characters, exceeds the ${HEADING_MAX_CHARS}-character limit \u2014 tighten it into a short, assertive phrase`
+      });
+    }
+  });
+  return errors;
+}
+function checkTheme(spec) {
+  const themeId = resolveSpecThemeId(spec);
+  const installed = getInstalledThemeIds();
+  if (installed.includes(themeId)) return [];
+  const message = themeId === "bloom" ? 'theme id "bloom" was removed \u2014 run `pptwise migrate <input> -o <output>` to rewrite it to "classroom"' : `unknown theme "${themeId}" \u2014 available: ${installed.join(", ")} (see \`pptwise themes\`)`;
+  return [{ path: "theme", message }];
+}
+var LAYOUT_IDS = Object.keys(LAYOUT_REGISTRY);
+function checkFocusVocabulary(spec, strategy) {
+  const tendencies = STRATEGY_DEFINITIONS[strategy].tendencies;
+  const errors = [];
+  spec.pages.forEach((page, i) => {
+    if (page.focus === void 0) return;
+    if (page.focus === "logo_wall") {
+      errors.push({
+        path: `pages.${i}.focus`,
+        pageId: page.id,
+        message: 'component type "logo_wall" was removed \u2014 run `pptwise migrate <input> -o <output>` to rewrite it to "image_grid"'
+      });
+      return;
+    }
+    if (page.focus === "banner-heading") {
+      errors.push({
+        path: `pages.${i}.focus`,
+        pageId: page.id,
+        message: 'layout "banner-heading" was removed \u2014 run `pptwise migrate <input> -o <output>` to rewrite it to "two-column"'
+      });
+      return;
+    }
+    if (tendencies.includes(page.focus) || COMPONENT_TYPES.includes(page.focus) || LAYOUT_IDS.includes(page.focus)) {
+      return;
+    }
+    errors.push({
+      path: `pages.${i}.focus`,
+      pageId: page.id,
+      message: `unknown focus "${page.focus}" for strategy "${strategy}" \u2014 expected one of this strategy's tendencies (${tendencies.join(", ")}), a component type (${COMPONENT_TYPES.join(", ")}), or a layout id (${LAYOUT_IDS.join(", ")})`
+    });
+  });
+  return errors;
+}
+function declaredBeatContentPages(spec) {
+  const result = [];
+  spec.pages.forEach((page, index) => {
+    if (page.type === "content" && page.beat !== void 0) {
+      result.push({ index, id: page.id, beat: page.beat });
+    }
+  });
+  return result;
+}
+function checkAlternatePolicy(spec, strategy) {
+  const seq = declaredBeatContentPages(spec);
+  const errors = [];
+  let i = 0;
+  while (i < seq.length) {
+    let j = i + 1;
+    while (j < seq.length && seq[j].beat === seq[i].beat) j++;
+    const runLength = j - i;
+    if (runLength >= 3) {
+      const members = seq.slice(i, j);
+      errors.push({
+        path: "pages",
+        pageId: members[0].id,
+        message: `${runLength} consecutive content pages declare beat "${seq[i].beat}" (${members.map((m) => m.id).join(", ")}) \u2014 strategy "${strategy}" requires beat to alternate, vary at least one of them`
+      });
+    }
+    i = j;
+  }
+  return errors;
+}
+function checkAnchorOpenPolicy(spec, strategy) {
+  const firstContentIndex = spec.pages.findIndex((page) => page.type === "content");
+  if (firstContentIndex === -1) return [];
+  const firstContent = spec.pages[firstContentIndex];
+  if (firstContent.beat === void 0 || firstContent.beat === "anchor") return [];
+  return [
+    {
+      path: `pages.${firstContentIndex}.beat`,
+      pageId: firstContent.id,
+      message: `first content page declares beat "${firstContent.beat}" \u2014 strategy "${strategy}" requires the deck to open its first content page on "anchor" beat when a beat is declared`
+    }
+  ];
+}
+function checkAnchorSparsePolicy(spec, strategy) {
+  const declared = declaredBeatContentPages(spec);
+  if (declared.length === 0) return [];
+  const anchorPages = declared.filter((page) => page.beat === "anchor");
+  if (anchorPages.length / declared.length <= 0.5) return [];
+  const pct = Math.round(anchorPages.length / declared.length * 100);
+  return [
+    {
+      path: "pages",
+      // First offending anchor page, same "representative pageId" shape
+      // checkAlternatePolicy's own issue carries (members[0]!.id there) —
+      // this gate's violation is deck-wide (a ratio, not one page), but a
+      // representative id still gives a CLI/agent caller something to jump
+      // to rather than only a bare "pages" path.
+      pageId: anchorPages[0].id,
+      message: `${anchorPages.length} of ${declared.length} content pages with a declared beat are "anchor" (${pct}%: ${anchorPages.map((page) => page.id).join(", ")}) \u2014 strategy "${strategy}" requires "anchor" to stay a minority of declared beats, vary some to "dense" or "breathing"`
+    }
+  ];
+}
+function checkBeatRotation(spec, strategy) {
+  const policy = STRATEGY_DEFINITIONS[strategy].beatPolicy;
+  switch (policy) {
+    case "uniform-dense":
+    case "repetition-ok":
+      return [];
+    case "alternate":
+      return checkAlternatePolicy(spec, strategy);
+    case "anchor-open":
+      return checkAnchorOpenPolicy(spec, strategy);
+    case "anchor-sparse":
+      return checkAnchorSparsePolicy(spec, strategy);
+    default: {
+      const exhaustive = policy;
+      throw new Error(`unhandled beat policy: ${String(exhaustive)}`);
+    }
+  }
+}
+var SPEC_PAGE_COUNT_RANGE = {
+  dense: { min: 8, max: 30 },
+  balanced: { min: 6, max: 24 },
+  spacious: { min: 4, max: 16 }
+};
+function checkPageCount(spec, pacing) {
+  const { min, max } = SPEC_PAGE_COUNT_RANGE[pacing];
+  const n = spec.pages.length;
+  if (n >= min && n <= max) return [];
+  return [
+    {
+      path: "pages",
+      message: `spec has ${n} pages \u2014 "${pacing}" pacing expects ${min}-${max} pages, change pacing or add/remove pages`
+    }
+  ];
+}
+function pageIdFromRawInput(input, index) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const pages = input.pages;
+  if (!Array.isArray(pages)) return void 0;
+  const page = pages[index];
+  if (typeof page !== "object" || page === null) return void 0;
+  const id = page.id;
+  return typeof id === "string" ? id : void 0;
+}
+function validateSpec(input) {
+  const rootAliasPass = normalizeDeckRootAliases(input);
+  const narrativeShapePass = normalizeNarrativeShape(rootAliasPass.value);
+  const normalizedInput = narrativeShapePass.value;
+  const normalized = [...rootAliasPass.normalized, ...narrativeShapePass.normalized];
+  const withNormalized = (result) => normalized.length > 0 ? { ...result, normalized } : result;
+  const r = DeckSpecSchema.safeParse(normalizedInput);
+  if (!r.success) {
+    const errors = r.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      const m = /^pages\.(\d+)/.exec(path);
+      return { path, message: issue.message, pageId: m ? pageIdFromRawInput(normalizedInput, Number(m[1])) : void 0 };
+    });
+    return withNormalized({ ok: false, errors });
+  }
+  const spec = r.data;
+  const emptyErrors = checkPagesNonEmpty(spec);
+  if (emptyErrors.length > 0) return withNormalized({ ok: false, errors: emptyErrors });
+  const boundaryErrors = checkBoundaryTypes(spec);
+  if (boundaryErrors.length > 0) return withNormalized({ ok: false, errors: boundaryErrors });
+  const idErrors = checkPageIds(spec);
+  if (idErrors.length > 0) return withNormalized({ ok: false, errors: idErrors });
+  const headingErrors = checkHeadings(spec);
+  if (headingErrors.length > 0) return withNormalized({ ok: false, errors: headingErrors });
+  const themeErrors = checkTheme(spec);
+  if (themeErrors.length > 0) return withNormalized({ ok: false, errors: themeErrors });
+  let resolvedAxes;
+  try {
+    resolvedAxes = resolveNarrative(spec.narrative);
+  } catch (err) {
+    if (!(err instanceof PptwiseError)) throw err;
+    return withNormalized({ ok: false, errors: [{ path: "narrative", message: err.message }] });
+  }
+  const beatErrors = checkBeatRotation(spec, resolvedAxes.strategy);
+  if (beatErrors.length > 0) return withNormalized({ ok: false, errors: beatErrors });
+  const focusErrors = checkFocusVocabulary(spec, resolvedAxes.strategy);
+  if (focusErrors.length > 0) return withNormalized({ ok: false, errors: focusErrors });
+  const pageCountErrors = checkPageCount(spec, resolvedAxes.pacing);
+  if (pageCountErrors.length > 0) return withNormalized({ ok: false, errors: pageCountErrors });
+  return withNormalized({ ok: true, spec, errors: [] });
+}
+
+// src/spec/assemble.ts
+function stableHash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = (h << 5) + h + s.charCodeAt(i) | 0;
+  return Math.abs(h);
+}
+function generateSeed(filename, pageIds) {
+  return stableHash([filename ?? "", ...pageIds].join("\n"));
+}
+var LOCKED_KEYS = ["type", "heading"];
+function assembleDeck(spec, pages) {
+  const validated = validateSpec(spec);
+  if (!validated.ok) {
+    throw new PptwiseError(formatInvalidSpecError(validated.errors));
+  }
+  const deckSpec = validated.spec;
+  for (const page of deckSpec.pages) {
+    const raw = pages[page.id];
+    if (raw === void 0) continue;
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      throw new PptwiseError(`page "${page.id}": page content must be an object`);
+    }
+    for (const key of LOCKED_KEYS) {
+      if (Object.hasOwn(raw, key)) {
+        throw new PptwiseError(`page "${page.id}": "${key}" is locked by the spec \u2014 remove it from the page file`);
+      }
+    }
+  }
+  const specIds = new Set(deckSpec.pages.map((page) => page.id));
+  const orphanIds = Object.keys(pages).filter((id) => !specIds.has(id));
+  if (orphanIds.length > 0) {
+    throw new PptwiseError(
+      `orphan page id${orphanIds.length === 1 ? "" : "s"} ${orphanIds.map((id) => `"${id}"`).join(", ")} \u2014 not in the spec, delete the page file or add the page to the spec`
+    );
+  }
+  const slides = deckSpec.pages.map((page) => buildSlide(page, pages[page.id]));
+  const generatedSeed = deckSpec.seed === void 0 ? generateSeed(deckSpec.filename, deckSpec.pages.map((page) => page.id)) : void 0;
+  const seed = deckSpec.seed ?? generatedSeed;
+  const rawIr = {
+    version: "4",
+    ...deckSpec.narrative !== void 0 ? { narrative: deckSpec.narrative } : {},
+    ...deckSpec.theme !== void 0 ? { theme: { id: deckSpec.theme } } : {},
+    ...deckSpec.filename !== void 0 ? { filename: deckSpec.filename } : {},
+    ...deckSpec.brand !== void 0 ? { brand: deckSpec.brand } : {},
+    ...deckSpec.branding !== void 0 ? { branding: deckSpec.branding } : {},
+    meta: deckSpec.meta,
+    seed,
+    slides
+  };
+  const parsed = PptxIRSchema.safeParse(rawIr);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+    throw new PptwiseError(`assembled deck did not produce valid IR:
+${detail}`);
+  }
+  const { ir, materializedCount } = materializeEffectiveLayouts(parsed.data);
+  return {
+    ir,
+    ...generatedSeed !== void 0 ? { generatedSeed } : {},
+    ...materializedCount > 0 ? { materializedLayoutCount: materializedCount } : {}
+  };
+}
+function materializeEffectiveLayouts(ir) {
+  let materializedCount = 0;
+  const slides = ir.slides.map((slide, index) => {
+    if (slide.layout !== void 0) return slide;
+    const effectiveLayoutId = resolveEffectiveLayoutId(ir, slide, index);
+    if (effectiveLayoutId === null) return slide;
+    materializedCount++;
+    return { ...slide, layout: effectiveLayoutId };
+  });
+  return materializedCount === 0 ? { ir, materializedCount } : { ir: { ...ir, slides }, materializedCount };
+}
+function buildSlide(page, raw) {
+  if (raw === void 0) {
+    return {
+      id: page.id,
+      type: page.type,
+      heading: page.heading,
+      placeholder: true,
+      ...page.beat !== void 0 ? { beat: page.beat } : {},
+      ...page.summary !== void 0 ? { subheading: page.summary } : {}
+    };
+  }
+  return {
+    id: page.id,
+    type: page.type,
+    heading: page.heading,
+    ...page.beat !== void 0 ? { beat: page.beat } : {},
+    ...page.type !== "content" && page.summary !== void 0 ? { subheading: page.summary } : {},
+    ...raw.components !== void 0 ? { components: raw.components } : {},
+    ...raw.layout !== void 0 ? { layout: raw.layout } : {},
+    ...raw.arrangement !== void 0 ? { arrangement: raw.arrangement } : {},
+    ...raw.background !== void 0 ? { background: raw.background } : {},
+    ...raw.image_side !== void 0 ? { image_side: raw.image_side } : {},
+    ...raw.footnote !== void 0 ? { footnote: raw.footnote } : {},
+    ...raw.notes !== void 0 ? { notes: raw.notes } : {}
+  };
+}
+var UNTITLED_HEADING = "Untitled";
+function disassembleDeck(ir) {
+  const pages = {};
+  const pageSpecs = ir.slides.map((slide, index) => {
+    const id = slide.id ?? `p-${index + 1}-${slide.type}`;
+    const heading = slide.heading !== void 0 && slide.heading.trim() !== "" ? slide.heading : UNTITLED_HEADING;
+    const pageSpec = {
+      id,
+      type: slide.type,
+      heading,
+      ...slide.beat !== void 0 ? { beat: slide.beat } : {},
+      ...(slide.placeholder === true || slide.type !== "content") && slide.subheading !== void 0 ? { summary: slide.subheading } : {}
+    };
+    if (slide.placeholder !== true) pages[id] = extractPageContent(slide);
+    return pageSpec;
+  });
+  const spec = {
+    version: "1",
+    // `ir.narrative` (v4 field, vocabulary-v4 rename) carries straight into
+    // the deck spec's own `narrative` field — its value is
+    // already in the new strategy/pacing vocabulary, no remapping needed.
+    ...ir.narrative !== void 0 ? { narrative: ir.narrative } : {},
+    theme: ir.theme.id,
+    filename: ir.filename,
+    ...ir.seed !== void 0 ? { seed: ir.seed } : {},
+    ...ir.brand !== void 0 ? { brand: ir.brand } : {},
+    ...ir.branding !== void 0 ? { branding: ir.branding } : {},
+    meta: ir.meta,
+    pages: pageSpecs
+  };
+  return { spec, pages };
+}
+function extractPageContent(slide) {
+  const content = {};
+  if (slide.components.length > 0) content.components = slide.components;
+  if (slide.layout !== void 0) content.layout = slide.layout;
+  if (slide.arrangement !== void 0) content.arrangement = slide.arrangement;
+  if (slide.background !== void 0) content.background = slide.background;
+  if (slide.image_side !== void 0) content.image_side = slide.image_side;
+  if (slide.footnote !== void 0) content.footnote = slide.footnote;
+  if (slide.notes !== void 0) content.notes = slide.notes;
+  return content;
+}
+
+// src/spec/migrate.ts
+function migrateDeckPlanToSpec(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return raw;
+  const { scenario, pages, ...rest } = raw;
+  const result = { ...rest };
+  if (scenario !== void 0) result.narrative = scenario;
+  if (Array.isArray(pages)) {
+    result.pages = pages.map(migratePageRhythmToBeat);
+  } else if (pages !== void 0) {
+    result.pages = pages;
+  }
+  return migrateBannerHeadingToTwoColumn(
+    migrateLogoWallToImageGrid(migrateBloomToClassroom(migrateChromeToBranding(result)))
+  );
+}
+function migratePageRhythmToBeat(page) {
+  if (typeof page !== "object" || page === null || Array.isArray(page)) return page;
+  const { rhythm, ...rest } = page;
+  const next = { ...rest };
+  if (rhythm !== void 0) next.beat = rhythm;
+  return next;
+}
+
+// src/svg/asset-brief.ts
+var DUMMY_PNG_DATA_URI = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
+function extractImageFrames(markup) {
+  const Parser = getPlatform().domParser ?? globalThis.DOMParser;
+  if (!Parser) {
+    throw new Error(
+      'DOMParser unavailable \u2014 in Node, call installNodePlatform() from "@liustack/pptwise/node" first (the pptwise CLI does this automatically)'
+    );
+  }
+  const doc = new Parser().parseFromString(markup, "image/svg+xml");
+  const byAssetId = /* @__PURE__ */ new Map();
+  const visit = (el, ox, oy, os) => {
+    const { dx, dy, scale } = parseTransform(el);
+    const ax = ox + os * dx;
+    const ay = oy + os * dy;
+    const as = os * scale;
+    if (el.tagName.toLowerCase() === "image") {
+      const href = el.getAttribute("href") ?? "";
+      const hashAt = href.indexOf("#");
+      if (hashAt !== -1) {
+        const assetId = href.slice(hashAt + 1);
+        const frame = {
+          x: ax + as * Number(el.getAttribute("x") ?? 0),
+          y: ay + as * Number(el.getAttribute("y") ?? 0),
+          w: as * Number(el.getAttribute("width") ?? 0),
+          h: as * Number(el.getAttribute("height") ?? 0),
+          preserveAspectRatio: el.getAttribute("preserveAspectRatio") ?? "xMidYMid meet"
+        };
+        const list = byAssetId.get(assetId);
+        if (list) list.push(frame);
+        else byAssetId.set(assetId, [frame]);
+      }
+    }
+    for (const child of Array.from(el.children)) visit(child, ax, ay, as);
+  };
+  visit(doc.documentElement, 0, 0, 1);
+  return byAssetId;
+}
+function gcd(a, b) {
+  let x = Math.abs(Math.round(a));
+  let y = Math.abs(Math.round(b));
+  while (y !== 0) [x, y] = [y, x % y];
+  return x || 1;
+}
+function formatAspect(w, h) {
+  if (h <= 0 || w <= 0) return `${w}:${h}`;
+  const ratio = w / h;
+  const TOL = 0.01;
+  for (let d = 1; d <= 12; d++) {
+    const n = Math.round(ratio * d);
+    if (n >= 1 && Math.abs(ratio - n / d) <= TOL) {
+      const g = gcd(n, d);
+      return `${n / g}:${d / g}`;
+    }
+  }
+  return `${ratio.toFixed(2)}:1`;
+}
+function toFrame(raw) {
+  const w = Math.round(raw.w);
+  const h = Math.round(raw.h);
+  return { x: Math.round(raw.x), y: Math.round(raw.y), w, h, aspect: formatAspect(w, h) };
+}
+function buildFit(mode, aspect) {
+  if (mode === "cover") {
+    return {
+      mode,
+      note: aspect ? `Cover crop (xMidYMid slice): generate close to ${aspect} to avoid any crop \u2014 otherwise the renderer center-crops to fill the frame, so keep essential subject matter within the center safe zone.` : `Cover crop (xMidYMid slice): the renderer center-crops to fill the frame \u2014 keep essential subject matter centered.`
+    };
+  }
+  return {
+    mode,
+    note: aspect ? `Contain fit (xMidYMid meet): the renderer letterboxes to show the whole image inside the frame with no crop \u2014 match ${aspect} to avoid empty margins.` : `Contain fit (xMidYMid meet): the renderer letterboxes to show the whole image inside the frame with no crop.`
+  };
+}
+function buildPalette(colors) {
+  const candidates = [colors.bg, colors.surface, colors.panel, colors.primary, colors.accent, colors.text, colors.muted, colors.border];
+  const hexes = [...new Set(candidates.filter((c) => Boolean(c)))];
+  return { hexes, primary: colors.primary, accent: colors.accent };
+}
+function themeLabel(id) {
+  return CANONICAL_THEME_IDS.includes(id) ? THEME_LABELS[id] : id;
+}
+function humanizeMotif(motif) {
+  return motif.replace(/-motif$/, "").replace(/-/g, " ");
+}
+function buildMood(themeId, themeDef) {
+  const label = themeLabel(themeId);
+  const tagPhrase = themeDef.tags.length > 0 ? ` (${themeDef.tags.join(", ")})` : "";
+  const motifPhrase = themeDef.motif ? ` with a ${humanizeMotif(themeDef.motif)} decorative motif` : "";
+  return { tags: themeDef.tags, description: `${label} theme${tagPhrase}${motifPhrase}.` };
+}
+function buildPrompt(mood, palette, frame, fit) {
+  const supporting = palette.hexes.filter((h) => h !== palette.primary && h !== palette.accent);
+  const paletteText = `Color palette: primary ${palette.primary}, accent ${palette.accent}${supporting.length > 0 ? `, supporting tones ${supporting.join(", ")}` : ""}.`;
+  const compositionText = frame ? `Compose for a ${frame.aspect} frame. ${fit.note}` : `Frame geometry unavailable \u2014 this image slot was not rendered under the deck's currently selected layout; generate at a versatile aspect ratio and verify placement once a layout renders it.`;
+  return `${mood.description} ${paletteText} ${compositionText}`;
+}
+function buildAssetBrief(ir) {
+  const themeDef = getThemeDefinition(ir.theme.id);
+  const tokens = resolveStyle(ir.theme.id, ir.theme.style);
+  const palette = buildPalette(tokens.colors);
+  const mood = buildMood(ir.theme.id, themeDef);
+  const occurrences = [];
+  ir.slides.forEach((slide, slideIndex) => {
+    for (const component of slide.components) {
+      if (component.type === "image") occurrences.push({ slideIndex, component });
+    }
+  });
+  const overrides = {};
+  for (const { component } of occurrences) {
+    overrides[component.asset_id] = { src: `${DUMMY_PNG_DATA_URI}#${component.asset_id}` };
+  }
+  const renderIr = { ...ir, assets: { images: { ...ir.assets.images, ...overrides } } };
+  const framesBySlide = /* @__PURE__ */ new Map();
+  for (const slideIndex of new Set(occurrences.map((o) => o.slideIndex))) {
+    framesBySlide.set(slideIndex, extractImageFrames(renderSlideSvg(renderIr, slideIndex)));
+  }
+  const items = [];
+  ir.slides.forEach((slide, slideIndex) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const component of slide.components) {
+      if (component.type !== "image") continue;
+      const list = groups.get(component.asset_id);
+      if (list) list.push(component);
+      else groups.set(component.asset_id, [component]);
+    }
+    if (groups.size === 0) return;
+    const page = { index: slideIndex, id: slide.id, type: slide.type, heading: slide.heading };
+    const frameMap = framesBySlide.get(slideIndex);
+    const isMissing = (assetId) => !ir.assets.images[assetId]?.src;
+    const altOf = (assetId) => ir.assets.images[assetId]?.alt;
+    for (const [assetId, group] of groups) {
+      const frames = frameMap?.get(assetId) ?? [];
+      if (group.length === 1) {
+        const raw = frames[0];
+        const frame = raw ? toFrame(raw) : void 0;
+        const fit = buildFit(group[0].fit, frame?.aspect);
+        items.push({
+          page,
+          asset_id: assetId,
+          alt: altOf(assetId),
+          kind: "image",
+          missing: isMissing(assetId),
+          rendered: frame !== void 0,
+          frame,
+          suggested_pixels: frame ? { w: frame.w * 2, h: frame.h * 2 } : void 0,
+          fit,
+          palette,
+          mood,
+          suggested_prompt: buildPrompt(mood, palette, frame, fit)
+        });
+        continue;
+      }
+      const occurrenceCount = group.length;
+      const sharedFit = group[0].fit;
+      const missing = isMissing(assetId);
+      for (const raw of frames) {
+        const frame = toFrame(raw);
+        const fit = buildFit(sharedFit, frame.aspect);
+        items.push({
+          page,
+          asset_id: assetId,
+          alt: altOf(assetId),
+          kind: "image",
+          missing,
+          rendered: true,
+          frame,
+          suggested_pixels: { w: frame.w * 2, h: frame.h * 2 },
+          fit,
+          palette,
+          mood,
+          shared: true,
+          occurrenceCount,
+          suggested_prompt: buildPrompt(mood, palette, frame, fit)
+        });
+      }
+      for (let i = frames.length; i < occurrenceCount; i++) {
+        const fit = buildFit(sharedFit, void 0);
+        items.push({
+          page,
+          asset_id: assetId,
+          alt: altOf(assetId),
+          kind: "image",
+          missing,
+          rendered: false,
+          fit,
+          palette,
+          mood,
+          shared: true,
+          occurrenceCount,
+          suggested_prompt: buildPrompt(mood, palette, void 0, fit)
+        });
+      }
+    }
+  });
+  return { theme: ir.theme.id, items };
+}
+
+export {
+  VERSION,
+  PptxIRV3Schema,
+  migrateChromeToBranding,
+  migrateBloomToClassroom,
+  migrateLogoWallToImageGrid,
+  migrateBannerHeadingToTwoColumn,
+  migrateIrV3ToV4,
+  slugify,
+  extractBrandTheme,
+  BrandThemeFileSchema,
+  parseBrandThemeFile,
+  registerBrandThemeFile,
+  PageSpecSchema,
+  DeckSpecSchema,
+  specJsonSchema,
+  formatSpecIssues,
+  formatInvalidSpecError,
+  resolveSpecThemeId,
+  SPEC_PAGE_COUNT_RANGE,
+  validateSpec,
+  assembleDeck,
+  disassembleDeck,
+  migrateDeckPlanToSpec,
+  buildAssetBrief
+};
+//# sourceMappingURL=chunk-M35M4QUC.js.map