winter-super-cli 2026.5.26 → 2026.5.28

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

@@ -1,504 +0,0 @@
-import fs from "node:fs/promises";
-import fsSync from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-
-export const DEFAULT_SLIDE_SIZE = { width: 1280, height: 720 };
-const MIN_ARTIFACT_TOOL_VERSION = "2.7.3";
-
-export function parseArgs(argv) {
-  const args = {};
-  for (let index = 0; index < argv.length; index += 1) {
-    const key = argv[index];
-    if (!key.startsWith("--")) {
-      throw new Error(`Unexpected positional argument: ${key}`);
-    }
-    const value = argv[index + 1];
-    if (!value || value.startsWith("--")) {
-      args[key.slice(2)] = true;
-      continue;
-    }
-    args[key.slice(2)] = value;
-    index += 1;
-  }
-  return args;
-}
-
-export function requireArg(args, key) {
-  const value = args[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Missing required --${key}`);
-  }
-  return value;
-}
-
-export function parseSlideSize(value) {
-  if (!value) return DEFAULT_SLIDE_SIZE;
-  const match = String(value).match(/^(\d+)x(\d+)$/);
-  if (!match) {
-    throw new Error(`Expected slide size as WIDTHxHEIGHT, got: ${value}`);
-  }
-  return {
-    width: Number.parseInt(match[1], 10),
-    height: Number.parseInt(match[2], 10),
-  };
-}
-
-export function padSlideNumber(value) {
-  return String(value).padStart(2, "0");
-}
-
-export function slideNumberFromModuleName(filePath) {
-  const base = path.basename(filePath);
-  const match = base.match(/^slide[-_]?(\d+)\.mjs$/i);
-  if (!match) return undefined;
-  return Number.parseInt(match[1], 10);
-}
-
-function defaultRuntimeNodeModules() {
-  return path.join(
-    process.env.HOME || process.cwd(),
-    ".cache",
-    "codex-runtimes",
-    ["codex", "primary", "runtime"].join("-"),
-    "dependencies",
-    "node",
-    "node_modules",
-  );
-}
-
-function packageJsonPath(packageDir) {
-  return path.join(packageDir, "package.json");
-}
-
-function readPackageJson(packageDir) {
-  const packagePath = packageJsonPath(packageDir);
-  if (!fsSync.existsSync(packagePath)) return undefined;
-  try {
-    return JSON.parse(fsSync.readFileSync(packagePath, "utf8"));
-  } catch {
-    return undefined;
-  }
-}
-
-function isNamedPackage(packageDir, packageName) {
-  const packageJson = readPackageJson(packageDir);
-  return packageJson?.name === packageName;
-}
-
-function isSamePackageLocation(targetPackage, sourcePackage) {
-  try {
-    return fsSync.realpathSync(targetPackage) === fsSync.realpathSync(sourcePackage);
-  } catch {
-    return false;
-  }
-}
-
-function isArtifactToolPackage(packageDir) {
-  return isNamedPackage(packageDir, "@oai/artifact-tool");
-}
-
-function artifactToolEntrypointPath(packageDir) {
-  const candidates = [
-    path.join(packageDir, "dist", "node", "artifact_tool.mjs"),
-    path.join(packageDir, "dist", "artifact_tool.mjs"),
-  ];
-  return candidates.find((candidate) => fsSync.existsSync(candidate));
-}
-
-function compareSemver(left, right) {
-  const leftParts = String(left || "0.0.0").split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const rightParts = String(right || "0.0.0").split(".").map((part) => Number.parseInt(part, 10) || 0);
-  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
-    const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
-    if (delta !== 0) return delta;
-  }
-  return 0;
-}
-
-function artifactToolExportPath(packageDir, exportName) {
-  const packageJson = readPackageJson(packageDir);
-  const exportValue = packageJson?.exports?.[exportName];
-  const relativePath =
-    typeof exportValue === "string"
-      ? exportValue
-      : exportValue?.import || exportValue?.default || exportValue?.node;
-  if (!relativePath) return undefined;
-  const resolved = path.join(packageDir, relativePath);
-  return fsSync.existsSync(resolved) ? resolved : undefined;
-}
-
-function validateArtifactToolPresentationJsx(packageDir, context) {
-  const requiredExports = [
-    "./presentation-jsx",
-    "./presentation-jsx/jsx-runtime",
-    "./presentation-jsx/jsx-dev-runtime",
-  ];
-  const missing = requiredExports.filter((exportName) => !artifactToolExportPath(packageDir, exportName));
-  if (missing.length) {
-    throw new Error(
-      [
-        `Expected ${context} to expose artifact-tool presentation JSX exports.`,
-        `Missing exports: ${missing.join(", ")}.`,
-        "Refresh the @oai/artifact-tool runtime bundle before retrying.",
-      ].join("\n"),
-    );
-  }
-}
-
-function validateArtifactToolPackage(packageDir, context) {
-  const packageJson = readPackageJson(packageDir);
-  if (!isArtifactToolPackage(packageDir)) {
-    const found = packageJson ? packageJson.name || "unknown package" : "missing package.json";
-    throw new Error(
-      [
-        `Expected ${context} to point to @oai/artifact-tool.`,
-        `Checked ${packageDir}; found ${found}.`,
-      ].join("\n"),
-    );
-  }
-  if (compareSemver(packageJson.version, MIN_ARTIFACT_TOOL_VERSION) < 0) {
-    throw new Error(
-      [
-        `Expected ${context} to point to @oai/artifact-tool ${MIN_ARTIFACT_TOOL_VERSION} or newer.`,
-        `Checked ${packageDir}; found @oai/artifact-tool@${packageJson.version || "unknown"}.`,
-      ].join("\n"),
-    );
-  }
-  const entrypoint = artifactToolEntrypointPath(packageDir);
-  if (!entrypoint) {
-    throw new Error(
-      [
-        `Expected ${context} to include a built artifact-tool entrypoint.`,
-        `Checked ${path.join(packageDir, "dist", "node", "artifact_tool.mjs")} and ${path.join(packageDir, "dist", "artifact_tool.mjs")}.`,
-        "Build the local artifact-tool bundle before retrying.",
-      ].join("\n"),
-    );
-  }
-  validateArtifactToolPresentationJsx(packageDir, context);
-  return { packageDir: path.resolve(packageDir), entrypoint: path.resolve(entrypoint) };
-}
-
-function findArtifactToolPackage() {
-  return validateArtifactToolPackage(
-    runtimePackagePath("@oai/artifact-tool"),
-    "the bundled Codex runtime @oai/artifact-tool package",
-  );
-}
-
-function runtimePackagePath(packageName) {
-  return path.join(defaultRuntimeNodeModules(), ...packageName.split("/"));
-}
-
-function findOptionalRuntimePackage(packageName) {
-  const runtimePackage = runtimePackagePath(packageName);
-  if (isNamedPackage(runtimePackage, packageName)) {
-    return runtimePackage;
-  }
-  return undefined;
-}
-
-function workspacePackagePath(workspaceDir, packageName) {
-  return path.join(workspaceDir, "node_modules", ...packageName.split("/"));
-}
-
-async function ensureWorkspacePackage(workspaceDir, packageName, sourcePackage) {
-  const target = workspacePackagePath(workspaceDir, packageName);
-  await fs.mkdir(path.dirname(target), { recursive: true });
-
-  const existing = await fs.lstat(target).catch(() => undefined);
-  if (existing) {
-    if (
-      fsSync.existsSync(packageJsonPath(target)) &&
-      isNamedPackage(target, packageName) &&
-      isSamePackageLocation(target, sourcePackage)
-    ) {
-      return target;
-    }
-    if (existing.isSymbolicLink()) {
-      await fs.rm(target, { recursive: true, force: true });
-    } else {
-      throw new Error(`${target} exists but is not ${packageName}.`);
-    }
-  }
-
-  await fs.symlink(sourcePackage, target, process.platform === "win32" ? "junction" : "dir");
-  return target;
-}
-
-async function ensureModulePackage(workspaceDir) {
-  const packagePath = path.join(workspaceDir, "package.json");
-  if (!fsSync.existsSync(packagePath)) {
-    await fs.writeFile(
-      packagePath,
-      `${JSON.stringify({ private: true, type: "module" }, null, 2)}\n`,
-      "utf8",
-    );
-    return;
-  }
-
-  const packageJson = JSON.parse(await fs.readFile(packagePath, "utf8"));
-  if (packageJson.type !== "module") {
-    throw new Error(`${packagePath} exists but does not set "type": "module".`);
-  }
-}
-
-export async function ensureArtifactToolWorkspace(workspaceDir) {
-  const resolvedWorkspace = path.resolve(workspaceDir);
-  await fs.mkdir(resolvedWorkspace, { recursive: true });
-  await ensureModulePackage(resolvedWorkspace);
-
-  const { packageDir: sourcePackage } = findArtifactToolPackage();
-  await ensureWorkspacePackage(resolvedWorkspace, "@oai/artifact-tool", sourcePackage);
-
-  const lucidePackage = findOptionalRuntimePackage("lucide");
-  if (lucidePackage) {
-    await ensureWorkspacePackage(resolvedWorkspace, "lucide", lucidePackage);
-  }
-
-  return { workspaceDir: resolvedWorkspace, packageDir: sourcePackage };
-}
-
-export async function importArtifactTool(workspaceDir) {
-  const { entrypoint } = findArtifactToolPackage();
-  return import(pathToFileURL(entrypoint).href);
-}
-
-export async function importModuleFresh(modulePath) {
-  const resolved = path.resolve(modulePath);
-  const stat = await fs.stat(resolved);
-  return import(`${pathToFileURL(resolved).href}?mtime=${stat.mtimeMs}`);
-}
-
-export function resolveSlideFunction(module, exportName, slideNumber) {
-  const candidates = [];
-  if (exportName) candidates.push(exportName);
-  if (slideNumber !== undefined) {
-    candidates.push(`slide${padSlideNumber(slideNumber)}`, `slide${slideNumber}`);
-  }
-  candidates.push("addSlide", "default");
-
-  for (const candidate of candidates) {
-    if (typeof module[candidate] === "function") {
-      return { name: candidate, fn: module[candidate] };
-    }
-  }
-
-  throw new Error(`Could not find slide function. Tried: ${candidates.join(", ")}`);
-}
-
-export async function readImageBlob(imagePath) {
-  const bytes = await fs.readFile(imagePath);
-  if (!bytes.byteLength) {
-    throw new Error(`Image file is empty: ${imagePath}`);
-  }
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-
-export async function saveBlobToFile(blob, outputPath) {
-  await fs.mkdir(path.dirname(outputPath), { recursive: true });
-  if (blob && typeof blob.arrayBuffer === "function") {
-    await fs.writeFile(outputPath, Buffer.from(await blob.arrayBuffer()));
-    return;
-  }
-  if (blob instanceof Uint8Array || Buffer.isBuffer(blob)) {
-    await fs.writeFile(outputPath, Buffer.from(blob));
-    return;
-  }
-  throw new Error("Expected a Blob or Uint8Array.");
-}
-
-function escapeXmlAttribute(value) {
-  return String(value)
-    .replaceAll("&", "&amp;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;");
-}
-
-function iconNameCandidates(name) {
-  const raw = String(name || "").trim();
-  const pascal = raw
-    .split(/[^a-zA-Z0-9]+/)
-    .filter(Boolean)
-    .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
-    .join("");
-  return [...new Set([raw, raw.replace(/Icon$/, ""), pascal, pascal.replace(/Icon$/, "")].filter(Boolean))];
-}
-
-async function loadLucide(workspaceDir) {
-  const resolverPath = path.join(path.resolve(workspaceDir), "__lucide_resolver__.mjs");
-  const requireFromWorkspace = createRequire(resolverPath);
-  const entrypoint = requireFromWorkspace.resolve("lucide");
-  return import(pathToFileURL(entrypoint).href);
-}
-
-function renderLucideNode(node) {
-  const [tag, attrs = {}, children = []] = node;
-  const renderedAttrs = Object.entries(attrs)
-    .map(([key, value]) => `${key}="${escapeXmlAttribute(value)}"`)
-    .join(" ");
-  const openTag = renderedAttrs ? `<${tag} ${renderedAttrs}` : `<${tag}`;
-  if (!children.length) {
-    return `${openTag}/>`;
-  }
-  return `${openTag}>${children.map(renderLucideNode).join("")}</${tag}>`;
-}
-
-async function lucideSvgDataUrl(workspaceDir, name, options = {}) {
-  const lucide = await loadLucide(workspaceDir);
-  const iconName = iconNameCandidates(name).find((candidate) => lucide.icons?.[candidate] || lucide[candidate]);
-  const iconNode = iconName ? lucide.icons?.[iconName] || lucide[iconName] : undefined;
-  if (!iconNode) {
-    throw new Error(`Lucide icon not found: ${name}`);
-  }
-
-  const {
-    color = "#111827",
-    strokeWidth = 2,
-    width = 24,
-    height = 24,
-    className,
-  } = options;
-  const classAttr = className ? ` class="${escapeXmlAttribute(className)}"` : "";
-  const svg = [
-    `<svg xmlns="http://www.w3.org/2000/svg" width="${escapeXmlAttribute(width)}" height="${escapeXmlAttribute(height)}" viewBox="0 0 24 24" fill="none" stroke="${escapeXmlAttribute(color)}" stroke-width="${escapeXmlAttribute(strokeWidth)}" stroke-linecap="round" stroke-linejoin="round"${classAttr}>`,
-    iconNode.map(renderLucideNode).join(""),
-    "</svg>",
-  ].join("");
-  return `data:image/svg+xml;base64,${Buffer.from(svg, "utf8").toString("base64")}`;
-}
-
-function normalizeFrame(options) {
-  const left = options.left ?? options.x ?? 0;
-  const top = options.top ?? options.y ?? 0;
-  const width = options.width ?? options.w;
-  const height = options.height ?? options.h;
-  if (!Number.isFinite(width) || !Number.isFinite(height)) {
-    throw new Error("Frame requires width and height.");
-  }
-  return { left, top, width, height };
-}
-
-export function createSlideContext(artifact, options = {}) {
-  const slideSize = options.slideSize ?? DEFAULT_SLIDE_SIZE;
-  const transparent = "#00000000";
-
-  const ctx = {
-    W: slideSize.width,
-    H: slideSize.height,
-    slideSize,
-    slideNumber: options.slideNumber,
-    referenceImage: options.referenceImage,
-    outputDir: options.outputDir,
-    assetDir: options.assetDir,
-    workspaceDir: options.workspaceDir,
-    fonts: {
-      title: options.titleFont ?? "Aptos Display",
-      body: options.bodyFont ?? "Aptos",
-      mono: options.monoFont ?? "Aptos Mono",
-    },
-    artifact,
-    readImageBlob,
-    line(fill = transparent, width = 0, style = "solid") {
-      return { style, fill, width };
-    },
-    addShape(slide, optionsForShape) {
-      const {
-        geometry = "rect",
-        fill = transparent,
-        line = { style: "solid", fill: transparent, width: 0 },
-        name,
-        ...frameOptions
-      } = optionsForShape;
-      const shape = slide.shapes.add({
-        geometry,
-        name,
-        position: normalizeFrame(frameOptions),
-        fill,
-        line,
-      });
-      return shape;
-    },
-    addText(slide, optionsForText) {
-      const {
-        text = "",
-        size,
-        fontSize = size ?? 24,
-        color = "#111827",
-        bold = false,
-        face,
-        typeface = face ?? ctx.fonts.body,
-        align = "left",
-        valign = "top",
-        fill = transparent,
-        line = { style: "solid", fill: transparent, width: 0 },
-        insets = { left: 0, right: 0, top: 0, bottom: 0 },
-        name,
-        ...frameOptions
-      } = optionsForText;
-      const shape = ctx.addShape(slide, {
-        ...frameOptions,
-        name,
-        geometry: "rect",
-        fill,
-        line,
-      });
-      shape.text = text;
-      shape.text.fontSize = fontSize;
-      shape.text.color = color;
-      shape.text.bold = Boolean(bold);
-      shape.text.typeface = typeface;
-      shape.text.alignment = align;
-      shape.text.verticalAlignment = valign;
-      shape.text.insets = insets;
-      return shape;
-    },
-    async addImage(slide, optionsForImage) {
-      const {
-        path: imagePath,
-        blob,
-        dataUrl,
-        uri,
-        fit = "cover",
-        alt = "",
-        name,
-        ...frameOptions
-      } = optionsForImage;
-      const source = blob
-        ? { blob }
-        : dataUrl
-          ? { dataUrl }
-          : uri
-            ? { uri }
-            : { blob: await readImageBlob(imagePath) };
-      const image = slide.images.add({ ...source, fit, alt, name });
-      image.position = normalizeFrame(frameOptions);
-      return image;
-    },
-    async addLucideIcon(slide, optionsForIcon) {
-      const {
-        name,
-        icon = name,
-        color = "#111827",
-        strokeWidth = 2,
-        alt,
-        fit = "contain",
-        ...frameOptions
-      } = optionsForIcon;
-      if (!ctx.workspaceDir) {
-        throw new Error("ctx.addLucideIcon requires ctx.workspaceDir.");
-      }
-      return ctx.addImage(slide, {
-        ...frameOptions,
-        dataUrl: await lucideSvgDataUrl(ctx.workspaceDir, icon, { color, strokeWidth }),
-        fit,
-        alt: alt ?? `${icon} icon`,
-        name: frameOptions.name,
-      });
-    },
-  };
-
-  return ctx;
-}

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

@@ -1,209 +0,0 @@
-#!/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 {
-  createSlideContext,
-  ensureArtifactToolWorkspace,
-  importArtifactTool,
-  importModuleFresh,
-  padSlideNumber,
-  parseArgs,
-  parseSlideSize,
-  requireArg,
-  resolveSlideFunction,
-  saveBlobToFile,
-  slideNumberFromModuleName,
-} from "./artifact_tool_utils.mjs";
-
-function usage() {
-  return [
-    "Usage:",
-    "  node scripts/build_artifact_deck.mjs --slides-dir <dir> --out <output.pptx> --preview-dir <dir> [options]",
-    "",
-    "Options:",
-    "  --workspace <dir>           Builder workspace. Defaults to the slides-dir parent.",
-    "  --reference-dir <dir>       Optional directory containing slide-XX.png references.",
-    "  --layout-dir <dir>          Optional layout JSON directory.",
-    "  --contact-sheet <path>      Optional PNG contact sheet path.",
-    "  --manifest <path>           Optional JSON manifest path.",
-    "  --slide-count <n>           Require exactly n slide modules.",
-    "  --slide-size <WxH>          Slide size in pixels. Defaults to 1280x720.",
-    "  --scale <number>            Preview render scale. Defaults to 1.",
-  ].join("\n");
-}
-
-async function discoverSlideModules(slidesDir) {
-  const entries = await fs.readdir(slidesDir);
-  const modules = entries
-    .filter((entry) => /^slide[-_]?\d+\.mjs$/i.test(entry))
-    .map((entry) => {
-      const absolutePath = path.join(slidesDir, entry);
-      return {
-        path: absolutePath,
-        slideNumber: slideNumberFromModuleName(absolutePath),
-      };
-    })
-    .filter((entry) => Number.isInteger(entry.slideNumber))
-    .sort((a, b) => a.slideNumber - b.slideNumber);
-
-  if (modules.length === 0) {
-    throw new Error(`No slide modules found in ${slidesDir}. Expected files like slide-01.mjs.`);
-  }
-
-  return modules;
-}
-
-async function maybeWriteLayout(presentation, slide, layoutPath) {
-  try {
-    const layoutBlob = await presentation.export({ slide, format: "layout" });
-    await fs.mkdir(path.dirname(layoutPath), { recursive: true });
-    await fs.writeFile(layoutPath, await layoutBlob.text(), "utf8");
-    return { layoutPath };
-  } catch (error) {
-    return { layoutError: error.message || String(error) };
-  }
-}
-
-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 slidesDir = path.resolve(requireArg(args, "slides-dir"));
-  const out = path.resolve(requireArg(args, "out"));
-  const previewDir = path.resolve(requireArg(args, "preview-dir"));
-  const workspace = path.resolve(args.workspace || path.dirname(slidesDir));
-  const referenceDir = args["reference-dir"] ? path.resolve(args["reference-dir"]) : undefined;
-  const layoutDir = args["layout-dir"] ? path.resolve(args["layout-dir"]) : undefined;
-  const manifestPath = args.manifest
-    ? path.resolve(args.manifest)
-    : path.join(path.dirname(out), "artifact-build-manifest.json");
-  const contactSheetPath = args["contact-sheet"] ? path.resolve(args["contact-sheet"]) : undefined;
-  const slideSize = parseSlideSize(args["slide-size"]);
-  const scale = args.scale ? Number.parseFloat(args.scale) : 1;
-
-  await ensureArtifactToolWorkspace(workspace);
-  const artifact = await importArtifactTool(workspace);
-  const { Presentation, PresentationFile } = artifact;
-  const modules = await discoverSlideModules(slidesDir);
-
-  if (args["slide-count"] && modules.length !== Number.parseInt(args["slide-count"], 10)) {
-    throw new Error(`Expected ${args["slide-count"]} slide modules, found ${modules.length}.`);
-  }
-
-  const presentation = Presentation.create({ slideSize });
-  const slideRecords = [];
-
-  for (const slideModule of modules) {
-    const module = await importModuleFresh(slideModule.path);
-    const { name: exportName, fn } = resolveSlideFunction(module, undefined, slideModule.slideNumber);
-    const referenceImage = referenceDir
-      ? path.join(referenceDir, `slide-${padSlideNumber(slideModule.slideNumber)}.png`)
-      : undefined;
-    const ctx = createSlideContext(artifact, {
-      slideSize,
-      slideNumber: slideModule.slideNumber,
-      referenceImage,
-      outputDir: path.dirname(out),
-      assetDir: path.join(workspace, "assets"),
-      workspaceDir: workspace,
-    });
-
-    const beforeCount = presentation.slides.count;
-    const returnedSlide = await fn(presentation, ctx);
-    if (presentation.slides.count !== beforeCount + 1) {
-      throw new Error(
-        `${path.basename(slideModule.path)} must add exactly one slide; count changed from ${beforeCount} to ${presentation.slides.count}.`,
-      );
-    }
-    const slide = returnedSlide || presentation.slides.getItem(presentation.slides.count - 1);
-    slideRecords.push({
-      slideNumber: slideModule.slideNumber,
-      modulePath: slideModule.path,
-      exportName,
-      slide,
-    });
-  }
-
-  await fs.mkdir(previewDir, { recursive: true });
-  const previewPaths = [];
-  const layoutResults = [];
-  for (let index = 0; index < slideRecords.length; index += 1) {
-    const record = slideRecords[index];
-    const previewPath = path.join(previewDir, `slide-${padSlideNumber(index + 1)}.png`);
-    const preview = await presentation.export({ slide: record.slide, format: "png", scale });
-    await saveBlobToFile(preview, previewPath);
-    previewPaths.push(previewPath);
-
-    if (layoutDir) {
-      const layoutPath = path.join(layoutDir, `slide-${padSlideNumber(index + 1)}.layout.json`);
-      layoutResults.push(await maybeWriteLayout(presentation, record.slide, 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 deck is empty: ${out}`);
-  }
-
-  const contactSheet = runContactSheet(previewPaths, contactSheetPath);
-  const manifest = {
-    output: out,
-    outputBytes: outputStat.size,
-    slideCount: presentation.slides.count,
-    slideSize,
-    previewDir,
-    previewPaths,
-    layoutDir,
-    layoutResults,
-    contactSheet,
-    slides: slideRecords.map((record, index) => ({
-      index: index + 1,
-      requestedSlideNumber: record.slideNumber,
-      modulePath: record.modulePath,
-      exportName: record.exportName,
-    })),
-  };
-  await fs.mkdir(path.dirname(manifestPath), { recursive: true });
-  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-
-  console.log(JSON.stringify(manifest, null, 2));
-}
-
-main().catch((error) => {
-  console.error(error.stack || error.message || String(error));
-  console.error(usage());
-  process.exit(1);
-});