winter-super-cli 2026.5.15

package/resources/local/codex/plugins/cache/openai-primary-runtime/presentations/26.505.10851/skills/presentations/scripts/inspect_template_deck.mjs

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import {
+  ensureArtifactToolWorkspace,
+  importArtifactTool,
+  parseArgs,
+  requireArg,
+  saveBlobToFile,
+} from "./artifact_tool_utils.mjs";
+
+function usage() {
+  return [
+    "Usage:",
+    "  node scripts/inspect_template_deck.mjs --workspace <dir> --pptx <source.pptx> [options]",
+    "",
+    "Options:",
+    "  --out-dir <dir>   Output directory under workspace. Defaults to <workspace>/template-inspect.",
+    "  --scale <n>       Render scale. Defaults to 1.",
+    "",
+    "Imports a source PPTX with artifact-tool, renders source slide PNGs/layouts,",
+    "extracts package media, scans font names, writes template-inspect.ndjson,",
+    "and writes template-manifest.json.",
+  ].join("\n");
+}
+
+function runCapture(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: options.encoding,
+    maxBuffer: options.maxBuffer || 80 * 1024 * 1024,
+  });
+  if (result.status !== 0) {
+    const stderr = Buffer.isBuffer(result.stderr) ? result.stderr.toString("utf8") : result.stderr;
+    const stdout = Buffer.isBuffer(result.stdout) ? result.stdout.toString("utf8") : result.stdout;
+    throw new Error((stderr || stdout || `${command} ${args.join(" ")} failed`).trim());
+  }
+  return result.stdout;
+}
+
+function isWithin(child, parent) {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function zipNames(pptxPath) {
+  return String(runCapture("unzip", ["-Z1", pptxPath], { encoding: "utf8" }))
+    .split(/\r?\n/)
+    .filter(Boolean);
+}
+
+function readZipText(pptxPath, entryName) {
+  return Buffer.from(runCapture("unzip", ["-p", pptxPath, entryName])).toString("utf8");
+}
+
+async function copyZipEntry(pptxPath, entryName, targetPath) {
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+  await fs.writeFile(targetPath, Buffer.from(runCapture("unzip", ["-p", pptxPath, entryName])));
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function relativeFromWorkspace(workspaceDir, filePath) {
+  return path.relative(workspaceDir, filePath).split(path.sep).join("/");
+}
+
+function collectFonts(pptxPath, names) {
+  const fonts = new Set();
+  for (const name of names) {
+    if (!/^ppt\/(?:slides|slideMasters|slideLayouts|theme)\/.*\.xml$/.test(name) && !/^ppt\/theme\/.*\.xml$/.test(name)) {
+      continue;
+    }
+    const xml = readZipText(pptxPath, name);
+    for (const match of xml.matchAll(/\btypeface="([^"]+)"/g)) fonts.add(match[1]);
+  }
+  return [...fonts].sort();
+}
+
+function slidesFromPresentation(presentation) {
+  if (Array.isArray(presentation.slides?.items)) return presentation.slides.items;
+  if (Number.isInteger(presentation.slides?.count) && typeof presentation.slides.getItem === "function") {
+    return Array.from({ length: presentation.slides.count }, (_, index) => presentation.slides.getItem(index));
+  }
+  throw new Error("Could not enumerate imported presentation slides.");
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+
+  const workspaceDir = path.resolve(requireArg(args, "workspace"));
+  const pptxPath = path.resolve(requireArg(args, "pptx"));
+  const scale = args.scale ? Number.parseFloat(args.scale) : 1;
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new Error("--scale must be a positive number");
+  }
+
+  const outDir = args["out-dir"]
+    ? path.resolve(workspaceDir, args["out-dir"])
+    : path.join(workspaceDir, "template-inspect");
+  if (!isWithin(outDir, workspaceDir)) {
+    throw new Error(`Refusing to write template inspection outside workspace: ${outDir}`);
+  }
+  if (path.resolve(outDir) === workspaceDir) {
+    throw new Error(
+      [
+        `Refusing to use the workspace root as template inspection output: ${outDir}`,
+        "Omit --out-dir or use a dedicated subdirectory such as --out-dir template-inspect.",
+      ].join("\n"),
+    );
+  }
+
+  const sourceStat = await fs.stat(pptxPath).catch(() => undefined);
+  if (!sourceStat?.isFile()) {
+    throw new Error(`Missing source PPTX: ${pptxPath}`);
+  }
+
+  await ensureArtifactToolWorkspace(workspaceDir);
+  const { FileBlob, PresentationFile } = await importArtifactTool(workspaceDir);
+
+  await fs.rm(outDir, { recursive: true, force: true });
+  const slidesDir = path.join(outDir, "source-slides");
+  const layoutsDir = path.join(outDir, "layouts");
+  const mediaDir = path.join(outDir, "assets", "ppt", "media");
+  const inspectPath = path.join(outDir, "template-inspect.ndjson");
+  const manifestPath = path.join(outDir, "template-manifest.json");
+  await fs.mkdir(slidesDir, { recursive: true });
+  await fs.mkdir(layoutsDir, { recursive: true });
+
+  const presentation = await PresentationFile.importPptx(await FileBlob.load(pptxPath));
+  const slides = slidesFromPresentation(presentation);
+  const names = zipNames(pptxPath);
+  const media = names.filter((name) => name.startsWith("ppt/media/"));
+  const slideXmlNames = names.filter((name) => /^ppt\/slides\/slide\d+\.xml$/.test(name));
+  const chartNames = names.filter((name) => /^ppt\/(?:charts|embeddings\/charts)\/chart\d+\.xml$/.test(name));
+
+  const slideArtifacts = [];
+  for (let index = 0; index < slides.length; index += 1) {
+    const slide = slides[index];
+    const slideNumber = index + 1;
+    const padded = String(slideNumber).padStart(2, "0");
+    const pngPath = path.join(slidesDir, `source-slide-${padded}.png`);
+    const layoutPath = path.join(layoutsDir, `source-slide-${padded}.layout.json`);
+
+    const preview = await presentation.export({ slide, format: "png", scale });
+    await saveBlobToFile(preview, pngPath);
+
+    const layout = await presentation.export({ slide, format: "layout" });
+    await saveBlobToFile(layout, layoutPath);
+
+    slideArtifacts.push({
+      slide: slideNumber,
+      previewPath: pngPath,
+      previewRelativePath: relativeFromWorkspace(workspaceDir, pngPath),
+      layoutPath,
+      layoutRelativePath: relativeFromWorkspace(workspaceDir, layoutPath),
+    });
+  }
+
+  const extractedMedia = [];
+  for (const entry of media) {
+    const target = path.join(mediaDir, path.basename(entry));
+    await copyZipEntry(pptxPath, entry, target);
+    const stat = await fs.stat(target);
+    extractedMedia.push({
+      entry,
+      path: target,
+      relativePath: relativeFromWorkspace(workspaceDir, target),
+      bytes: stat.size,
+    });
+  }
+
+  const inspect = await presentation.inspect({
+    kind: "slide,textbox,shape,image,table,chart",
+    max_chars: 200000,
+  });
+  await fs.writeFile(inspectPath, inspect.ndjson || "", "utf8");
+
+  const tableSlideCount = slideXmlNames.filter((name) => readZipText(pptxPath, name).includes("<a:tbl>")).length;
+  const manifest = {
+    sourcePptx: pptxPath,
+    workspace: workspaceDir,
+    outDir,
+    generatedAt: new Date().toISOString(),
+    slideCount: slides.length,
+    slideArtifacts,
+    inspectPath,
+    inspectRelativePath: relativeFromWorkspace(workspaceDir, inspectPath),
+    inspectTruncated: Boolean(inspect.truncated),
+    inspectMetadata: inspect.metadata || {},
+    extractedMedia,
+    fonts: collectFonts(pptxPath, names),
+    packageParts: {
+      mediaCount: media.length,
+      slideXmlCount: slideXmlNames.length,
+      chartCount: chartNames.length,
+      tableSlideCount,
+    },
+  };
+  await writeJson(manifestPath, manifest);
+  console.log(manifestPath);
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  console.error(usage());
+  process.exit(1);
+});

package/resources/local/codex/plugins/cache/openai-primary-runtime/presentations/26.505.10851/skills/presentations/scripts/make_contact_sheet.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import math
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("images", nargs="+", help="Preview images to include.")
+    parser.add_argument("--output", required=True, help="Output PNG path.")
+    parser.add_argument("--cols", type=int, default=3)
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    image_paths = [Path(value).expanduser().resolve() for value in args.images]
+    for image_path in image_paths:
+        if not image_path.exists():
+            raise FileNotFoundError(image_path)
+
+    thumbs = [Image.open(path).convert("RGB") for path in image_paths]
+    tile_w = max(image.width for image in thumbs)
+    tile_h = max(image.height for image in thumbs)
+    label_h = 48
+    pad = 18
+    cols = max(1, args.cols)
+    rows = math.ceil(len(thumbs) / cols)
+
+    sheet = Image.new(
+        "RGB",
+        (cols * tile_w + (cols + 1) * pad, rows * (tile_h + label_h) + (rows + 1) * pad),
+        "white",
+    )
+    draw = ImageDraw.Draw(sheet)
+
+    for idx, image in enumerate(thumbs):
+        row, col = divmod(idx, cols)
+        x = pad + col * (tile_w + pad)
+        y = pad + row * (tile_h + label_h + pad)
+        sheet.paste(image, (x, y))
+        draw.text((x + 8, y + tile_h + 14), f"Slide {idx + 1:02d}", fill=(20, 30, 50))
+        image.close()
+
+    output_path = Path(args.output).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    sheet.save(output_path)
+    print(output_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/local/codex/plugins/cache/openai-primary-runtime/presentations/26.505.10851/skills/presentations/scripts/openai_generate_image.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+Write a Codex imagegen prompt text file for a requested image.
+
+This helper intentionally does not call any network API and does not read API
+keys. The Presentations skill uses Codex's imagegen tool for image creation;
+this script only prepares the prompt and intended output path for the agent.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import datetime
+from pathlib import Path
+
+DEFAULT_OUTPUT_FORMAT = "png"
+DEFAULT_SIZE = "1792x1024"
+DEFAULT_QUALITY = "medium"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Prepare a Codex imagegen prompt text file from a text prompt."
+    )
+    parser.add_argument("prompt", help="Prompt to use with the Codex imagegen tool.")
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Intended generated image path. The script will not create this image.",
+    )
+    parser.add_argument(
+        "--prompt-output",
+        help="Prompt file path. Defaults beside --output, or ./imagegen-prompt-<timestamp>.txt.",
+    )
+    parser.add_argument(
+        "--reference-image",
+        help="Optional reference image path to pass to Codex imagegen.",
+    )
+    parser.add_argument(
+        "--size",
+        default=DEFAULT_SIZE,
+        help=f"Requested image size to include in the prompt note. Default: {DEFAULT_SIZE}",
+    )
+    parser.add_argument(
+        "--quality",
+        default=DEFAULT_QUALITY,
+        help=f"Requested quality to include in the prompt note. Default: {DEFAULT_QUALITY}",
+    )
+    parser.add_argument(
+        "--format",
+        dest="output_format",
+        default=DEFAULT_OUTPUT_FORMAT,
+        help=f"Requested output format to include in the prompt note. Default: {DEFAULT_OUTPUT_FORMAT}",
+    )
+    parser.add_argument(
+        "--background",
+        default="auto",
+        help="Requested background mode to include in the prompt note. Default: auto",
+    )
+    parser.add_argument(
+        "--moderation",
+        default="auto",
+        help="Accepted for compatibility; recorded in the prompt metadata only.",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite the prompt file if it already exists.",
+    )
+    return parser.parse_args()
+
+
+def resolve_reference_image(reference_image: str | None) -> Path | None:
+    if not reference_image:
+        return None
+    image_path = Path(reference_image).expanduser().resolve()
+    if not image_path.exists():
+        raise FileNotFoundError(f"Reference image not found: {image_path}")
+    if not image_path.is_file():
+        raise ValueError(f"Reference image is not a file: {image_path}")
+    return image_path
+
+
+def default_prompt_path(output: str | None) -> Path:
+    if output:
+        output_path = Path(output).expanduser().resolve()
+        return output_path.with_suffix(".imagegen.txt")
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    return Path.cwd() / f"imagegen-prompt-{stamp}.txt"
+
+
+def build_prompt_doc(args: argparse.Namespace, reference_image: Path | None) -> str:
+    intended_output = str(Path(args.output).expanduser().resolve()) if args.output else ""
+    metadata = {
+        "intended_output": intended_output,
+        "reference_image": str(reference_image) if reference_image else "",
+        "size": args.size,
+        "quality": args.quality,
+        "format": args.output_format,
+        "background": args.background,
+        "moderation": args.moderation,
+    }
+    return "\n".join(
+        [
+            "# Codex Imagegen Prompt",
+            "",
+            "Use the Codex imagegen tool with this prompt. Do not call external image APIs from scripts.",
+            "",
+            "```json",
+            json.dumps(metadata, indent=2),
+            "```",
+            "",
+            "## Prompt",
+            "",
+            args.prompt.strip(),
+            "",
+        ]
+    )
+
+
+def main() -> int:
+    args = parse_args()
+    reference_image = resolve_reference_image(args.reference_image)
+    prompt_path = (
+        Path(args.prompt_output).expanduser().resolve()
+        if args.prompt_output
+        else default_prompt_path(args.output)
+    )
+    if prompt_path.exists() and not args.force:
+        raise FileExistsError(f"Prompt file already exists: {prompt_path}")
+    prompt_path.parent.mkdir(parents=True, exist_ok=True)
+    prompt_path.write_text(build_prompt_doc(args, reference_image), encoding="utf-8")
+
+    result = {
+        "prompt_output": str(prompt_path),
+        "intended_output": str(Path(args.output).expanduser().resolve()) if args.output else "",
+        "reference_image": str(reference_image) if reference_image else "",
+        "imagegen_required": True,
+    }
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/local/codex/plugins/cache/openai-primary-runtime/presentations/26.505.10851/skills/presentations/scripts/prepare_template_starter_deck.mjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import {
+  ensureArtifactToolWorkspace,
+  importArtifactTool,
+  padSlideNumber,
+  parseArgs,
+  requireArg,
+  saveBlobToFile,
+} from "./artifact_tool_utils.mjs";
+
+function usage() {
+  return [
+    "Usage:",
+    "  node scripts/prepare_template_starter_deck.mjs --workspace <dir> --pptx <source.pptx> --map <template-frame-map.json> --out <starter.pptx> [options]",
+    "",
+    "Options:",
+    "  --preview-dir <dir>     Render starter slide PNGs. Defaults to <workspace>/template-starter-preview.",
+    "  --layout-dir <dir>      Write starter layout JSON. Defaults to <workspace>/template-starter-layout.",
+    "  --contact-sheet <path>  Optional PNG contact sheet path.",
+    "  --scale <n>            Render scale. Defaults to 1.",
+    "",
+    "Reads template-frame-map.json outputSlides[] and builds an editable starter",
+    "deck by duplicating selected source slides in output order.",
+  ].join("\n");
+}
+
+function isWithin(child, parent) {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function readJson(filePath) {
+  return JSON.parse(await fs.readFile(filePath, "utf8"));
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function relativeFromWorkspace(workspaceDir, filePath) {
+  return path.relative(workspaceDir, filePath).split(path.sep).join("/");
+}
+
+function slidesFromPresentation(presentation) {
+  if (Array.isArray(presentation.slides?.items)) return presentation.slides.items;
+  if (Number.isInteger(presentation.slides?.count) && typeof presentation.slides.getItem === "function") {
+    return Array.from({ length: presentation.slides.count }, (_, index) => presentation.slides.getItem(index));
+  }
+  throw new Error("Could not enumerate imported presentation slides.");
+}
+
+function validateOutputSlides(map, sourceSlideCount) {
+  if (!Array.isArray(map.outputSlides) || map.outputSlides.length === 0) {
+    throw new Error("template-frame-map.json must include a non-empty outputSlides array.");
+  }
+
+  const sorted = [...map.outputSlides].sort((a, b) => a.outputSlide - b.outputSlide);
+  for (let index = 0; index < sorted.length; index += 1) {
+    const entry = sorted[index];
+    const expectedOutputSlide = index + 1;
+    if (!Number.isInteger(entry.outputSlide) || entry.outputSlide !== expectedOutputSlide) {
+      throw new Error(`outputSlides must be sequential from 1; expected outputSlide ${expectedOutputSlide}.`);
+    }
+    if (!Number.isInteger(entry.sourceSlide) || entry.sourceSlide < 1 || entry.sourceSlide > sourceSlideCount) {
+      throw new Error(
+        `outputSlide ${entry.outputSlide} must reference sourceSlide 1-${sourceSlideCount}; got ${entry.sourceSlide}.`,
+      );
+    }
+    if (entry.reuseMode !== "duplicate-slide") {
+      throw new Error(
+        `outputSlide ${entry.outputSlide} must use reuseMode "duplicate-slide"; got ${JSON.stringify(entry.reuseMode)}.`,
+      );
+    }
+    if (typeof entry.narrativeRole !== "string" || entry.narrativeRole.trim().length === 0) {
+      throw new Error(`outputSlide ${entry.outputSlide} must include a non-empty narrativeRole.`);
+    }
+    if (!Array.isArray(entry.editTargets)) {
+      throw new Error(`outputSlide ${entry.outputSlide} must include editTargets as an array.`);
+    }
+  }
+  return sorted;
+}
+
+function runContactSheet(previewPaths, outputPath) {
+  if (!outputPath) return undefined;
+  const scriptPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "make_contact_sheet.py");
+  const python = process.env.PYTHON || "python3";
+  const result = spawnSync(python, [scriptPath, "--output", outputPath, ...previewPaths], { encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(
+      [
+        `Contact sheet generation failed with ${python}.`,
+        result.stdout.trim(),
+        result.stderr.trim(),
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    );
+  }
+  return outputPath;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+
+  const workspaceDir = path.resolve(requireArg(args, "workspace"));
+  const pptxPath = path.resolve(requireArg(args, "pptx"));
+  const mapPath = path.resolve(requireArg(args, "map"));
+  const out = path.resolve(requireArg(args, "out"));
+  const previewDir = args["preview-dir"]
+    ? path.resolve(args["preview-dir"])
+    : path.join(workspaceDir, "template-starter-preview");
+  const layoutDir = args["layout-dir"]
+    ? path.resolve(args["layout-dir"])
+    : path.join(workspaceDir, "template-starter-layout");
+  const contactSheetPath = args["contact-sheet"] ? path.resolve(args["contact-sheet"]) : undefined;
+  const scale = args.scale ? Number.parseFloat(args.scale) : 1;
+
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new Error("--scale must be a positive number");
+  }
+  for (const writePath of [previewDir, layoutDir, contactSheetPath].filter(Boolean)) {
+    if (!isWithin(writePath, workspaceDir)) {
+      throw new Error(`Refusing to write starter artifacts outside workspace: ${writePath}`);
+    }
+  }
+
+  const sourceStat = await fs.stat(pptxPath).catch(() => undefined);
+  if (!sourceStat?.isFile()) {
+    throw new Error(`Missing source PPTX: ${pptxPath}`);
+  }
+
+  await ensureArtifactToolWorkspace(workspaceDir);
+  const { FileBlob, PresentationFile } = await importArtifactTool(workspaceDir);
+  const map = await readJson(mapPath);
+  const presentation = await PresentationFile.importPptx(await FileBlob.load(pptxPath));
+  const sourceSlides = slidesFromPresentation(presentation);
+  const outputSlides = validateOutputSlides(map, sourceSlides.length);
+
+  const originals = [...sourceSlides];
+  const starterSlides = [];
+  for (const entry of outputSlides) {
+    const sourceSlide = originals[entry.sourceSlide - 1];
+    const duplicate = sourceSlide.duplicate();
+    starterSlides.push({ entry, slide: duplicate });
+  }
+
+  for (const slide of originals) {
+    slide.delete();
+  }
+
+  for (let index = 0; index < starterSlides.length; index += 1) {
+    starterSlides[index].slide.moveTo(index);
+  }
+
+  await fs.mkdir(previewDir, { recursive: true });
+  await fs.mkdir(layoutDir, { recursive: true });
+  const previewPaths = [];
+  const layoutPaths = [];
+  for (let index = 0; index < starterSlides.length; index += 1) {
+    const slideNumber = index + 1;
+    const padded = padSlideNumber(slideNumber);
+    const slide = starterSlides[index].slide;
+
+    const previewPath = path.join(previewDir, `starter-slide-${padded}.png`);
+    const preview = await presentation.export({ slide, format: "png", scale });
+    await saveBlobToFile(preview, previewPath);
+    previewPaths.push(previewPath);
+
+    const layoutPath = path.join(layoutDir, `starter-slide-${padded}.layout.json`);
+    const layout = await presentation.export({ slide, format: "layout" });
+    await saveBlobToFile(layout, layoutPath);
+    layoutPaths.push(layoutPath);
+  }
+
+  await fs.mkdir(path.dirname(out), { recursive: true });
+  const pptx = await PresentationFile.exportPptx(presentation);
+  await pptx.save(out);
+  const outputStat = await fs.stat(out);
+  if (outputStat.size <= 0) {
+    throw new Error(`Exported starter deck is empty: ${out}`);
+  }
+
+  const contactSheet = runContactSheet(previewPaths, contactSheetPath);
+  const manifestPath = out.toLowerCase().endsWith(".pptx")
+    ? `${out.slice(0, -5)}.manifest.json`
+    : `${out}.manifest.json`;
+  const manifest = {
+    sourcePptx: pptxPath,
+    mapPath,
+    output: out,
+    outputBytes: outputStat.size,
+    sourceSlideCount: originals.length,
+    slideCount: starterSlides.length,
+    previewDir,
+    layoutDir,
+    contactSheet,
+    slides: starterSlides.map(({ entry }, index) => ({
+      outputSlide: index + 1,
+      sourceSlide: entry.sourceSlide,
+      narrativeRole: entry.narrativeRole,
+      reuseMode: entry.reuseMode,
+      editTargetCount: entry.editTargets.length,
+      previewPath: previewPaths[index],
+      previewRelativePath: relativeFromWorkspace(workspaceDir, previewPaths[index]),
+      layoutPath: layoutPaths[index],
+      layoutRelativePath: relativeFromWorkspace(workspaceDir, layoutPaths[index]),
+    })),
+  };
+  await writeJson(manifestPath, manifest);
+  console.log(JSON.stringify({ ...manifest, manifestPath }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  console.error(usage());
+  process.exit(1);
+});