@field/cascade 0.11.0 → 0.12.0

package/dist/cli/chunk-5ORUQ6ES.js

@@ -0,0 +1,267 @@
+// server/src/stageCache.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs3 from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// server/src/atomicWrite.ts
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+var temporaryFor = (file) => `${file}.${process.pid}.tmp`;
+async function writeFileAtomic(file, data, options = {}) {
+  const temporary = temporaryFor(file);
+  await fsp.writeFile(temporary, data, options.mode === void 0 ? void 0 : { mode: options.mode });
+  await fsp.rename(temporary, file);
+}
+function writeFileAtomicSync(file, data) {
+  const temporary = temporaryFor(file);
+  fs.writeFileSync(temporary, data);
+  fs.renameSync(temporary, file);
+}
+
+// server/src/stageSources.ts
+import { createHash } from "node:crypto";
+import fs2 from "node:fs";
+import path from "node:path";
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["__pycache__", "node_modules", "venv", ".venv", ".git", ".cascade", ".cascade-cache"]);
+var digests = /* @__PURE__ */ new Map();
+function contentDigest(fullPath) {
+  let stat;
+  try {
+    stat = fs2.statSync(fullPath, { bigint: true });
+  } catch {
+    return null;
+  }
+  if (!stat.isFile()) return null;
+  const stamp = `${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  const known = digests.get(fullPath);
+  if (known?.stamp === stamp) return known.digest;
+  const hash = createHash("sha256");
+  const handle = fs2.openSync(fullPath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(1 << 20);
+    let read;
+    while ((read = fs2.readSync(handle, buffer, 0, buffer.length, null)) > 0) hash.update(buffer.subarray(0, read));
+  } finally {
+    fs2.closeSync(handle);
+  }
+  const digest = hash.digest("hex");
+  digests.set(fullPath, { stamp, digest });
+  return digest;
+}
+var StageSources = class {
+  constructor(project, roots) {
+    this.project = project;
+    this.roots = [...new Set(roots)].sort();
+  }
+  /** The default roots for a stage configuration without `sources`. */
+  static defaultRoots(project, entrypoint, worker) {
+    const roots = [path.posix.dirname(entrypoint)];
+    if (worker) roots.push(path.posix.dirname(worker));
+    if (fs2.existsSync(project.resolve("src"))) roots.push("src");
+    return roots.map((root) => root === "" ? "." : root);
+  }
+  /** Every source file, project-relative and sorted. */
+  files() {
+    const found = /* @__PURE__ */ new Set();
+    for (const root of this.roots) {
+      let full;
+      try {
+        full = this.project.resolveMedia(root);
+      } catch {
+        continue;
+      }
+      let stat;
+      try {
+        stat = fs2.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isFile()) found.add(root);
+      else if (stat.isDirectory()) this.walk(full, root, found);
+    }
+    return [...found].sort();
+  }
+  walk(directory, relative, found) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const child = relative === "." ? entry.name : path.posix.join(relative, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIPPED_DIRECTORIES.has(entry.name) || entry.name.startsWith(".")) continue;
+        this.walk(path.join(directory, entry.name), child, found);
+      } else if (entry.isFile() && entry.name.endsWith(".py")) {
+        found.add(child);
+      }
+    }
+  }
+  digest(relative) {
+    return contentDigest(this.project.resolveMedia(relative)) ?? "missing";
+  }
+  /**
+   * The code hash, 16 hex characters. A file added, removed or edited changes
+   * it. Cheap to call per request: one directory walk and one stat per file,
+   * with a file read only when its stat changed.
+   */
+  codeHash() {
+    const hash = createHash("sha256");
+    for (const file of this.files()) hash.update(`${file}\0${this.digest(file)}
+`);
+    return hash.digest("hex").slice(0, 16);
+  }
+};
+
+// server/src/stageCache.ts
+var CACHE_FORMAT = 1;
+var CACHE_DIRECTORY = ".cascade/cache/stages";
+var version;
+function cascadeVersion() {
+  if (version) return version;
+  let directory = path2.dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth++) {
+    try {
+      const manifest = JSON.parse(fs3.readFileSync(path2.join(directory, "package.json"), "utf8"));
+      if (manifest.name === "@field/cascade" && manifest.version) return version = manifest.version;
+    } catch {
+    }
+    directory = path2.dirname(directory);
+  }
+  return version = "unknown";
+}
+function projectFile(project, value) {
+  if (!value || value.length > 1024 || value.includes("\0") || /^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  if (path2.isAbsolute(value) || !/[./]/.test(value)) return null;
+  try {
+    return project.resolveMedia(value.replace(/^\.\//, ""));
+  } catch {
+    return null;
+  }
+}
+function replaceFiles(project, value, at, skip, onFile) {
+  if (typeof value === "string") {
+    const full = projectFile(project, value);
+    const digest = full ? contentDigest(full) : null;
+    if (!digest) return value;
+    onFile(at, value, digest);
+    return `file:${digest}`;
+  }
+  if (Array.isArray(value)) return value.map((item, index) => replaceFiles(project, item, `${at}[${index}]`, skip, onFile));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const name of Object.keys(value).sort()) {
+      const child = value[name];
+      const where = at ? `${at}.${name}` : name;
+      out[name] = !at && skip.has(name) ? child : replaceFiles(project, child, where, skip, onFile);
+    }
+    return out;
+  }
+  return value;
+}
+function stageCacheKey(project, stage, args, code, outputs = []) {
+  const inputs = {};
+  const params = replaceFiles(project, args, "", new Set(outputs), (where, _relative, digest) => {
+    inputs[where] = digest.slice(0, 16);
+  });
+  const cascade = cascadeVersion();
+  const blob = JSON.stringify({ format: CACHE_FORMAT, stage, code, cascade, params });
+  return { key: createHash2("sha256").update(blob).digest("hex").slice(0, 32), code, cascade, inputs };
+}
+function entryPath(project, stage, key) {
+  return project.resolve(path2.posix.join(CACHE_DIRECTORY, stage, `${key}.json`));
+}
+function resultFiles(project, result) {
+  const files = {};
+  replaceFiles(project, result, "", /* @__PURE__ */ new Set(), (_where, relative, digest) => {
+    files[relative] = digest;
+  });
+  return files;
+}
+function readEntry(project, stage, key) {
+  let entry;
+  try {
+    entry = JSON.parse(fs3.readFileSync(entryPath(project, stage, key), "utf8"));
+  } catch {
+    return { why: "no entry" };
+  }
+  if (entry.format !== CACHE_FORMAT || entry.key !== key) return { why: "no entry" };
+  for (const [relative, digest] of Object.entries(entry.outputs ?? {})) {
+    const full = projectFile(project, relative);
+    if (!full || contentDigest(full) !== digest) return { why: `output changed: ${relative}` };
+  }
+  return { result: entry.result };
+}
+function writeEntry(project, stage, key, result) {
+  const file = entryPath(project, stage, key);
+  const entry = { format: CACHE_FORMAT, stage, key, result, outputs: resultFiles(project, result) };
+  fs3.mkdirSync(path2.dirname(file), { recursive: true });
+  writeFileAtomicSync(file, JSON.stringify(entry));
+}
+function cacheMode(policy, stage, caller, env) {
+  if (env.CASCADE_STAGE_CACHE === "off") return { use: false, bypass: true, why: "CASCADE_STAGE_CACHE=off" };
+  if (!policy.enabled) return { use: false, bypass: false, why: "not enabled" };
+  if (policy.exclude.includes(stage)) return { use: false, bypass: false, why: "excluded" };
+  if (policy.scope === "cook" && caller !== "cook") return { use: false, bypass: false, why: "not a cook call" };
+  return { use: true, bypass: false };
+}
+function stageSources(project, config) {
+  return new StageSources(project, config.sources ?? StageSources.defaultRoots(project, config.entrypoint, config.worker));
+}
+async function callStage(project, config, stage, args, invoke, options = {}) {
+  const started = performance.now();
+  const code = stageSources(project, config).codeHash();
+  const identity = stageCacheKey(project, stage, args, code, config.cache.outputs);
+  const mode = cacheMode(config.cache, stage, options.caller ?? "cook", options.env ?? process.env);
+  const finish = (result, trace) => {
+    const full = {
+      stage,
+      key: identity.key,
+      ...trace,
+      code: identity.code,
+      cascade: identity.cascade,
+      inputs: identity.inputs,
+      ms: Math.round(performance.now() - started)
+    };
+    options.onTrace?.(full);
+    return { result, trace: full };
+  };
+  let why = mode.why;
+  if (mode.use) {
+    const stored = readEntry(project, stage, identity.key);
+    if ("result" in stored) return finish(stored.result, { cache: "hit" });
+    why = stored.why;
+  }
+  const answer = await invoke({ key: identity.key, code, cache: mode.bypass ? "off" : "use" });
+  if (mode.use) {
+    try {
+      writeEntry(project, stage, identity.key, answer.result);
+    } catch {
+    }
+  }
+  return finish(answer.result, {
+    cache: mode.use ? "miss" : "off",
+    ...why ? { why } : {},
+    ...answer.projectCache ? { project: answer.projectCache } : {},
+    ...answer.restarted ? { restarted: true } : {}
+  });
+}
+function formatStageTrace(trace) {
+  const reason = trace.why ? ` (${trace.why})` : "";
+  const project = trace.project ? ` project:${trace.project}` : "";
+  const restarted = trace.restarted ? " worker restarted for new code" : "";
+  return `${trace.stage}: ${trace.cache}${reason}${project} key ${trace.key.slice(0, 12)} code ${trace.code} ${trace.ms} ms${restarted}`;
+}
+
+export {
+  writeFileAtomic,
+  writeFileAtomicSync,
+  cascadeVersion,
+  stageCacheKey,
+  stageSources,
+  callStage,
+  formatStageTrace
+};
+//# sourceMappingURL=chunk-5ORUQ6ES.js.map

package/dist/cli/chunk-73S4JZXK.js

@@ -0,0 +1,336 @@
+import {
+  installHeadlessCanvas
+} from "./chunk-EZRWJ4G2.js";
+import {
+  applyScene,
+  exportEditor,
+  formatPlan,
+  fromBase64,
+  parseScene
+} from "./chunk-3RXL5GHB.js";
+import {
+  cookProjectGraph,
+  installProjectIo
+} from "./chunk-MP653A5O.js";
+import {
+  ProjectRoot
+} from "./chunk-2JEU3MGB.js";
+
+// src/cli/editorCommands.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var EDITOR_COMMANDS = ["export", "share", "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 share <graph | site-dir> [--name <slug>] [--scope <team>] [--protected]   Deploy as cascade-<slug>, print the link
+  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 (command === "share") {
+    const { runShareCommand } = await import("./share-MHF6TNRK.js");
+    return runShareCommand(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: ${path.join(result.directory, "export-manifest.json")}`);
+  if (result.url) console.log(`Deployed: ${result.url}`);
+}
+async function readGraph(file) {
+  return JSON.parse(await fs.readFile(file, "utf8"));
+}
+async function writeEditor(file, document, editor) {
+  const next = { ...document, editor };
+  await fs.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: path.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 = path.resolve(graph);
+  const project = new ProjectRoot(path.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 = path.join("frozen", node);
+  await fs.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}/${path.basename(from)}`;
+      await fs.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 fs.writeFile(project.resolve(snapshotFile), `${JSON.stringify(snapshot, null, 2)}
+`);
+  const editor = document.editor ?? { id: path.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 (path.resolve(out) === path.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 fs.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 fs.readFile(sceneFile, "utf8"));
+  const project = new ProjectRoot(path.dirname(path.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 = path.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 fs.mkdir(path.dirname(project.resolve(name)), { recursive: true });
+    await fs.writeFile(project.resolve(name), bytes);
+    return name;
+  }
+  for (const candidate of await filesNamed(project.root, path.basename(file.name))) {
+    const digest = createHash("sha256").update(await fs.readFile(candidate)).digest("hex");
+    if (digest === file.sha256) return path.relative(project.root, candidate).split(path.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 fs.readdir(directory, { withFileTypes: true }).catch(() => [])) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".cascade-cache") continue;
+      const file = path.join(directory, entry.name);
+      if (entry.isDirectory()) await walk(file, depth + 1);
+      else if (entry.name === name) found.push(file);
+    }
+  };
+  await walk(path.join(root, "assets"), 0);
+  await walk(path.join(root, "licensed"), 0);
+  return found;
+}
+async function runWithScene(graph, flags) {
+  const graphFile = path.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(path.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 fs.writeFile(file, value);
+    else if (value && typeof value === "object" && typeof value.path === "string")
+      await fs.copyFile(project.resolve(value.path.replace(/^\.\//, "")), file);
+    else await fs.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
+};
+//# sourceMappingURL=chunk-73S4JZXK.js.map

package/dist/cli/{chunk-YAT5Y25U.js → chunk-7QE2ZNSN.js}

@@ -52,7 +52,7 @@ async function encodeSequence(options) {
     if (frames[index] !== frames[index - 1] + 1) throw new Error("--mp4 needs a contiguous range of whole frames (no step)");
   }
   const { prefix, width, extension } = options.sequence;
-  const pattern = path.join(options.root, `${prefix}.%0${width}d${extension}`);
+  const pattern = path.resolve(options.root, `${prefix}.%0${width}d${extension}`);
   const output = path.resolve(options.root, options.file);
   await fs.mkdir(path.dirname(output), { recursive: true });
   const size = scale === 1 ? "pad=ceil(iw/2)*2:ceil(ih/2)*2" : `scale=trunc(iw*${scale}/2)*2:trunc(ih*${scale}/2)*2:flags=lanczos`;
@@ -60,7 +60,7 @@ async function encodeSequence(options) {
   let pixelFormat;
   let codecArgs;
   if (options.codec === "prores") {
-    const first = path.join(options.root, `${prefix}.${String(frames[0]).padStart(width, "0")}${extension}`);
+    const first = path.resolve(options.root, `${prefix}.${String(frames[0]).padStart(width, "0")}${extension}`);
     const alpha = await hasTransparency(first);
     pixelFormat = alpha ? "yuva444p10le" : "yuv422p10le";
     codecArgs = ["-c:v", "prores_ks", "-profile:v", alpha ? "4" : "3", "-vendor", "apl0", "-pix_fmt", pixelFormat];
@@ -118,4 +118,4 @@ export {
   hasFfmpeg,
   encodeSequence
 };
-//# sourceMappingURL=chunk-YAT5Y25U.js.map
+//# sourceMappingURL=chunk-7QE2ZNSN.js.map

package/dist/cli/{chunk-SGJAET2L.js → chunk-BPODRH52.js}

@@ -3,15 +3,16 @@ import {
   packagePathToType,
   registerNodeClasses,
   registerNodeMetadata
-} from "./chunk-FCDXJ6EK.js";
+} from "./chunk-CTPLRSWF.js";
 import {
   bundleValueProblem,
+  gpuLimitShortfall,
   graphSeed,
   isGpuHost,
   nodeSeed,
   seededRandom,
   selectBundleFields
-} from "./chunk-GFS6W3C5.js";
+} from "./chunk-L6B6FUQP.js";
 
 // src/nodes/definition/DefinitionNode.ts
 var silentProgress = { report: () => {
@@ -136,7 +137,10 @@ function attachDefinition(node, registration, capabilities) {
     const gpuHost = (definition.capabilities ?? []).includes("gpu") && isGpuHost(capabilities.gpu) ? capabilities.gpu : null;
     if (gpuHost) {
       await gpuHost.ensure();
-      nodeCapabilities = { ...capabilities, gpu: gpuHost.forNode(node.id) };
+      const gpu = gpuHost.forNode(node.id);
+      const shortfall = gpuLimitShortfall(node.id, definition.gpuLimits, gpu);
+      if (shortfall) throw new Error(shortfall);
+      nodeCapabilities = { ...capabilities, gpu };
     }
     const seed = nodeSeed(graphSeed({ seed: node.documentSeed }), node.id);
     const context = {
@@ -194,4 +198,4 @@ export {
   attachDefinition,
   registerDefinitionNodes
 };
-//# sourceMappingURL=chunk-SGJAET2L.js.map
+//# sourceMappingURL=chunk-BPODRH52.js.map

package/dist/cli/{chunk-XWDSKG7N.js → chunk-BZ63XQ3I.js}

@@ -1,6 +1,6 @@
 import {
   canConnectTypes
-} from "./chunk-BIJO5OFS.js";
+} from "./chunk-FWMSGKEH.js";
 
 // packages/runtime/src/edit/document.ts
 var SUBNET = "cascade.core.Subnet";
@@ -1298,4 +1298,4 @@ export {
   applyOperation,
   readGraph
 };
-//# sourceMappingURL=chunk-XWDSKG7N.js.map
+//# sourceMappingURL=chunk-BZ63XQ3I.js.map