@field/cascade 0.10.0 → 0.11.0

package/dist/cli/chunk-WKURDVYP.js

@@ -0,0 +1,1119 @@
+import {
+  canonicalFuturePath,
+  createBrowserRuntimeHost,
+  exists,
+  inside,
+  playerFile,
+  staticRuntimePlugin
+} from "./chunk-3JTJHF7V.js";
+import {
+  PREFLIGHT_WARNING_CODES,
+  cookProjectGraph,
+  createRuntime,
+  installProjectIo,
+  moduleId,
+  projectModuleFile,
+  validateNodeModuleArchitecture
+} from "./chunk-EUIAC3U3.js";
+import {
+  builtinNodeRegistration
+} from "./chunk-36P5K3SD.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";
+
+// packages/runtime/src/editor/index.ts
+var SCENE_FORMAT = "cascade.scene";
+var platform = globalThis;
+function connectionEnds(connection) {
+  if (Array.isArray(connection)) {
+    const [source, target] = connection;
+    return { source: source[0], sourcePort: source[2], target: target[0], targetPort: target[2] };
+  }
+  const object = connection;
+  return {
+    source: object.source.nodeId,
+    sourcePort: object.source.outputName,
+    target: object.target.nodeId,
+    targetPort: object.target.inputName
+  };
+}
+function requireEditor(document) {
+  const editor = document.editor;
+  if (!editor || typeof editor !== "object" || typeof editor.id !== "string" || !editor.id)
+    throw new Error('This graph declares no editor. Add an "editor" section with an id (see doc/EDITOR_EXPORT.md).');
+  return editor;
+}
+function validateEditor(document) {
+  const out = [];
+  const error = (code, message) => out.push({ severity: "error", code, message });
+  const warn = (code, message) => out.push({ severity: "warning", code, message });
+  const editor = document.editor;
+  if (!editor) return [{ severity: "error", code: "editor/missing", message: "The graph has no editor section" }];
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(editor.id ?? ""))
+    error("editor/id", `editor.id must be a plain identifier, got ${JSON.stringify(editor.id)}`);
+  const nodes = new Map(document.nodes.map((node) => [node.id, node]));
+  const ids = /* @__PURE__ */ new Set();
+  for (const parameter of editor.parameters ?? []) {
+    if (ids.has(parameter.id)) error("editor/duplicate-parameter", `Parameter id ${parameter.id} is used twice`);
+    ids.add(parameter.id);
+    if (!nodes.has(parameter.node))
+      error("editor/parameter-node", `Parameter ${parameter.id} targets missing node ${parameter.node}`);
+  }
+  for (const parameter of editor.parameters ?? [])
+    for (const condition of conditionsOf(parameter))
+      if (!ids.has(condition.param))
+        warn("editor/visible-when", `Parameter ${parameter.id} is shown when unknown parameter ${condition.param} matches`);
+  const outputIds = /* @__PURE__ */ new Set();
+  let views = 0;
+  for (const output of editor.outputs ?? []) {
+    if (outputIds.has(output.id)) error("editor/duplicate-output", `Output id ${output.id} is used twice`);
+    outputIds.add(output.id);
+    if (!nodes.has(output.node)) error("editor/output-node", `Output ${output.id} reads missing node ${output.node}`);
+    if (output.view) views++;
+    for (const id of output.parameters ?? [])
+      if (!ids.has(id)) error("editor/output-parameter", `Output ${output.id} shows unknown parameter ${id}`);
+  }
+  if (!(editor.outputs ?? []).length) error("editor/no-outputs", "The editor declares no outputs");
+  if (views > 1) warn("editor/views", "More than one output sets view; the first is shown");
+  for (const preset of editor.presets ?? [])
+    for (const key of Object.keys(preset.values ?? {}))
+      if (!ids.has(key)) warn("editor/preset-parameter", `Preset ${preset.id} sets unknown parameter ${key}`);
+  for (const id of editor.peek ?? [])
+    if (!ids.has(id)) warn("editor/peek-parameter", `peek names unknown parameter ${id}`);
+  for (const id of Object.keys(editor.draft ?? {}))
+    if (!ids.has(id)) warn("editor/draft-parameter", `draft sets unknown parameter ${id}`);
+  for (const frozen of editor.freeze ?? [])
+    if (!nodes.has(frozen.node)) error("editor/freeze-node", `Frozen source ${frozen.node} is not in the graph`);
+  return out;
+}
+function selectEditorSubgraph(document) {
+  const editor = requireEditor(document);
+  const frozen = new Set((editor.freeze ?? []).map((item) => item.node));
+  const children = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  for (const node of document.nodes) {
+    if (!node.parent) continue;
+    parents.set(node.id, node.parent);
+    children.set(node.parent, [...children.get(node.parent) ?? [], node.id]);
+  }
+  const upstream = /* @__PURE__ */ new Map();
+  for (const connection of document.connections ?? []) {
+    const { source, target } = connectionEnds(connection);
+    upstream.set(target, [...upstream.get(target) ?? [], source]);
+  }
+  const known = new Set(document.nodes.map((node) => node.id));
+  const selected = /* @__PURE__ */ new Set();
+  const queue = [
+    ...(editor.outputs ?? []).map((output) => output.node),
+    ...(editor.parameters ?? []).map((parameter) => parameter.node)
+  ].filter((id) => known.has(id));
+  while (queue.length) {
+    const id = queue.pop();
+    if (selected.has(id)) continue;
+    selected.add(id);
+    const parent = parents.get(id);
+    if (parent) queue.push(parent);
+    if (frozen.has(id)) continue;
+    queue.push(...children.get(id) ?? [], ...upstream.get(id) ?? []);
+  }
+  return selected;
+}
+function editorGraphVersion(document) {
+  const editor = requireEditor(document);
+  const selected = selectEditorSubgraph(document);
+  const frozen = new Set((editor.freeze ?? []).map((item) => item.node));
+  const nodes = document.nodes.filter((node) => selected.has(node.id)).map((node) => [node.id, frozen.has(node.id) ? "frozen" : moduleOf(node), node.parent ?? ""]).sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+  const connections = (document.connections ?? []).map(connectionEnds).filter((end) => selected.has(end.source) && selected.has(end.target) && !frozen.has(end.target)).map((end) => `${end.source}.${frozen.has(end.source) ? "" : end.sourcePort ?? ""}>${end.target}.${end.targetPort ?? ""}`).sort();
+  const parameters = (editor.parameters ?? []).map((parameter) => [parameter.id, parameter.node, parameter.prop, controlOf(parameter)]).sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+  return `h${hash(JSON.stringify([editor.id, parameters, nodes, connections]))}`;
+}
+function publishedValues(document) {
+  const editor = requireEditor(document);
+  const nodes = new Map(document.nodes.map((node) => [node.id, node]));
+  const values = {};
+  for (const parameter of editor.parameters ?? []) {
+    const stored = propsOf(nodes.get(parameter.node))[parameter.prop];
+    values[parameter.id] = isBinding(stored) ? stored.value : stored;
+  }
+  return values;
+}
+function parseScene(input) {
+  const value = typeof input === "string" ? JSON.parse(input) : input;
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("A scene must be a JSON object");
+  const scene = value;
+  if (scene.format !== SCENE_FORMAT) throw new Error(`Not a Cascade scene (format ${JSON.stringify(scene.format)})`);
+  if (scene.version !== 1) throw new Error(`Unsupported scene version ${JSON.stringify(scene.version)}`);
+  if (!scene.graph || typeof scene.graph.id !== "string") throw new Error("A scene must name its graph");
+  if (!scene.values || typeof scene.values !== "object" || Array.isArray(scene.values))
+    throw new Error("A scene must carry a values object");
+  for (const [id, file] of Object.entries(scene.files ?? {})) {
+    if (!file || typeof file.name !== "string" || typeof file.sha256 !== "string" || typeof file.size !== "number")
+      throw new Error(`Scene file ${id} needs a name, a size and a sha256`);
+    if (file.data !== void 0 && typeof file.data !== "string") throw new Error(`Scene file ${id} data must be base64`);
+  }
+  return scene;
+}
+function resolveScene(document, sceneInput) {
+  const scene = parseScene(sceneInput);
+  const editor = requireEditor(document);
+  const warnings = [];
+  if (scene.graph.id !== editor.id)
+    warnings.push(`Scene was made for "${scene.graph.id}", not "${editor.id}"; matching parameters are applied`);
+  else if (scene.graph.version && scene.graph.version !== editorGraphVersion(document))
+    warnings.push("Scene was saved against another version of this graph; matching parameters are applied");
+  const parameters = new Map((editor.parameters ?? []).map((parameter) => [parameter.id, parameter]));
+  for (const id of Object.keys(scene.values))
+    if (!parameters.has(id)) warnings.push(`Unknown parameter "${id}" ignored`);
+  for (const id of Object.keys(scene.files ?? {}))
+    if (!parameters.has(id)) warnings.push(`Unknown file parameter "${id}" ignored`);
+  const current = publishedValues(document);
+  const values = {};
+  const files = {};
+  for (const parameter of parameters.values()) {
+    if (controlOf(parameter, current[parameter.id]) === "file") {
+      const file = scene.files?.[parameter.id];
+      if (file) files[parameter.id] = file;
+      continue;
+    }
+    if (!(parameter.id in scene.values)) continue;
+    const coerced = coerceValue(parameter, scene.values[parameter.id], current[parameter.id]);
+    if (coerced.warning) warnings.push(coerced.warning);
+    if (coerced.value !== void 0) values[parameter.id] = coerced.value;
+  }
+  return { values, files, warnings };
+}
+function applyScene(document, sceneInput, options = {}) {
+  const editor = requireEditor(document);
+  const resolved = resolveScene(document, sceneInput);
+  const warnings = [...resolved.warnings];
+  const updates = { ...resolved.values };
+  for (const parameter of editor.parameters ?? []) {
+    const file = resolved.files[parameter.id];
+    if (!file) continue;
+    const value = options.resolveFile?.(parameter, file);
+    if (value === void 0) warnings.push(`${labelOf(parameter)}: "${file.name}" is not available here; the graph's file is kept`);
+    else updates[parameter.id] = value;
+  }
+  const result = setPublishedValues(document, updates);
+  return { document: result, values: publishedValues(result), warnings };
+}
+function setPublishedValues(document, updates) {
+  const editor = requireEditor(document);
+  const writes = /* @__PURE__ */ new Map();
+  for (const parameter of editor.parameters ?? []) {
+    if (!(parameter.id in updates) || updates[parameter.id] === void 0) continue;
+    const props = writes.get(parameter.node) ?? {};
+    props[parameter.prop] = updates[parameter.id];
+    writes.set(parameter.node, props);
+  }
+  const nodes = document.nodes.map((node) => {
+    const props = writes.get(node.id);
+    if (!props) return node;
+    const merged = { ...propsOf(node) };
+    for (const [name, value] of Object.entries(props)) {
+      const stored = merged[name];
+      merged[name] = isBinding(stored) ? { ...stored, value } : value;
+    }
+    return { ...node, props: merged };
+  });
+  return { ...document, nodes };
+}
+function conditionsOf(parameter) {
+  const condition = parameter.visibleWhen;
+  if (!condition) return [];
+  return Array.isArray(condition) ? condition : [condition];
+}
+function coerceValue(parameter, value, current) {
+  const label = labelOf(parameter);
+  const reject = (what) => ({ warning: `${label}: ${what}; kept the graph's value` });
+  if (value === void 0) return {};
+  const control = controlOf(parameter, current);
+  switch (control) {
+    case "number":
+    case "slider":
+      return typeof value === "number" && Number.isFinite(value) ? { value } : reject("expected a number");
+    case "int":
+    case "seed":
+      return typeof value === "number" && Number.isFinite(value) ? { value: Math.round(value) } : reject("expected a whole number");
+    case "bool":
+      return typeof value === "boolean" ? { value } : reject("expected true or false");
+    case "text":
+    case "textarea":
+      return typeof value === "string" ? { value } : reject("expected text");
+    case "select": {
+      const options = (parameter.options ?? []).map(
+        (option) => option !== null && typeof option === "object" && "value" in option ? option.value : option
+      );
+      return options.some((option) => Object.is(option, value)) ? { value } : reject(`${JSON.stringify(value)} is not one of its options`);
+    }
+    case "color":
+      return typeof value === "string" || Array.isArray(value) && value.every((part) => typeof part === "number") ? { value } : reject("expected a colour");
+    case "vec2":
+      return Array.isArray(value) && value.length === 2 && value.every((part) => typeof part === "number" && Number.isFinite(part)) ? { value } : reject("expected two numbers");
+    default:
+      return { value };
+  }
+}
+function controlOf(parameter, current, type) {
+  if (parameter.control) return parameter.control;
+  if (parameter.options?.length) return "select";
+  const byType = {
+    float: parameter.min !== void 0 && parameter.max !== void 0 ? "slider" : "number",
+    int: "int",
+    bool: "bool",
+    string: "text",
+    color: "color",
+    vec2: "vec2",
+    vec2i: "vec2",
+    image: "file",
+    asset: "file"
+  };
+  if (type && byType[type]) return byType[type];
+  if (typeof current === "boolean") return "bool";
+  if (typeof current === "string") return "text";
+  if (Array.isArray(current) && current.length === 2) return "vec2";
+  if (current && typeof current === "object" && "path" in current) return "file";
+  return typeof current === "number" ? "number" : "any";
+}
+function fromBase64(text) {
+  const binary = platform.atob(text);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function labelOf(parameter) {
+  return parameter.label ?? parameter.id;
+}
+function moduleOf(node) {
+  return node.module ?? node.type ?? "";
+}
+function propsOf(node) {
+  const props = node?.props;
+  return props && typeof props === "object" ? props : {};
+}
+function isBinding(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || !("value" in value)) return false;
+  return Object.keys(value).every((key) => key === "value" || key === "expression" || key === "channel");
+}
+function hash(text) {
+  let h = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (let index = 0; index < text.length; index++) {
+    h ^= BigInt(text.charCodeAt(index));
+    h = h * prime & 0xffffffffffffffffn;
+  }
+  return h.toString(16).padStart(16, "0");
+}
+
+// src/cli/editorExport.ts
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { promisify } from "node:util";
+import { build } from "esbuild";
+import ts from "typescript";
+var run = promisify(execFile);
+var PERSONAL = /(note|transcript|calendar|diary|journal|whoop|weight|sleep|hrv|heart|health|body|location|gps|email|phone|address|observation|caption|person|people)/i;
+var COORDINATE = /^(lat|lon|lng|latitude|longitude)$/i;
+var LIVE_CAPABILITIES = /* @__PURE__ */ new Set(["files", "python", "shell"]);
+async function exportEditor(file, options = {}) {
+  const log = options.log ?? ((line) => console.log(line));
+  const prepared = await prepareExport(file);
+  if (options.plan) return { plan: prepared.plan };
+  if (!options.out) throw new Error("cascade export requires --out <directory> (or --plan to review without building)");
+  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);
+  return { plan, directory, ...url ? { url } : {} };
+}
+async function prepareExport(file) {
+  const graphFile = path.resolve(file);
+  const project = new ProjectRoot(path.dirname(graphFile));
+  const source = JSON.parse(await fs.readFile(graphFile, "utf8"));
+  if (!Array.isArray(source.nodes)) throw new Error("Graph document must contain a nodes array");
+  const editor = requireEditor(source);
+  const problems = validateEditor(source).filter((item) => item.severity === "error").map((item) => item.message);
+  const warnings = validateEditor(source).filter((item) => item.severity === "warning").map((item) => item.message);
+  if (problems.length) throw new Error(`The editor declaration has errors:
+${problems.map((line) => `  ${line}`).join("\n")}`);
+  const selected = selectEditorSubgraph(source);
+  const frozenNodes = new Map((editor.freeze ?? []).map((item) => [item.node, item]));
+  const nodes = source.nodes.filter((node) => selected.has(node.id));
+  const modules = [];
+  const definitions = /* @__PURE__ */ new Map();
+  const notExportable = [];
+  const live = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (frozenNodes.has(node.id)) continue;
+    const id = moduleId(node);
+    const builtin = builtinNodeRegistration(id);
+    if (builtin) {
+      definitions.set(node.id, builtin.definition);
+      continue;
+    }
+    const resolved = await projectModuleFile(project.root, node, id);
+    if (!resolved.file) {
+      notExportable.push(`${node.id} (${id}: no project module found)`);
+      continue;
+    }
+    const sourceFile = project.resolve(path.relative(project.root, resolved.file));
+    const code = await fs.readFile(sourceFile, "utf8");
+    const extracted = extractNodeDefinition(code, sourceFile, ts);
+    if (!extracted.ok) {
+      notExportable.push(`${node.id} (${id}: not a definition-v1 module)`);
+      continue;
+    }
+    const definition = extracted.definition;
+    definitions.set(node.id, definition);
+    const capabilities = definition.capabilities ?? [];
+    if (capabilities.includes("python") || capabilities.includes("shell")) {
+      notExportable.push(`${node.id} (${id}: Python/shell node)`);
+      continue;
+    }
+    if (definition.runsOn === "server" || definition.source === "live" || capabilities.some((name) => LIVE_CAPABILITIES.has(name))) {
+      live.push(`${node.id} (${id}${definition.source === "live" ? ", live source" : definition.runsOn === "server" ? ", server node" : ", reads files"})`);
+      continue;
+    }
+    const architecture = validateNodeModuleArchitecture(code, sourceFile, ts);
+    if (architecture.length) {
+      notExportable.push(...architecture.map((item) => `${node.id} (${id}: ${item.code}: ${item.message})`));
+      continue;
+    }
+    if (!seen.has(id)) {
+      seen.add(id);
+      modules.push({ id, file: sourceFile, definition });
+    }
+  }
+  const refusals = [];
+  if (notExportable.length) refusals.push(`Not exportable (only browser-runnable nodes ship; port these to TypeScript or freeze their output):
+${notExportable.map((line) => `  ${line}`).join("\n")}`);
+  if (live.length) refusals.push(`Live data sources are still wired in; freeze them with \`cascade freeze\` or take them out of the published path:
+${live.map((line) => `  ${line}`).join("\n")}`);
+  if (refusals.length) throw new Error(refusals.join("\n"));
+  const assets = /* @__PURE__ */ new Map();
+  const frozenPlan = [];
+  const personal = [];
+  const replacements = /* @__PURE__ */ new Map();
+  for (const frozen of editor.freeze ?? []) {
+    if (!selected.has(frozen.node)) continue;
+    const snapshotPath = checkedAssetPath(frozen.snapshot, `snapshot for ${frozen.node}`);
+    const snapshot = JSON.parse(await fs.readFile(project.resolve(snapshotPath), "utf8"));
+    if (snapshot.format !== "cascade.frozen" || snapshot.version !== 1)
+      throw new Error(`${frozen.snapshot} is not a cascade freeze snapshot`);
+    const fields = snapshot.fields.map((field) => {
+      const flagged = (snapshot.personal ?? []).includes(field) || field.split(/[.[\]]/).some((part) => PERSONAL.test(part) || COORDINATE.test(part));
+      if (flagged) personal.push(`${frozen.node}: ${field}`);
+      return { field, personal: flagged };
+    });
+    frozenPlan.push({ node: frozen.node, snapshot: snapshotPath, fields });
+    for (const name of snapshot.files ?? []) await addAsset(project, assets, checkedAssetPath(name, `file of snapshot ${frozen.node}`), "frozen", snapshotPath);
+    const original = source.nodes.find((node) => node.id === frozen.node);
+    replacements.set(frozen.node, {
+      id: original.id,
+      module: "cascade.core.Frozen",
+      ...original.parent ? { parent: original.parent } : {},
+      props: { value: snapshot.value }
+    });
+  }
+  const shippedNodes = nodes.map((node) => replacements.get(node.id) ?? stripNode(node));
+  const connections = [];
+  for (const connection of source.connections ?? []) {
+    const ends = connectionEnds(connection);
+    if (!selected.has(ends.source) || !selected.has(ends.target) || frozenNodes.has(ends.target)) continue;
+    if (!frozenNodes.has(ends.source)) {
+      connections.push(connection);
+      continue;
+    }
+    connections.push([[ends.source, 0, "value"], Array.isArray(connection) ? connection[1] : [ends.target, 0, ends.targetPort]]);
+  }
+  const shippedEditor = {
+    id: editor.id,
+    ...editor.title ? { title: editor.title } : {},
+    ...editor.description ? { description: editor.description } : {},
+    ...editor.groups ? { groups: editor.groups } : {},
+    parameters: editor.parameters ?? [],
+    outputs: editor.outputs ?? [],
+    ...editor.presets ? { presets: editor.presets } : {},
+    ...editor.freeze ? { freeze: editor.freeze.filter((item) => selected.has(item.node)).map((item) => ({ node: item.node, output: item.output, snapshot: "" })) } : {},
+    ...editor.panel ? { panel: { module: "", ...editor.panel.placement ? { placement: editor.panel.placement } : {} } } : {},
+    ...editor.inspect === false ? { inspect: false } : {},
+    ...editor.peek ? { peek: editor.peek } : {},
+    ...editor.draft ? { draft: editor.draft } : {},
+    ...editor.fonts?.length ? { fonts: editor.fonts } : {}
+  };
+  const document = {
+    version: source.version,
+    ...typeof source.metadata?.name === "string" ? { metadata: { name: source.metadata.name } } : {},
+    nodes: shippedNodes,
+    connections,
+    editor: shippedEditor
+  };
+  const graphVersion = editorGraphVersion(document);
+  if (graphVersion !== editorGraphVersion(source))
+    throw new Error("Internal: the exported graph version differs from the source graph version");
+  for (const asset of editor.assets ?? []) await addAsset(project, assets, checkedAssetPath(asset, "editor.assets"), "asset", "editor.assets");
+  for (const font of editor.fonts ?? []) await addAsset(project, assets, checkedFont(font), "asset", "editor.fonts");
+  for (const literal of await literalAssets(document, modules)) await addAsset(project, assets, checkedAssetPath(literal.path, literal.where), "asset", literal.where);
+  for (const asset of assets.values()) await refuseIgnored(project.root, asset.name);
+  const planNodes = shippedNodes.map((node) => ({
+    id: node.id,
+    module: String(node.module ?? node.type ?? ""),
+    kind: replacements.has(node.id) ? "frozen" : builtinNodeRegistration(moduleId(node)) ? "builtin" : "project",
+    props: Object.keys(node.props ?? {})
+  }));
+  const files = [];
+  for (const asset of assets.values())
+    files.push({ path: `assets/${asset.name}`, size: (await fs.stat(asset.file)).size, from: asset.from === "editor.assets" ? asset.name : `${asset.name} (${asset.from})`, kind: asset.kind });
+  const panel = editor.panel?.module ? project.resolve(checkedAssetPath(editor.panel.module, "editor.panel.module")) : void 0;
+  const plan = {
+    format: "cascade.export-plan",
+    version: 1,
+    editor: { id: editor.id, ...editor.title ? { title: editor.title } : {}, graphVersion },
+    graph: path.basename(graphFile),
+    nodes: planNodes,
+    excluded: source.nodes.filter((node) => !selected.has(node.id)).map((node) => node.id),
+    parameters: (editor.parameters ?? []).map((item) => `${item.id} \u2192 ${item.node}.${item.prop}`),
+    outputs: (editor.outputs ?? []).map((item) => `${item.id} \u2192 ${item.node}.${item.port} (${item.format})`),
+    frozen: frozenPlan,
+    files,
+    personal,
+    warnings
+  };
+  return { plan, project, document, modules, assets: [...assets.values()].map(({ name, file: file2 }) => ({ name, file: file2 })), ...panel ? { panel } : {} };
+}
+function formatPlan(plan) {
+  const lines = [];
+  lines.push(`Editor ${plan.editor.title ?? plan.editor.id} (${plan.editor.id}, ${plan.editor.graphVersion}) from ${plan.graph}`);
+  lines.push("", `Nodes shipped (${plan.nodes.length}):`);
+  for (const node of plan.nodes) lines.push(`  ${node.id}  ${node.module}${node.kind === "frozen" ? "  [frozen snapshot]" : ""}${node.props.length ? `  props: ${node.props.join(", ")}` : ""}`);
+  lines.push("", `Not shipped (${plan.excluded.length}): ${plan.excluded.join(", ") || "none"}`);
+  lines.push("", `Published parameters (${plan.parameters.length}):`, ...plan.parameters.map((line) => `  ${line}`));
+  lines.push("", "Outputs:", ...plan.outputs.map((line) => `  ${line}`));
+  if (plan.frozen.length) {
+    lines.push("", "Frozen sources:");
+    for (const frozen of plan.frozen) {
+      lines.push(`  ${frozen.node} from ${frozen.snapshot}`);
+      for (const field of frozen.fields) lines.push(`    ${field.field}${field.personal ? "   PERSONAL" : ""}`);
+    }
+  }
+  lines.push("", "Files:");
+  for (const file of plan.files) lines.push(`  ${file.path}  ${formatSize(file.size)}  ${file.kind}  from ${file.from}`);
+  if (plan.personal.length) lines.push("", "PERSONAL \u2014 check before sharing:", ...plan.personal.map((line) => `  ${line}`));
+  if (plan.warnings.length) lines.push("", "Warnings:", ...plan.warnings.map((line) => `  ${line}`));
+  return lines.join("\n");
+}
+async function buildSite(prepared, outOption) {
+  const { project, document, modules, assets, panel } = prepared;
+  const out = path.resolve(process.cwd(), outOption);
+  const canonicalOut = await canonicalFuturePath(out);
+  for (const sourceDirectory of ["assets", "nodes", "lib"]) {
+    const sourceRoot = await canonicalFuturePath(path.join(project.root, sourceDirectory));
+    if (inside(sourceRoot, canonicalOut)) throw new Error(`Export output cannot be inside the project's ${sourceDirectory} directory`);
+  }
+  if (inside(canonicalOut, await fs.realpath(project.root))) throw new Error("Export output cannot contain the project");
+  if (await exists(out)) {
+    if (!await exists(path.join(out, "export-manifest.json")))
+      throw new Error(`${out} exists and is not a previous export. Choose a new directory.`);
+  }
+  const plugins = [await staticRuntimePlugin(project.root), sveltePlugin(project.root)];
+  const editorEntry = await playerFile("editor");
+  const imports = modules.map((item, index) => `import { execute as execute${index} } from ${JSON.stringify(item.file)};`).join("\n");
+  const registrations = modules.map((item, index) => `{ kind:'definition-v1', moduleId:${JSON.stringify(item.id)}, definition:${JSON.stringify(item.definition)}, loadExecute:async()=>execute${index} }`).join(",");
+  const assetSource = assets.map((item) => `${JSON.stringify(item.name)}:new URL(${JSON.stringify(`./assets/${item.name.split("/").map(encodeURIComponent).join("/")}`)},import.meta.url).href`).join(",");
+  const panelImport = panel ? `import * as panel from ${JSON.stringify(panel)};` : "";
+  const engineEntry = await playerFile("editorEngine");
+  const fonts = fontSources(document.editor?.fonts ?? []);
+  const entry = `import { startEditor } from ${JSON.stringify(editorEntry)};
+${panelImport}
+${fonts.loader}
+window.cascadeEditorReady = startEditor({document:${JSON.stringify(document)},worker:new URL('./editor-worker.js',import.meta.url),assets:{${assetSource}}${panel ? ",panel" : ""}});`;
+  const workerEntry = `import { serveEditorEngine } from ${JSON.stringify(engineEntry)};
+${imports}
+${fonts.loader}
+serveEditorEngine([${registrations}]);`;
+  const bundle = (contents, sourcefile) => build({
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    target: "es2022",
+    write: false,
+    minify: true,
+    legalComments: "none",
+    logLevel: "silent",
+    plugins,
+    stdin: { contents, resolveDir: project.root, sourcefile }
+  });
+  const [result, workerResult] = await Promise.all([bundle(entry, "editor-entry.js"), bundle(workerEntry, "editor-worker-entry.js")]);
+  await fs.mkdir(path.dirname(out), { recursive: true });
+  const staging = await fs.mkdtemp(path.join(path.dirname(out), ".cascade-export-"));
+  try {
+    const title = escapeHtml(document.editor?.title ?? document.editor?.id ?? "Cascade");
+    const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover,maximum-scale=1"><meta name="robots" content="noindex,nofollow"><meta name="referrer" content="no-referrer"><link rel="icon" href="data:,"><title>${title}</title><style>${fonts.css}html,body{margin:0;height:100%;background:#f4f4f2}@media (prefers-color-scheme:dark){html,body{background:#151515}}</style></head><body><script type="module" src="./editor.js"></script></body></html>`;
+    const files = [];
+    const write = async (name, data, kind, from) => {
+      await fs.mkdir(path.dirname(path.join(staging, name)), { recursive: true });
+      await fs.writeFile(path.join(staging, name), data);
+      files.push({ path: name, size: typeof data === "string" ? Buffer.byteLength(data) : data.byteLength, from, kind });
+    };
+    await write("index.html", html, "page", "generated");
+    await write("editor.js", result.outputFiles[0].contents, "code", "cascade editor shell");
+    await write("editor-worker.js", workerResult.outputFiles[0].contents, "code", "cascade runtime + project nodes");
+    for (const asset of assets) {
+      const target = path.join(staging, "assets", asset.name);
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.copyFile(asset.file, target);
+    }
+    await write("vercel.json", `${JSON.stringify(vercelConfig(), null, 2)}
+`, "config", "generated");
+    const plan = { ...prepared.plan, files: [...files, ...prepared.plan.files] };
+    await fs.writeFile(path.join(staging, "export-manifest.json"), `${JSON.stringify(plan, null, 2)}
+`);
+    await scanForLeaks(staging, project.root);
+    await fs.rm(out, { recursive: true, force: true });
+    await fs.rename(staging, out);
+    await fs.chmod(out, 493);
+  } catch (error) {
+    await fs.rm(staging, { recursive: true, force: true });
+    throw error;
+  }
+  return out;
+}
+function vercelConfig() {
+  return {
+    $schema: "https://openapi.vercel.sh/vercel.json",
+    framework: null,
+    buildCommand: "",
+    installCommand: "",
+    outputDirectory: ".",
+    headers: [{
+      source: "/(.*)",
+      headers: [
+        { key: "Content-Security-Policy", value: "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data: blob:; worker-src 'self' blob:; connect-src 'self' blob: data:; frame-ancestors 'none'; base-uri 'none'; form-action 'none'" },
+        { key: "Referrer-Policy", value: "no-referrer" },
+        { key: "X-Robots-Tag", value: "noindex, nofollow" },
+        { key: "X-Content-Type-Options", value: "nosniff" }
+      ]
+    }]
+  };
+}
+var LEAK_PATTERNS = [
+  ["libSQL/Turso URL", /libsql:\/\/|\.turso\.io/i],
+  ["local path", /\/Users\/[A-Za-z]|\/home\/[a-z][a-z0-9_-]*\/|[A-Z]:\\\\Users\\\\|file:\/\//],
+  ["home-relative path", /["'`\s(]~\/[A-Za-z._-]/],
+  ["Observatory endpoint", /observatory\.field\.io|observatory-api|\/api\/observatory/i],
+  ["bearer token", /Bearer\s+[A-Za-z0-9._~+/-]{16,}/],
+  ["API key", /\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}|\bghp_[A-Za-z0-9]{20,}|\bgithub_pat_[A-Za-z0-9_]{20,}|\bxox[abprs]-[A-Za-z0-9-]{10,}|\bAKIA[0-9A-Z]{16}\b|\bAIza[0-9A-Za-z_-]{30,}/],
+  ["JWT", /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\./],
+  ["private key", /-----BEGIN [A-Z ]*PRIVATE KEY-----/],
+  ["env file reference", /(?:^|[^A-Za-z0-9_])\.env(?:\.local|\.production|\.development)?["'`]/]
+];
+async function scanForLeaks(directory, projectRoot) {
+  const secrets = await secretValues(projectRoot);
+  const findings = [];
+  for (const file of await filesUnder(directory)) {
+    const name = path.relative(directory, file);
+    if (/(^|\/)\.env/.test(name) || /(^|\/)\.vercel\//.test(name)) {
+      findings.push(`${name}: environment or link file in the site`);
+      continue;
+    }
+    if (/(^|\/)licensed\//.test(name)) {
+      findings.push(`${name}: licensed file in the site`);
+      continue;
+    }
+    if (!/\.(js|mjs|html|json|svg|txt|css|md|map|xml)$/i.test(name)) continue;
+    const text = await fs.readFile(file, "utf8");
+    for (const [label, pattern] of LEAK_PATTERNS) {
+      const match = pattern.exec(text);
+      if (match) findings.push(`${name}: ${label} near "${excerpt(text, match.index)}"`);
+    }
+    for (const [key, value] of secrets) if (text.includes(value)) findings.push(`${name}: the value of ${key}`);
+  }
+  if (findings.length) throw new Error(`The export was stopped: it would publish sensitive content.
+${findings.map((line) => `  ${line}`).join("\n")}`);
+}
+async function secretValues(projectRoot) {
+  const secret = /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|AUTH|CREDENTIAL|DATABASE_URL|DB_URL|_URL|_DSN)$/i;
+  const values = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(process.env)) if (value && value.length >= 12 && secret.test(key)) values.set(key, value);
+  for (const entry of await fs.readdir(projectRoot).catch(() => [])) {
+    if (!entry.startsWith(".env")) continue;
+    const text = await fs.readFile(path.join(projectRoot, entry), "utf8").catch(() => "");
+    for (const line of text.split("\n")) {
+      const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*["']?([^"'\n]*)["']?\s*$/.exec(line);
+      if (match && match[2].length >= 8) values.set(`${match[1]} (${entry})`, match[2]);
+    }
+  }
+  values.set("your home directory", os.homedir());
+  return [...values];
+}
+async function deployVercel(directory, projectName, scope, log, intendedPublic) {
+  const team = scope ?? "field-io";
+  const scratch = await fs.mkdtemp(path.join(os.tmpdir(), "cascade-vercel-"));
+  try {
+    await run("vercel", ["link", "--yes", "--project", projectName, "--scope", team], { cwd: scratch });
+    const link = await fs.readFile(path.join(scratch, ".vercel", "project.json"), "utf8");
+    await fs.mkdir(path.join(directory, ".vercel"), { recursive: true });
+    await fs.writeFile(path.join(directory, ".vercel", "project.json"), link);
+  } finally {
+    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:
+${stdout}`);
+  const response = await fetch(`https://${projectName}.vercel.app/`, { redirect: "manual" });
+  const verdict = publicVerdict(response.status, intendedPublic);
+  if (verdict === "public-as-intended") log(`Public, as intended (--public): https://${projectName}.vercel.app`);
+  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;
+}
+function publicVerdict(status, intendedPublic) {
+  if (status !== 200) return "protected";
+  return intendedPublic ? "public-as-intended" : "public-by-accident";
+}
+function sveltePlugin(projectRoot) {
+  return {
+    name: "cascade-editor-svelte",
+    setup(builder) {
+      builder.onLoad({ filter: /\.svelte$/ }, async (args) => {
+        let compiler;
+        try {
+          compiler = createRequire(path.join(projectRoot, "package.json"))("svelte/compiler");
+        } catch {
+          return { errors: [{ text: `${args.path}: install svelte in the project to use a Svelte panel` }] };
+        }
+        const source = await fs.readFile(args.path, "utf8");
+        const output = compiler.compile(source, { filename: args.path, generate: "client", css: "injected" });
+        return { contents: output.js.code, loader: "js", resolveDir: path.dirname(args.path) };
+      });
+    }
+  };
+}
+async function literalAssets(document, modules) {
+  const registrations = modules.map((item) => ({
+    kind: "definition-v1",
+    moduleId: item.id,
+    definition: item.definition,
+    loadExecute: async () => {
+      throw new Error("Exports never execute project code");
+    }
+  }));
+  const runtime = createRuntime({ host: createBrowserRuntimeHost({
+    modules: { resolve: async (id) => registrations.find((item) => item.moduleId === id) ?? null },
+    assets: {},
+    gpu: {}
+  }), nodes: registrations });
+  const found = [];
+  try {
+    const graph = await runtime.load(document);
+    const blocking = graph.preflight().filter((item) => !PREFLIGHT_WARNING_CODES.has(item.code));
+    if (blocking.length) throw new Error(`This graph cannot run in the browser:
+${blocking.map((item) => `  ${item.path ?? ""} ${item.code}: ${item.message}`).join("\n")}`);
+    for (const node of graph.inspect().nodes)
+      for (const [name, port] of [...Object.entries(node.inputs), ...Object.entries(node.props)]) {
+        if (port.type !== "image" && port.type !== "asset") continue;
+        const value = port.value;
+        const asset = typeof value === "string" ? value : value && typeof value === "object" && "path" in value ? value.path : void 0;
+        if (typeof asset === "string" && asset && !/^(https?:|data:|blob:)/.test(asset)) found.push({ path: asset, where: `${node.id}.${name}` });
+      }
+  } finally {
+    await runtime.dispose();
+  }
+  return found;
+}
+var FONT_FILE = /\.(woff2?|ttf|otf)$/i;
+function checkedFont(font) {
+  const where = `editor.fonts ${JSON.stringify(font?.family ?? "")}`;
+  if (!font || typeof font.family !== "string" || !font.family.trim()) throw new Error(`${where}: needs a family name`);
+  if (font.license !== "OFL-1.1")
+    throw new Error(`${where}: only OFL-1.1 fonts are exported (got ${JSON.stringify(font.license)}); a licensed font never leaves the project`);
+  if (typeof font.file !== "string" || !FONT_FILE.test(font.file)) throw new Error(`${where}: file must be a .woff2, .woff, .ttf or .otf`);
+  return checkedAssetPath(font.file, where);
+}
+function fontSources(fonts) {
+  const url = (file) => `./assets/${file.replace(/^\.\//, "").split("/").map(encodeURIComponent).join("/")}`;
+  const css = fonts.map((font) => `@font-face{font-family:${JSON.stringify(font.family)};src:url(${JSON.stringify(url(font.file))});font-weight:${font.weight ?? "normal"};font-style:${font.style ?? "normal"};font-display:swap}`).join("");
+  const list = JSON.stringify(fonts.map((font) => ({ family: font.family, url: url(font.file), weight: String(font.weight ?? "normal"), style: font.style ?? "normal" })));
+  const loader = fonts.length ? `await (async()=>{const s=globalThis;if(typeof FontFace==='undefined'||!s.fonts)return;await Promise.all(${list}.map(async(f)=>{try{const face=new FontFace(f.family,'url('+new URL(f.url,import.meta.url).href+')',{weight:f.weight,style:f.style});s.fonts.add(await face.load())}catch(e){console.warn('Font '+f.family+' did not load',e)}}))})();` : "";
+  return { css, loader };
+}
+function checkedAssetPath(asset, where) {
+  const name = String(asset).replace(/^\.\//, "");
+  if (!name || name.includes("\\") || path.isAbsolute(name) || name.split("/").some((part) => !part || part === ".." || part.startsWith(".")))
+    throw new Error(`${where}: ${asset} must be a visible project-relative file`);
+  if (name.split("/").includes("licensed"))
+    throw new Error(`${where}: ${asset} is under a licensed/ directory and is never exported`);
+  return name;
+}
+async function addAsset(project, assets, name, kind, from) {
+  if (assets.has(name)) return;
+  const file = project.resolve(name);
+  const real = await fs.realpath(file);
+  if (real.split(path.sep).includes("licensed")) throw new Error(`${name} resolves into a licensed/ directory and is never exported`);
+  if (!(await fs.stat(real)).isFile()) throw new Error(`${name} is not a file`);
+  assets.set(name, { name, file: real, kind, from });
+}
+async function refuseIgnored(root, name) {
+  try {
+    await run("git", ["check-ignore", "-q", "--", name], { cwd: root });
+  } catch (error) {
+    const code = error.code;
+    if (code === 1 || code === 128 || code === "ENOENT") return;
+    throw error;
+  }
+  throw new Error(`${name} is gitignored, so it is not exported. Commit it, or select another file.`);
+}
+function stripNode(node) {
+  return {
+    id: node.id,
+    ...node.module ? { module: node.module } : {},
+    ...node.type ? { type: node.type } : {},
+    ...node.parent ? { parent: node.parent } : {},
+    ...node.inputs ? { inputs: node.inputs } : {},
+    ...node.props ? { props: node.props } : {}
+  };
+}
+async function filesUnder(directory) {
+  const entries = await fs.readdir(directory, { withFileTypes: true });
+  const nested = await Promise.all(entries.map(async (entry) => {
+    const file = path.join(directory, entry.name);
+    return entry.isDirectory() ? filesUnder(file) : [file];
+  }));
+  return nested.flat();
+}
+function excerpt(text, index) {
+  return text.slice(Math.max(0, index - 20), index + 40).replace(/\s+/g, " ");
+}
+function escapeHtml(text) {
+  return text.replace(/[&<>"]/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[char]);
+}
+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
+};
+//# sourceMappingURL=chunk-WKURDVYP.js.map