@field/cascade 0.11.0 → 0.12.0

package/dist/cli/{chunk-WKURDVYP.js → chunk-3RXL5GHB.js}

@@ -5,30 +5,21 @@ import {
   inside,
   playerFile,
   staticRuntimePlugin
-} from "./chunk-3JTJHF7V.js";
+} from "./chunk-OM6BEME6.js";
 import {
   PREFLIGHT_WARNING_CODES,
-  cookProjectGraph,
   createRuntime,
-  installProjectIo,
   moduleId,
   projectModuleFile,
   validateNodeModuleArchitecture
-} from "./chunk-EUIAC3U3.js";
+} from "./chunk-MP653A5O.js";
 import {
   builtinNodeRegistration
-} from "./chunk-36P5K3SD.js";
+} from "./chunk-MI5JLQYA.js";
 import {
   ProjectRoot,
   extractNodeDefinition
-} from "./chunk-RQZ4SX5R.js";
-import {
-  installHeadlessCanvas
-} from "./chunk-WIH4TEIS.js";
-
-// src/cli/editorCommands.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+} from "./chunk-2JEU3MGB.js";
 
 // packages/runtime/src/editor/index.ts
 var SCENE_FORMAT = "cascade.scene";
@@ -335,7 +326,8 @@ async function exportEditor(file, options = {}) {
   const directory = await buildSite(prepared, options.out);
   const plan = JSON.parse(await fs.readFile(path.join(directory, "export-manifest.json"), "utf8"));
   let url;
-  if (options.deploy === "vercel") url = await deployVercel(directory, options.project ?? prepared.plan.editor.id, options.scope, log, options.public === true);
+  if (options.deploy === "vercel")
+    url = (await deployVercel(directory, { project: options.project ?? prepared.plan.editor.id, scope: options.scope, public: options.public === true, log })).deployment;
   return { plan, directory, ...url ? { url } : {} };
 }
 async function prepareExport(file) {
@@ -659,7 +651,7 @@ async function secretValues(projectRoot) {
   values.set("your home directory", os.homedir());
   return [...values];
 }
-async function deployVercel(directory, projectName, scope, log, intendedPublic) {
+var deployVercel = async (directory, { project: projectName, scope, public: intendedPublic, log }) => {
   const team = scope ?? "field-io";
   const scratch = await fs.mkdtemp(path.join(os.tmpdir(), "cascade-vercel-"));
   try {
@@ -671,16 +663,21 @@ async function deployVercel(directory, projectName, scope, log, intendedPublic)
     await fs.rm(scratch, { recursive: true, force: true });
   }
   log(`Deploying ${directory} to Vercel project ${team}/${projectName}\u2026`);
-  const { stdout } = await run("vercel", ["deploy", "--prod", "--yes", "--scope", team], { cwd: directory, maxBuffer: 16 * 1024 * 1024 });
-  const url = stdout.trim().split("\n").reverse().find((line) => /^https:\/\//.test(line.trim()))?.trim();
-  if (!url) throw new Error(`Vercel did not report a deployment URL:
+  const { stdout, stderr } = await run("vercel", ["deploy", "--prod", "--yes", "--scope", team], { cwd: directory, maxBuffer: 16 * 1024 * 1024 });
+  const deployment = stdout.trim().split("\n").reverse().find((line) => /^https:\/\//.test(line.trim()))?.trim();
+  if (!deployment) throw new Error(`Vercel did not report a deployment URL:
 ${stdout}`);
-  const response = await fetch(`https://${projectName}.vercel.app/`, { redirect: "manual" });
+  const url = productionAlias(`${stdout}
+${stderr}`) ?? `https://${projectName}.vercel.app`;
+  const response = await fetch(`${url}/`, { redirect: "manual" });
   const verdict = publicVerdict(response.status, intendedPublic);
-  if (verdict === "public-as-intended") log(`Public, as intended (--public): https://${projectName}.vercel.app`);
+  if (verdict === "public-as-intended") log(`Public, as intended: ${url}`);
   else if (verdict === "public-by-accident")
-    throw new Error(`Deployed, but https://${projectName}.vercel.app is publicly readable. Turn on Vercel Authentication (Settings \u2192 Deployment Protection) for ${team}/${projectName}.`);
-  return url;
+    throw new Error(`Deployed, but ${url} is publicly readable. Turn on Vercel Authentication (Settings \u2192 Deployment Protection) for ${team}/${projectName}.`);
+  return { deployment, url };
+};
+function productionAlias(output) {
+  return /Aliased:?\s+(https:\/\/[^\s[\]]+)/.exec(output)?.[1]?.replace(/\/$/, "");
 }
 function publicVerdict(status, intendedPublic) {
   if (status !== 200) return "protected";
@@ -806,314 +803,14 @@ function formatSize(bytes) {
   return bytes >= 1048576 ? `${(bytes / 1048576).toFixed(1)} MB` : bytes >= 1024 ? `${Math.round(bytes / 1024)} KB` : `${bytes} B`;
 }
 
-// src/cli/editorCommands.ts
-var EDITOR_COMMANDS = ["export", "freeze", "publish", "scene"];
-var EDITOR_HELP = `
-Shareable editors (see doc/EDITOR_EXPORT.md):
-  cascade export <graph> --plan                 Print what would ship, build nothing
-  cascade export <graph> --out <dir> [--deploy vercel [--project <name>] [--scope <team>] [--public]]
-  cascade publish <graph> <node>.<prop> [--id <id>] [--label <text>] [--group <name>]
-                  [--control <kind>] [--min n] [--max n] [--step n] [--help <text>] [--remove]
-  cascade freeze <graph> <node> --fields <a,b.c> [--output <port>] [--personal <a,..>]
-  cascade scene <graph> <scene.json> --out <new-graph.cascade>
-  cascade run <graph> --scene <scene.json> [--write <node>.<port>=<file>]...
-`;
-async function runEditorCommand(args) {
-  const [command, graph] = args;
-  if (!graph || graph.startsWith("-")) throw new Error(`cascade ${command} requires a graph file`);
-  const flags = parseFlags(args.slice(2));
-  switch (command) {
-    case "export":
-      return exportCommand(graph, flags);
-    case "publish":
-      return publishCommand(graph, flags);
-    case "freeze":
-      return freezeCommand(graph, flags);
-    case "scene":
-      return sceneCommand(graph, flags);
-    case "run":
-      return runWithScene(graph, flags);
-    default:
-      throw new Error(`Unknown command ${command}`);
-  }
-}
-var SWITCHES = /* @__PURE__ */ new Set(["--plan", "--remove", "--json", "--public"]);
-function parseFlags(args) {
-  const positional = [];
-  const values = /* @__PURE__ */ new Map();
-  const switches = /* @__PURE__ */ new Set();
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
-    if (!arg.startsWith("--")) {
-      positional.push(arg);
-      continue;
-    }
-    if (SWITCHES.has(arg)) {
-      switches.add(arg);
-      continue;
-    }
-    const value = args[index + 1];
-    if (value === void 0 || value.startsWith("--") && !/^--?\d/.test(value)) throw new Error(`${arg} needs a value`);
-    values.set(arg, [...values.get(arg) ?? [], value]);
-    index++;
-  }
-  return { positional, values, switches };
-}
-var one = (flags, name) => {
-  const list = flags.values.get(name);
-  return list?.[list.length - 1];
-};
-async function exportCommand(graph, flags) {
-  const deploy = one(flags, "--deploy");
-  if (deploy && deploy !== "vercel") throw new Error("--deploy supports vercel only");
-  const result = await exportEditor(graph, {
-    plan: flags.switches.has("--plan"),
-    out: one(flags, "--out"),
-    ...deploy ? { deploy: "vercel" } : {},
-    project: one(flags, "--project"),
-    scope: one(flags, "--scope"),
-    ...flags.switches.has("--public") ? { public: true } : {}
-  });
-  if (flags.switches.has("--json")) console.log(JSON.stringify(result.plan, null, 2));
-  else console.log(formatPlan(result.plan));
-  if (result.directory) console.log(`
-Editor exported: ${result.directory}
-Manifest: ${path2.join(result.directory, "export-manifest.json")}`);
-  if (result.url) console.log(`Deployed: ${result.url}`);
-}
-async function readGraph(file) {
-  return JSON.parse(await fs2.readFile(file, "utf8"));
-}
-async function writeEditor(file, document, editor) {
-  const next = { ...document, editor };
-  await fs2.writeFile(file, `${JSON.stringify(next, null, 2)}
-`);
-}
-async function publishCommand(graph, flags) {
-  const target = flags.positional[0];
-  const match = target ? /^([^.]+)\.(.+)$/.exec(target) : null;
-  if (!match) throw new Error("cascade publish needs <node>.<prop>");
-  const [, node, prop] = match;
-  const document = await readGraph(graph);
-  if (!document.nodes.some((item) => item.id === node)) throw new Error(`No node ${node} in ${graph}`);
-  const editor = document.editor ?? { id: path2.basename(graph).replace(/\.cascade$/, "") };
-  const parameters = [...editor.parameters ?? []];
-  const id = one(flags, "--id") ?? prop;
-  const existing = parameters.findIndex((item) => item.node === node && item.prop === prop);
-  if (flags.switches.has("--remove")) {
-    if (existing < 0) throw new Error(`${node}.${prop} is not published`);
-    parameters.splice(existing, 1);
-    await writeEditor(graph, document, { ...editor, parameters });
-    console.log(`Unpublished ${node}.${prop}`);
-    return;
-  }
-  const number = (name) => {
-    const value = one(flags, name);
-    if (value === void 0) return void 0;
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed)) throw new Error(`${name} must be a number`);
-    return parsed;
-  };
-  const previous = existing >= 0 ? parameters[existing] : void 0;
-  const parameter = {
-    ...previous,
-    id: previous?.id ?? id,
-    node,
-    prop,
-    ...one(flags, "--label") ? { label: one(flags, "--label") } : {},
-    ...one(flags, "--group") ? { group: one(flags, "--group") } : {},
-    ...one(flags, "--control") ? { control: one(flags, "--control") } : {},
-    ...number("--min") !== void 0 ? { min: number("--min") } : {},
-    ...number("--max") !== void 0 ? { max: number("--max") } : {},
-    ...number("--step") !== void 0 ? { step: number("--step") } : {},
-    ...number("--order") !== void 0 ? { order: number("--order") } : {},
-    ...one(flags, "--help") ? { help: one(flags, "--help") } : {},
-    ...one(flags, "--unit") ? { unit: one(flags, "--unit") } : {}
-  };
-  if (existing >= 0) parameters[existing] = parameter;
-  else {
-    if (parameters.some((item) => item.id === parameter.id)) throw new Error(`Parameter id ${parameter.id} is taken; pass --id`);
-    parameters.push(parameter);
-  }
-  await writeEditor(graph, document, { ...editor, parameters });
-  console.log(`${existing >= 0 ? "Updated" : "Published"} ${node}.${prop} as "${parameter.id}"`);
-}
-async function freezeCommand(graph, flags) {
-  const node = flags.positional[0];
-  if (!node) throw new Error("cascade freeze needs a node id");
-  const fields = (one(flags, "--fields") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
-  if (!fields.length) throw new Error("cascade freeze needs --fields: name exactly the values to keep");
-  const personal = (one(flags, "--personal") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
-  const document = await readGraph(graph);
-  if (!document.nodes.some((item) => item.id === node)) throw new Error(`No node ${node} in ${graph}`);
-  const graphFile = path2.resolve(graph);
-  const project = new ProjectRoot(path2.dirname(graphFile));
-  await installHeadlessCanvas().catch(() => void 0);
-  const removeIo = installProjectIo(project);
-  const { outputs } = await cookProjectGraph(graphFile, document, node).finally(removeIo);
-  const produced = outputs.get(node);
-  if (!produced) throw new Error(`${node} produced nothing`);
-  const output = one(flags, "--output") ?? [...produced.keys()][0];
-  if (!produced.has(output)) throw new Error(`${node} has no output ${output}; it has ${[...produced.keys()].join(", ")}`);
-  const full = toJson(produced.get(output));
-  const directory = path2.join("frozen", node);
-  await fs2.mkdir(project.resolve(directory), { recursive: true });
-  const files = [];
-  const pick = async (value) => {
-    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.path === "string") {
-      const from = value.path;
-      const source = project.resolve(from.replace(/^\.\//, ""));
-      const name = `${directory}/${path2.basename(from)}`;
-      await fs2.copyFile(source, project.resolve(name));
-      files.push(name);
-      return { ...value, path: name };
-    }
-    if (Array.isArray(value)) return Promise.all(value.map(pick));
-    if (value && typeof value === "object")
-      return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, item]) => [key, await pick(item)])));
-    return value;
-  };
-  const chosen = {};
-  for (const field of fields) {
-    const value = getPath(full, field);
-    if (value === void 0) throw new Error(`${node}.${output} has no field ${field}`);
-    setPath(chosen, field, await pick(value));
-  }
-  if (fields.includes("path") && typeof chosen.path === "string" && full && typeof full === "object" && !Array.isArray(full)) {
-    const { path: copied } = await pick({ path: chosen.path });
-    chosen.path = copied;
-  }
-  const snapshot = {
-    format: "cascade.frozen",
-    version: 1,
-    node,
-    output,
-    fields,
-    ...personal.length ? { personal } : {},
-    value: chosen,
-    ...files.length ? { files } : {},
-    frozenAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const snapshotFile = `${directory}.json`;
-  await fs2.writeFile(project.resolve(snapshotFile), `${JSON.stringify(snapshot, null, 2)}
-`);
-  const editor = document.editor ?? { id: path2.basename(graph).replace(/\.cascade$/, "") };
-  const freeze = (editor.freeze ?? []).filter((item) => item.node !== node);
-  freeze.push({ node, output, snapshot: snapshotFile });
-  await writeEditor(graph, document, { ...editor, freeze });
-  console.log(`Froze ${node}.${output}: ${fields.join(", ")} \u2192 ${snapshotFile}${files.length ? ` (+${files.length} file${files.length > 1 ? "s" : ""})` : ""}`);
-}
-async function sceneCommand(graph, flags) {
-  const sceneFile = flags.positional[0];
-  const out = one(flags, "--out");
-  if (!sceneFile || !out) throw new Error("cascade scene needs <scene.json> --out <new-graph.cascade>");
-  if (path2.resolve(out) === path2.resolve(graph)) throw new Error("--out must be a new file; the source graph is never overwritten");
-  const { document, warnings } = await sceneDocument(graph, sceneFile);
-  await fs2.writeFile(out, `${JSON.stringify(document, null, 2)}
-`);
-  for (const warning of warnings) console.warn(`Warning: ${warning}`);
-  console.log(`Scene applied: ${out}`);
-}
-async function sceneDocument(graph, sceneFile) {
-  const document = await readGraph(graph);
-  const scene = parseScene(await fs2.readFile(sceneFile, "utf8"));
-  const project = new ProjectRoot(path2.dirname(path2.resolve(graph)));
-  const located = /* @__PURE__ */ new Map();
-  for (const [id, file] of Object.entries(scene.files ?? {})) {
-    const found = await locateSceneFile(project, file);
-    if (found) located.set(id, { path: found, ...file.mediaType ? { mediaType: file.mediaType } : {} });
-  }
-  return applyScene(document, scene, { resolveFile: (parameter) => located.get(parameter.id) });
-}
-async function locateSceneFile(project, file) {
-  const { createHash } = await import("node:crypto");
-  const safe = path2.basename(file.name).replace(/[^A-Za-z0-9._-]/g, "_");
-  if (file.data) {
-    const bytes = fromBase64(file.data);
-    const digest = createHash("sha256").update(bytes).digest("hex");
-    if (digest !== file.sha256) throw new Error(`Scene file ${file.name} does not match its hash`);
-    const name = `assets/scenes/${digest.slice(0, 12)}-${safe}`;
-    await fs2.mkdir(path2.dirname(project.resolve(name)), { recursive: true });
-    await fs2.writeFile(project.resolve(name), bytes);
-    return name;
-  }
-  for (const candidate of await filesNamed(project.root, path2.basename(file.name))) {
-    const digest = createHash("sha256").update(await fs2.readFile(candidate)).digest("hex");
-    if (digest === file.sha256) return path2.relative(project.root, candidate).split(path2.sep).join("/");
-  }
-  return void 0;
-}
-async function filesNamed(root, name) {
-  const found = [];
-  const walk = async (directory, depth) => {
-    if (depth > 6) return;
-    for (const entry of await fs2.readdir(directory, { withFileTypes: true }).catch(() => [])) {
-      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".cascade-cache") continue;
-      const file = path2.join(directory, entry.name);
-      if (entry.isDirectory()) await walk(file, depth + 1);
-      else if (entry.name === name) found.push(file);
-    }
-  };
-  await walk(path2.join(root, "assets"), 0);
-  await walk(path2.join(root, "licensed"), 0);
-  return found;
-}
-async function runWithScene(graph, flags) {
-  const graphFile = path2.resolve(graph);
-  let document = await readGraph(graph);
-  const scene = one(flags, "--scene");
-  if (scene) {
-    const applied = await sceneDocument(graph, scene);
-    document = applied.document;
-    for (const warning of applied.warnings) console.warn(`Warning: ${warning}`);
-  }
-  await installHeadlessCanvas().catch(() => void 0);
-  const project = new ProjectRoot(path2.dirname(graphFile));
-  const removeIo = installProjectIo(project);
-  const { outputs } = await cookProjectGraph(graphFile, document).finally(removeIo);
-  for (const spec of flags.values.get("--write") ?? []) {
-    const match = /^([^.=]+)\.([^=]+)=(.+)$/.exec(spec);
-    if (!match) throw new Error(`--write expects <node>.<port>=<file>, got ${spec}`);
-    const [, node, port, file] = match;
-    const value = outputs.get(node)?.get(port);
-    if (value === void 0) throw new Error(`${node}.${port} produced nothing`);
-    if (typeof value === "string") await fs2.writeFile(file, value);
-    else if (value && typeof value === "object" && typeof value.path === "string")
-      await fs2.copyFile(project.resolve(value.path.replace(/^\.\//, "")), file);
-    else await fs2.writeFile(file, JSON.stringify(toJson(value)));
-    console.log(`Wrote ${node}.${port} \u2192 ${file}`);
-  }
-}
-function toJson(value) {
-  return JSON.parse(JSON.stringify(value, (_key, item) => ArrayBuffer.isView(item) ? Array.from(item) : item) ?? "null");
-}
-function getPath(value, field) {
-  let current = value;
-  for (const part of field.split(".").flatMap((item) => item.split(/\[(\d+)\]/).filter(Boolean))) {
-    if (current === null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-function setPath(target, field, value) {
-  const parts = field.split(".").flatMap((item) => item.split(/\[(\d+)\]/).filter(Boolean));
-  let current = target;
-  parts.forEach((part, index) => {
-    const last = index === parts.length - 1;
-    const container = current;
-    if (last) {
-      container[part] = value;
-      return;
-    }
-    if (container[part] === void 0) container[part] = /^\d+$/.test(parts[index + 1]) ? [] : {};
-    current = container[part];
-  });
-}
-
 export {
-  EDITOR_COMMANDS,
-  EDITOR_HELP,
-  runEditorCommand,
-  sceneDocument
+  parseScene,
+  applyScene,
+  fromBase64,
+  exportEditor,
+  formatPlan,
+  vercelConfig,
+  scanForLeaks,
+  deployVercel
 };
-//# sourceMappingURL=chunk-WKURDVYP.js.map
+//# sourceMappingURL=chunk-3RXL5GHB.js.map

package/dist/cli/chunk-53LGFPWX.js

@@ -0,0 +1,138 @@
+// packages/runtime/src/builtins/image/contactSheet.ts
+function contactSheetLayout(sizes, options = {}) {
+  const count = sizes.length;
+  if (!count) throw new Error("cascade.image.ContactSheet needs at least one image");
+  for (const [width, height] of sizes) {
+    if (!(width > 0 && height > 0)) throw new Error(`cascade.image.ContactSheet: an image is ${width}x${height}`);
+  }
+  const gap = Math.max(0, Math.round(options.gap ?? 16));
+  const columns = Math.min(count, options.columns && options.columns > 0 ? Math.round(options.columns) : Math.ceil(Math.sqrt(count)));
+  const rows = Math.ceil(count / columns);
+  const scaled = Boolean(options.cellWidth && options.cellWidth > 0);
+  const cellWidth = scaled ? Math.round(options.cellWidth) : Math.max(...sizes.map(([width]) => width));
+  const cellHeight = scaled ? Math.max(...sizes.map(([width, height]) => Math.round(height * cellWidth / width))) : Math.max(...sizes.map(([, height]) => height));
+  const labelHeight = Math.max(0, Math.round(options.labelHeight ?? 0));
+  const cells = sizes.map(([width, height], index) => {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const fit = Math.min(cellWidth / width, cellHeight / height);
+    const scale = scaled ? fit : Math.min(1, fit);
+    const drawnWidth = Math.max(1, Math.round(width * scale));
+    const drawnHeight = Math.max(1, Math.round(height * scale));
+    const left = gap + column * (cellWidth + gap);
+    const top = gap + row * (cellHeight + labelHeight + gap);
+    return {
+      x: left + Math.floor((cellWidth - drawnWidth) / 2),
+      y: top + Math.floor((cellHeight - drawnHeight) / 2),
+      width: drawnWidth,
+      height: drawnHeight,
+      labelX: left,
+      labelY: top + cellHeight
+    };
+  });
+  return {
+    width: gap + columns * (cellWidth + gap),
+    height: gap + rows * (cellHeight + labelHeight + gap),
+    columns,
+    rows,
+    cell: [cellWidth, cellHeight],
+    labelHeight,
+    cells
+  };
+}
+function host() {
+  const globals = globalThis;
+  const Canvas = globals.OffscreenCanvas;
+  const createBitmap = globals.createImageBitmap;
+  if (!Canvas || !createBitmap || !globals.Blob) {
+    throw new Error("cascade.image.ContactSheet needs OffscreenCanvas and createImageBitmap, which this host does not provide");
+  }
+  const BlobType = globals.Blob;
+  return {
+    surface: (width, height) => new Canvas(width, height),
+    decode: (bytes) => createBitmap(new BlobType([bytes]))
+  };
+}
+function css(colour, fallback) {
+  const [r = 0, g = 0, b = 0, a = 1] = colour ?? fallback;
+  return `rgba(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)}, ${a})`;
+}
+async function composeContactSheet(images, options = {}) {
+  const canvas = host();
+  const bitmaps = [];
+  try {
+    for (const bytes of images) bitmaps.push(await canvas.decode(bytes));
+    const labels = options.labels ?? [];
+    const labelSize = Math.round(options.labelSize ?? 14);
+    const labelled = labels.some((label) => label.trim().length > 0);
+    const layout = contactSheetLayout(bitmaps.map((bitmap) => [bitmap.width, bitmap.height]), {
+      columns: options.columns,
+      gap: options.gap,
+      cellWidth: options.cellWidth,
+      labelHeight: labelled ? Math.round(labelSize * 1.8) : 0
+    });
+    const surface = canvas.surface(layout.width, layout.height);
+    const context = surface.getContext("2d");
+    if (!context) throw new Error("cascade.image.ContactSheet: no 2D context");
+    context.fillStyle = css(options.background, [1, 1, 1, 1]);
+    context.fillRect(0, 0, layout.width, layout.height);
+    context.imageSmoothingEnabled = true;
+    context.imageSmoothingQuality = "high";
+    layout.cells.forEach((cell, index) => context.drawImage(bitmaps[index], cell.x, cell.y, cell.width, cell.height));
+    if (labelled) {
+      context.fillStyle = css(options.labelColor, [0.1, 0.1, 0.1, 1]);
+      context.font = `${labelSize}px sans-serif`;
+      context.textBaseline = "top";
+      layout.cells.forEach((cell, index) => {
+        const label = labels[index];
+        if (label) context.fillText(label, cell.labelX, cell.labelY + Math.round((layout.labelHeight - labelSize) / 2), layout.cell[0]);
+      });
+    }
+    const blob = await surface.convertToBlob({ type: "image/png" });
+    return { bytes: new Uint8Array(await blob.arrayBuffer()), layout };
+  } finally {
+    for (const bitmap of bitmaps) bitmap.close?.();
+  }
+}
+function imageReference(value) {
+  if (typeof value === "string" && value) return { path: value };
+  const candidate = value?.path;
+  return typeof candidate === "string" && candidate ? { path: candidate } : void 0;
+}
+async function executeContactSheet(context) {
+  const { props } = context;
+  const references = [...context.inputs.images, ...context.inputs.list ?? []].map(imageReference).filter((reference) => reference !== void 0);
+  const bytes = [];
+  for (const reference of references) {
+    bytes.push(await context.capabilities.assets.read(reference, { signal: context.signal }));
+  }
+  const { bytes: sheet, layout } = await composeContactSheet(bytes, {
+    columns: props.columns,
+    gap: props.gap,
+    cellWidth: props.cellWidth,
+    labels: props.labels ? props.labels.split("\n") : [],
+    labelSize: props.labelSize,
+    background: props.background,
+    labelColor: props.labelColor
+  });
+  const asset = await context.capabilities.assets.write(
+    sheet,
+    { mediaType: "image/png", suggestedName: props.filename },
+    { signal: context.signal }
+  );
+  context.outputs.asset.set(asset);
+  context.outputs.image.set({
+    path: asset.path ?? props.filename,
+    size: [layout.width, layout.height],
+    channels: "rgba",
+    depth: "u8",
+    space: "srgb"
+  });
+}
+
+export {
+  contactSheetLayout,
+  composeContactSheet,
+  executeContactSheet
+};
+//# sourceMappingURL=chunk-53LGFPWX.js.map