@field/cascade 0.10.0 → 0.11.0

package/dist/cli/render-YURAPPUI.js

@@ -0,0 +1,436 @@
+import {
+  runGraph
+} from "./chunk-DUIUFVU2.js";
+import "./chunk-4UDFYF5G.js";
+import "./chunk-QBBKRNGY.js";
+import "./chunk-2KXB47FP.js";
+import {
+  parseFrameSpec
+} from "./chunk-BP7UKF36.js";
+import {
+  encodeSequence,
+  frameSequences,
+  hasFfmpeg,
+  timelineFrameSpec
+} from "./chunk-YAT5Y25U.js";
+import {
+  parseEnvArgs
+} from "./chunk-ZL4JTG5Y.js";
+import "./chunk-RUU3YWXU.js";
+import "./chunk-MIIEFUGG.js";
+import "./chunk-WPUDGEFY.js";
+import "./chunk-VVGSLVSF.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-EUIAC3U3.js";
+import "./chunk-36P5K3SD.js";
+import "./chunk-D6BUOHUG.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-35D343DC.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import {
+  DEFAULT_FPS,
+  frameRange
+} from "./chunk-CO22XHNG.js";
+import "./chunk-RQZ4SX5R.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-XWDSKG7N.js";
+import "./chunk-BIJO5OFS.js";
+import "./chunk-WIH4TEIS.js";
+
+// src/cli/render.ts
+import { fork, spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var PREVIEW_SCALE = 0.5;
+function defaultWorkers(cores = os.availableParallelism()) {
+  return Math.max(1, cores - Math.min(4, Math.max(1, Math.round(cores / 4))));
+}
+var RENDER_HELP = `
+cascade render <graph-file> [options]
+
+Render an animation across worker processes, then encode it. Frames are
+written exactly as run --frames writes them, <out>/<node id>.<frame>.<ext>;
+the video goes beside them.
+
+Options:
+  --frames <range>    1-100, 1-100x2, 42, or timeline (default: timeline)
+  --node <id>         Render only this node's output. Repeatable
+  --workers <n>       Worker processes (default: cores minus a few, here ${defaultWorkers()}).
+                      With more than one, the first two frames are rendered
+                      alone first, and a node writing both to one fixed file
+                      stops the render: parallel workers would overwrite it
+  --final             Full-size H.264 <node>.mp4 instead of the half-size
+                      <node>.preview.mp4
+  --prores            Also a full-size ProRes master <node>.mov (4444 when the
+                      frames have alpha, else 422 HQ); implies --final
+  --no-video          Frames only
+  --crf <n>           H.264 quality, 0-51, lower is better (default 18)
+  --out <dir>         Sequence directory, project-relative (default: renders)
+  --fps <number>      Frame rate to evaluate at and play at
+  --seed <n>          Cook with this graph seed
+  --fresh             Cook every node on every frame
+  --progress <n>      A progress line every n frames (default: about 20 lines)
+  --job <id>          Note progress on this Cairn job (default: $CAIRN_JOB),
+                      with cairn jobs update <id> --note
+  --env NAME=value    Set a variable in every worker and its Python stages. Repeatable
+  --json              Print the result as JSON; progress goes to stderr
+  --verbose, -v       Every frame, and the workers' own output
+`;
+function parseRenderArgs(args) {
+  const file = args[0];
+  if (!file || file.startsWith("-")) throw new Error("cascade render requires a graph file");
+  const options = { file };
+  const nodes = [];
+  const value = (index, flag) => {
+    const next = args[index + 1];
+    if (next === void 0 || next.startsWith("--")) throw new Error(`${flag} needs a value`);
+    return next;
+  };
+  const integer = (text, flag, min, max = Number.MAX_SAFE_INTEGER) => {
+    const number = Number(text);
+    if (!Number.isInteger(number) || number < min || number > max) throw new Error(`${flag} must be an integer from ${min}${max === Number.MAX_SAFE_INTEGER ? " up" : ` to ${max}`} (got "${text}")`);
+    return number;
+  };
+  for (let index = 1; index < args.length; index += 1) {
+    const flag = args[index];
+    switch (flag) {
+      case "--frames":
+        options.frames = value(index, flag);
+        index += 1;
+        break;
+      case "--node":
+        nodes.push(value(index, flag));
+        index += 1;
+        break;
+      case "--workers":
+        options.workers = integer(value(index, flag), flag, 1);
+        index += 1;
+        break;
+      case "--final":
+        options.final = true;
+        break;
+      case "--prores":
+        options.prores = true;
+        options.final = true;
+        break;
+      case "--no-video":
+        options.video = false;
+        break;
+      case "--crf":
+        options.crf = integer(value(index, flag), flag, 0, 51);
+        index += 1;
+        break;
+      case "--out":
+        options.out = value(index, flag);
+        index += 1;
+        break;
+      case "--fps": {
+        const fps = Number(value(index, flag));
+        if (!Number.isFinite(fps) || fps <= 0) throw new Error(`--fps must be a positive number (got "${args[index + 1]}")`);
+        options.fps = fps;
+        index += 1;
+        break;
+      }
+      case "--seed":
+        options.seed = integer(value(index, flag), flag, 0, 4294967295);
+        index += 1;
+        break;
+      case "--fresh":
+        options.fresh = true;
+        break;
+      case "--progress":
+        options.progressEvery = integer(value(index, flag), flag, 1);
+        index += 1;
+        break;
+      case "--job":
+        options.job = value(index, flag);
+        index += 1;
+        break;
+      case "--env":
+        options.env = { ...options.env, ...parseEnvArgs(["--env", value(index, flag)]) };
+        index += 1;
+        break;
+      case "--json":
+        options.json = true;
+        break;
+      case "--verbose":
+      case "-v":
+        options.verbose = true;
+        break;
+      default:
+        throw new Error(`Unknown render option: ${flag} (cascade render --help)`);
+    }
+  }
+  if (nodes.length) options.nodes = nodes;
+  if (options.video === false && (options.final || options.crf !== void 0)) {
+    throw new Error("--no-video leaves nothing for --final, --prores or --crf to apply to");
+  }
+  return options;
+}
+function sharedOutputPaths(a, b) {
+  const shared = [];
+  for (const output of a.outputs) {
+    if (b.outputs.some((other) => other.nodeId === output.nodeId && other.source === output.source)) {
+      shared.push({ nodeId: output.nodeId, source: output.source });
+    }
+  }
+  return shared;
+}
+function fixedPathMessage(shared, a, b) {
+  const nodes = shared.map(({ nodeId, source }) => `"${nodeId}" (${source})`).join(", ");
+  return `Cannot render in parallel: ${shared.length === 1 ? "node" : "nodes"} ${nodes} wrote frames ${a} and ${b} to the same file, so workers would overwrite each other's frames and the sequence would silently mix them up. Give the output a per-frame path: put the frame in the file name, or save through saveImage(canvas, cachePath(context.nodeId, ".png")) from cascade/io or the assets capability, which name files by their content. Or render with --workers 1.`;
+}
+function nextBatch(remaining, workers) {
+  const size = Math.max(1, Math.ceil(remaining.length / (2 * workers)));
+  return remaining.splice(0, size);
+}
+function clock(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1e3));
+  const h = Math.floor(seconds / 3600), m = Math.floor(seconds % 3600 / 60), s = seconds % 60;
+  return h ? `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` : `${m}:${String(s).padStart(2, "0")}`;
+}
+function progressLine(done, total, elapsedMs) {
+  const rate = elapsedMs > 0 ? done / (elapsedMs / 1e3) : 0;
+  const eta = rate > 0 ? (total - done) / rate * 1e3 : NaN;
+  const percent = total ? Math.floor(done / total * 100) : 100;
+  return `${done}/${total} frames (${percent}%) \xB7 ${rate.toFixed(1)} fps \xB7 ${clock(elapsedMs)} elapsed \xB7 ` + (done >= total ? "done" : `ETA ${Number.isFinite(eta) ? clock(eta) : "?"}`);
+}
+function cairnNotifier(job, run, warn) {
+  let busy = null;
+  let warned = false;
+  const note = (text, force = false) => {
+    if (!job) return Promise.resolve();
+    if (busy && !force) return busy;
+    const attempt = (busy ?? Promise.resolve()).then(() => run(["jobs", "update", job, "--note", text])).catch((error) => {
+      if (!warned) warn(`Could not note progress on Cairn job ${job}: ${error instanceof Error ? error.message : error}`);
+      warned = true;
+    });
+    busy = attempt.finally(() => {
+      if (busy === attempt) busy = null;
+    });
+    return attempt;
+  };
+  return note;
+}
+function runCairn(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("cairn", args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => code === 0 ? resolve() : reject(new Error(stderr.trim() || `cairn exited ${code}`)));
+  });
+}
+async function renderGraph(options) {
+  const started = performance.now();
+  const log = options.log ?? (options.json ? (line) => {
+    process.stderr.write(`${line}
+`);
+  } : (line) => console.log(line));
+  const file = path.resolve(options.file);
+  const root = path.dirname(file);
+  const document = JSON.parse(await fs.readFile(file, "utf8"));
+  const spec = !options.frames || options.frames === "timeline" ? timelineFrameSpec(document) : parseFrameSpec(options.frames);
+  const all = frameRange(spec.start, spec.end, spec.step ?? 1);
+  const out = options.out ?? "renders";
+  const video = options.video !== false && all.length > 1;
+  if (video && spec.step !== void 0 && spec.step !== 1) {
+    throw new Error("A video needs a contiguous range of whole frames; drop the step or pass --no-video");
+  }
+  if (video && !await hasFfmpeg()) {
+    throw new Error("Encoding the video needs ffmpeg on the PATH (brew install ffmpeg), or pass --no-video for frames only");
+  }
+  const workers = Math.max(1, Math.min(options.workers ?? defaultWorkers(), all.length));
+  const every = options.progressEvery ?? Math.max(1, Math.round(all.length / 20));
+  const job = options.job ?? process.env.CAIRN_JOB ?? void 0;
+  const note = cairnNotifier(job || void 0, options.cairn ?? runCairn, (line) => console.error(line));
+  const what = options.nodes?.length ? options.nodes.join(", ") : path.basename(file);
+  log(`Rendering ${all.length} frames of ${what} on ${workers} ${workers === 1 ? "worker" : "workers"} -> ${out}/`);
+  const workerSpec = {
+    file,
+    range: spec.step === void 0 ? `${spec.start}-${spec.end}` : `${spec.start}-${spec.end}x${spec.step}`,
+    out,
+    ...options.nodes?.length ? { nodes: options.nodes } : {},
+    ...options.fps === void 0 ? {} : { fps: options.fps },
+    ...options.fresh ? { fresh: true } : {},
+    ...options.seed === void 0 ? {} : { seed: options.seed }
+  };
+  const entry = options.workerEntry ?? { script: process.argv[1], execArgv: process.execArgv };
+  const remaining = [...all];
+  const rendered = /* @__PURE__ */ new Map();
+  const probeFrames = workers > 1 ? remaining.splice(0, 2) : [];
+  let probe = Promise.resolve();
+  let passProbe = () => {
+  };
+  if (probeFrames.length === 2) probe = new Promise((resolve) => {
+    passProbe = resolve;
+  });
+  const children = [];
+  let failure = null;
+  const fail = (error) => {
+    if (failure) return;
+    failure = error;
+    for (const child of children) child.kill("SIGTERM");
+    passProbe();
+  };
+  let lastLogged = 0;
+  const onFrame = (frame) => {
+    rendered.set(frame.frame, frame);
+    if (probeFrames.length === 2 && probeFrames.every((value) => rendered.has(value))) {
+      const shared = sharedOutputPaths(rendered.get(probeFrames[0]), rendered.get(probeFrames[1]));
+      if (shared.length) fail(new Error(fixedPathMessage(shared, probeFrames[0], probeFrames[1])));
+      passProbe();
+    }
+    if (failure) return;
+    if (options.verbose) log(`  frame ${frame.frame} (${Math.round(frame.durationMs)} ms)`);
+    if (rendered.size - lastLogged >= every || rendered.size === all.length) {
+      lastLogged = rendered.size;
+      const line = progressLine(rendered.size, all.length, performance.now() - started);
+      log(line);
+      void note(`render ${what}: ${line}`);
+    }
+  };
+  const runWorker = (index) => new Promise((resolve) => {
+    const child = fork(entry.script, ["__render-worker", JSON.stringify(workerSpec)], {
+      execArgv: entry.execArgv,
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      cwd: process.cwd(),
+      env: { ...process.env, ...options.env }
+    });
+    children.push(child);
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      if (options.verbose) process.stderr.write(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = (stderr + chunk).slice(-4e3);
+      if (options.verbose) process.stderr.write(chunk);
+    });
+    let first = true;
+    const send = (message) => {
+      if (child.connected) child.send(message);
+    };
+    child.on("message", async (message) => {
+      if (message.type === "frame") onFrame(message);
+      else if (message.type === "error") fail(new Error(message.message));
+      else if (message.type === "next") {
+        if (index === 0 && first && probeFrames.length) {
+          first = false;
+          send({ type: "frames", frames: probeFrames });
+          return;
+        }
+        first = false;
+        await probe;
+        send({ type: "frames", frames: failure ? [] : nextBatch(remaining, workers) });
+      }
+    });
+    child.on("exit", (code, signal) => {
+      if (code !== 0 && !failure) {
+        const detail = stderr.trim().split("\n").slice(-6).join("\n");
+        fail(new Error(`render worker ${index + 1} ${signal ? `was killed (${signal})` : `exited ${code}`}${detail ? `:
+${detail}` : ""}`));
+      }
+      resolve();
+    });
+  });
+  await Promise.all(Array.from({ length: workers }, (_, index) => runWorker(index)));
+  if (failure) {
+    await note(`render ${what} failed: ${failure.message.split("\n")[0]}`, true);
+    throw failure;
+  }
+  const missing = all.filter((frame) => !rendered.has(frame));
+  if (missing.length) throw new Error(`render finished without ${missing.length} frames (first: ${missing[0]})`);
+  const frames = [...all];
+  const files = frames.flatMap((frame) => rendered.get(frame).outputs.map((output) => output.file));
+  const videos = [];
+  if (video) {
+    const saved = document?.timeline?.fps;
+    const fps = options.fps ?? (typeof saved === "number" && saved > 0 ? saved : DEFAULT_FPS);
+    for (const sequence of frameSequences(files)) {
+      const base = sequence.prefix;
+      const encodes = [
+        options.final || options.prores ? { file: `${base}.mp4`, codec: "h264", scale: 1 } : { file: `${base}.preview.mp4`, codec: "h264", scale: PREVIEW_SCALE },
+        ...options.prores ? [{ file: `${base}.mov`, codec: "prores", scale: 1 }] : []
+      ];
+      for (const encode of encodes) {
+        videos.push(await encodeSequence({
+          root,
+          sequence,
+          frames,
+          fps,
+          ...encode,
+          ...options.crf === void 0 ? {} : { crf: options.crf }
+        }));
+      }
+    }
+  }
+  const durationMs = performance.now() - started;
+  const summary = `Rendered ${frames.length} frames in ${clock(durationMs)} on ${workers} ${workers === 1 ? "worker" : "workers"}` + (videos.length ? `; ${videos.map((item) => item.file).join(", ")}` : "");
+  log(summary);
+  await note(`render ${what}: ${summary}`, true);
+  return { frames, files, workers, durationMs, videos };
+}
+async function runRenderWorker(argument) {
+  if (!process.send) throw new Error("__render-worker is started by cascade render, not by hand");
+  const spec = JSON.parse(argument ?? "");
+  const send = (message) => new Promise((resolve, reject) => {
+    process.send(message, void 0, {}, (error) => error ? reject(error) : resolve());
+  });
+  const request = () => new Promise((resolve) => {
+    const listener = (message) => {
+      if (message?.type !== "frames") return;
+      process.off("message", listener);
+      resolve(message.frames);
+    };
+    process.on("message", listener);
+    void send({ type: "next" });
+  });
+  async function* frames() {
+    for (; ; ) {
+      const batch = await request();
+      if (!batch.length) return;
+      yield* batch;
+    }
+  }
+  try {
+    await runGraph({
+      file: spec.file,
+      frames: spec.range,
+      out: spec.out,
+      ...spec.nodes ? { nodes: spec.nodes } : {},
+      ...spec.fps === void 0 ? {} : { fps: spec.fps },
+      ...spec.fresh ? { fresh: true } : {},
+      ...spec.seed === void 0 ? {} : { seed: spec.seed },
+      worker: { frameSource: frames(), onFrame: (frame) => send({ type: "frame", ...frame }) }
+    });
+  } catch (error) {
+    await send({ type: "error", message: error instanceof Error ? error.message : String(error) }).catch(() => {
+    });
+    process.exitCode = 1;
+  } finally {
+    process.disconnect?.();
+  }
+}
+export {
+  PREVIEW_SCALE,
+  RENDER_HELP,
+  defaultWorkers,
+  fixedPathMessage,
+  nextBatch,
+  parseRenderArgs,
+  progressLine,
+  renderGraph,
+  runRenderWorker,
+  sharedOutputPaths
+};
+//# sourceMappingURL=render-YURAPPUI.js.map

package/dist/cli/runCommand-PI764LEG.js

@@ -0,0 +1,198 @@
+import {
+  parseEnvArgs
+} from "./chunk-ZL4JTG5Y.js";
+
+// src/cli/runCommand.ts
+import * as fs from "fs/promises";
+
+// src/cli/supervise.ts
+import { spawn } from "node:child_process";
+function superviseProcess(command, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "inherit", detached: process.platform !== "win32" });
+    let timedOut = false;
+    let cancelled = false;
+    let grace;
+    const kill = (signal) => {
+      if (!child.pid) return;
+      try {
+        if (process.platform === "win32") child.kill(signal);
+        else process.kill(-child.pid, signal);
+      } catch (error) {
+        if (error.code !== "ESRCH") throw error;
+      }
+    };
+    const cancel = () => {
+      cancelled = true;
+      kill("SIGTERM");
+      grace ??= setTimeout(() => kill("SIGKILL"), 1e3);
+    };
+    process.on("SIGINT", cancel);
+    process.on("SIGTERM", cancel);
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      console.error(`Render timed out after ${timeoutMs} ms`);
+      kill("SIGKILL");
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      clearTimeout(grace);
+      process.off("SIGINT", cancel);
+      process.off("SIGTERM", cancel);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.once("close", (code) => {
+      cleanup();
+      resolve(timedOut ? 124 : cancelled ? 130 : code ?? 1);
+    });
+  });
+}
+
+// src/cli/runCommand.ts
+async function runCommand(args) {
+  const command = args[0];
+  const fileArg = args[1];
+  if (!fileArg) {
+    console.error("Error: Graph file path required");
+    console.error('Run "cascade --help" for usage information');
+    process.exit(1);
+  }
+  try {
+    await fs.access(fileArg);
+  } catch {
+    console.error(`Error: File not found: ${fileArg}`);
+    process.exit(1);
+  }
+  const options = {
+    file: fileArg,
+    validateOnly: command === "validate",
+    strict: args.includes("--strict"),
+    checkOnly: command === "check",
+    inspectOnly: command === "inspect"
+  };
+  const verboseIndex = args.indexOf("--verbose") !== -1 ? args.indexOf("--verbose") : args.indexOf("-v");
+  if (verboseIndex !== -1) {
+    options.verbose = true;
+  }
+  const named = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--node" && args[index + 1]) named.push(args[index + 1]);
+  }
+  if (named.length) options.nodes = named;
+  const outNodes = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== "--out-node") continue;
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+      console.error("Error: --out-node needs a node id");
+      process.exit(1);
+    }
+    outNodes.push(value);
+  }
+  if (outNodes.length) options.outNodes = outNodes;
+  const env = parseEnvArgs(args);
+  if (env) options.env = env;
+  const entryNodeIndex = args.indexOf("--entry-node");
+  if (entryNodeIndex !== -1 && args[entryNodeIndex + 1]) {
+    options.entryNode = args[entryNodeIndex + 1];
+  }
+  const valueOf = (flag) => {
+    const index = args.indexOf(flag);
+    if (index === -1) return void 0;
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+      console.error(`Error: ${flag} needs a value`);
+      process.exit(1);
+    }
+    return value;
+  };
+  const frames = valueOf("--frames");
+  if (frames) options.frames = frames;
+  const fps = valueOf("--fps");
+  if (fps !== void 0) {
+    const rate = Number(fps);
+    if (!Number.isFinite(rate) || rate <= 0) {
+      console.error(`Error: --fps must be a positive number (got "${fps}")`);
+      process.exit(1);
+    }
+    options.fps = rate;
+  }
+  const out = valueOf("--out");
+  if (out) options.out = out;
+  const mp4 = valueOf("--mp4");
+  if (mp4) {
+    if (command !== "run" || !options.frames) throw new Error("--mp4 requires run --frames (try --frames timeline)");
+    options.mp4 = mp4;
+  }
+  const crf = valueOf("--crf");
+  if (crf !== void 0) {
+    const value = Number(crf);
+    if (!options.mp4 || !Number.isInteger(value) || value < 0 || value > 51) throw new Error("--crf needs --mp4 and an integer from 0 to 51");
+    options.crf = value;
+  }
+  if (args.includes("--json") && command === "run") options.json = true;
+  if (args.includes("--fresh")) options.fresh = true;
+  const seed = valueOf("--seed");
+  if (seed !== void 0) {
+    const value = Number(seed);
+    if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+      throw new Error(`--seed must be an integer from 0 to 4294967295 (got "${seed}")`);
+    }
+    options.seed = value;
+  }
+  const timeout = valueOf("--timeout");
+  if (timeout !== void 0) {
+    const ms = Number(timeout);
+    if (command !== "run" || !Number.isSafeInteger(ms) || ms <= 0 || ms > 2147483647) {
+      throw new Error("--timeout requires run and a positive integer number of milliseconds up to 2147483647");
+    }
+    const index = args.indexOf("--timeout");
+    const childArgs = [...args.slice(0, index), ...args.slice(index + 2)];
+    if (childArgs.includes("--timeout")) throw new Error("--timeout may only be specified once");
+    process.exitCode = await superviseProcess(process.execPath, [...process.execArgv, process.argv[1], ...childArgs], ms);
+    return;
+  }
+  const { runGraph } = await import("./runner-RA6UKEPD.js");
+  try {
+    if (options.json) console.log = console.error;
+    await runGraph(options);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    if (options.verbose && error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+async function buildCommand(args) {
+  const { buildPlayer } = await import("./webBuild-GT4PZT5D.js");
+  if (!args[1] || args[1].startsWith("-")) throw new Error("cascade build requires a graph file");
+  let out;
+  const assets = [];
+  for (let index = 2; index < args.length; index += 2) {
+    const flag = args[index];
+    if (flag !== "--out" && flag !== "--asset") throw new Error(`Unknown build option: ${flag}`);
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) throw new Error(`${flag} requires a value`);
+    if (flag === "--out") {
+      if (out !== void 0) throw new Error("--out may only be supplied once");
+      out = value;
+    } else assets.push(value);
+  }
+  if (!out) throw new Error("cascade build requires --out <new-directory>");
+  try {
+    const result = await buildPlayer(args[1], { out, assets });
+    console.log(`Browser player built: ${result.directory}`);
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  }
+}
+export {
+  buildCommand,
+  runCommand
+};
+//# sourceMappingURL=runCommand-PI764LEG.js.map

package/dist/cli/runner-RA6UKEPD.js

@@ -0,0 +1,37 @@
+import {
+  runGraph
+} from "./chunk-DUIUFVU2.js";
+import "./chunk-4UDFYF5G.js";
+import "./chunk-QBBKRNGY.js";
+import "./chunk-2KXB47FP.js";
+import "./chunk-BP7UKF36.js";
+import "./chunk-YAT5Y25U.js";
+import "./chunk-ZL4JTG5Y.js";
+import "./chunk-RUU3YWXU.js";
+import "./chunk-MIIEFUGG.js";
+import "./chunk-WPUDGEFY.js";
+import "./chunk-VVGSLVSF.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-EUIAC3U3.js";
+import "./chunk-36P5K3SD.js";
+import "./chunk-D6BUOHUG.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-35D343DC.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-RQZ4SX5R.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-XWDSKG7N.js";
+import "./chunk-BIJO5OFS.js";
+import "./chunk-WIH4TEIS.js";
+export {
+  runGraph
+};
+//# sourceMappingURL=runner-RA6UKEPD.js.map