@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-EUIAC3U3.js

@@ -0,0 +1,3006 @@
+import {
+  builtinNodeRegistration,
+  builtinNodeRegistrations,
+  headlessBuiltin,
+  headlessBuiltinRegistrations
+} from "./chunk-36P5K3SD.js";
+import {
+  imagePath,
+  sequenceFileName,
+  sequenceWidth
+} from "./chunk-ICH7N5PN.js";
+import {
+  DEFAULT_GRAPH_SEED,
+  bundleFieldType,
+  bundleSchemasCompatible,
+  bundleValueProblem,
+  createGpuHost,
+  graphSeed,
+  isBundleValue,
+  isGpuHost,
+  nodeSeed,
+  seededRandom,
+  selectBundleFields,
+  suggestName,
+  unknownFieldMessage
+} from "./chunk-GFS6W3C5.js";
+import {
+  PropAnimator,
+  isBoundProp
+} from "./chunk-HFHWYL55.js";
+import {
+  DEFAULT_FPS,
+  MIN_FRAME,
+  bundleFieldReferences,
+  deserializeChannel,
+  frameRange,
+  isEmptyChannel,
+  parseBundleFieldPath,
+  remoteBundlePath
+} from "./chunk-CO22XHNG.js";
+import {
+  ProjectRoot,
+  extractNodeDefinition
+} from "./chunk-RQZ4SX5R.js";
+import {
+  CAPABILITIES_BY_ENVIRONMENT,
+  validateNodeDefinition
+} from "./chunk-A4OAMOZH.js";
+import {
+  canConnectTypes
+} from "./chunk-BIJO5OFS.js";
+
+// src/cli/projectRuntime.ts
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
+import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
+import { existsSync } from "node:fs";
+import ts from "typescript";
+import { build } from "esbuild";
+
+// packages/runtime/src/error.ts
+var CascadeRuntimeError = class extends Error {
+  constructor(code, diagnostics, message = diagnostics[0]?.message ?? code) {
+    super(message);
+    this.code = code;
+    this.diagnostics = diagnostics;
+    this.name = "CascadeRuntimeError";
+  }
+};
+
+// packages/runtime/src/runtime.ts
+var PREFLIGHT_WARNING_CODES = /* @__PURE__ */ new Set([
+  "runtime/preflight-environment",
+  "runtime/stray-params",
+  "runtime/unknown-props"
+]);
+var RUN_TOLERATED_CODES = /* @__PURE__ */ new Set([
+  "runtime/stray-params",
+  "runtime/unknown-props"
+]);
+var MutableAbortSignal = class {
+  constructor(report) {
+    this.report = report;
+    this.aborted = false;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  addEventListener(_type, listener, options) {
+    if (this.aborted) this.call(listener);
+    else if (options?.once) {
+      const once = () => {
+        this.listeners.delete(once);
+        listener();
+      };
+      this.listeners.add(once);
+    } else this.listeners.add(listener);
+  }
+  removeEventListener(_type, listener) {
+    this.listeners.delete(listener);
+  }
+  abort(reason) {
+    if (this.aborted) return;
+    this.aborted = true;
+    this.reason = reason;
+    for (const listener of [...this.listeners]) this.call(listener);
+    this.listeners.clear();
+  }
+  call(listener) {
+    try {
+      listener();
+    } catch (error) {
+      this.report({
+        phase: "run",
+        code: "runtime/abort-listener-failed",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+};
+function createRuntime(options) {
+  return new Runtime(options.host, [...builtinNodeRegistrations, ...options.nodes ?? []]);
+}
+var Runtime = class {
+  constructor(host, registrations) {
+    this.host = host;
+    this.registrations = /* @__PURE__ */ new Map();
+    this.graphs = /* @__PURE__ */ new Set();
+    this.sealed = false;
+    this.disposed = false;
+    for (const registration of registrations) this.registerNode(registration);
+  }
+  registerNode(registration) {
+    if (this.sealed || this.disposed)
+      misuse(
+        "runtime/registry-sealed",
+        "Node registrations are sealed after the first load"
+      );
+    if (this.registrations.has(registration.moduleId))
+      misuse(
+        "runtime/duplicate-registration",
+        `Duplicate registration ${registration.moduleId}`
+      );
+    this.registrations.set(
+      registration.moduleId,
+      snapshotRegistration(registration)
+    );
+  }
+  async load(document2) {
+    if (this.disposed) misuse("runtime/disposed", "Runtime is disposed");
+    this.sealed = true;
+    const nodes = [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const authored of document2.nodes) {
+      if (!authored.id || ids.has(authored.id))
+        misuse(
+          "runtime/invalid-node-id",
+          `Invalid or duplicate node id ${authored.id}`
+        );
+      ids.add(authored.id);
+      const moduleId2 = authored.module ?? authored.type;
+      if (!moduleId2)
+        misuse("runtime/missing-module", `Node ${authored.id} has no module`);
+      const resolved = this.registrations.get(moduleId2) ?? await this.host.modules.resolve(moduleId2);
+      if (!resolved)
+        misuse(
+          "runtime/module-not-found",
+          `Module ${moduleId2} was not registered`
+        );
+      if (resolved.moduleId !== moduleId2)
+        misuse(
+          "runtime/module-identity",
+          `Resolver returned ${resolved.moduleId} for ${moduleId2}`
+        );
+      const snapshot2 = snapshotRegistration(resolved);
+      if (snapshot2.kind === "legacy-dynamic")
+        misuse(
+          "runtime/legacy-adapter-required",
+          `Legacy module ${moduleId2} requires the explicit legacy adapter`
+        );
+      const registration = specializeCoreRegistration(
+        snapshot2,
+        authored,
+        document2.nodes
+      );
+      const diagnostics = validateNodeDefinition(registration.definition);
+      if (diagnostics.length)
+        throw new CascadeRuntimeError(
+          "runtime/definition-invalid",
+          diagnostics
+        );
+      nodes.push(materialize(authored, registration));
+    }
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    validateHierarchy(nodes, byId);
+    const connections = (document2.connections ?? []).map(
+      (connection, index) => materializeConnection(connection, index, byId)
+    );
+    validateCardinality(byId, connections);
+    validateTopology(nodes, connections);
+    const graph = new Graph(
+      this.host,
+      nodes,
+      connections,
+      () => this.graphs.delete(graph),
+      document2.annotations,
+      graphSeed(document2)
+    );
+    const fps = document2.timeline?.fps;
+    if (typeof fps === "number" && Number.isFinite(fps) && fps > 0) graph.setFps(fps);
+    this.graphs.add(graph);
+    return graph;
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await Promise.all([...this.graphs].map((graph) => graph.dispose()));
+    await this.host.legacyShell?.dispose?.();
+  }
+};
+var Graph = class {
+  constructor(host, nodes, connections, onDispose, annotations = [], seed = DEFAULT_GRAPH_SEED) {
+    this.host = host;
+    this.nodes = nodes;
+    this.connections = connections;
+    this.onDispose = onDispose;
+    this.seed = seed;
+    this.graphState = "ready";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.diagnostics = [];
+    this.runCounter = 0;
+    this.frame = MIN_FRAME;
+    this.fps = DEFAULT_FPS;
+    /**
+     * The state a feedback container is carrying, while it is running.
+     *
+     * Runtime state on the instance rather than on the node, because it is alive
+     * only during one container's loop and a node's `outputs` map is the graph's
+     * result — putting a half-finished step in there would make a partially
+     * simulated value readable by anything that inspects outputs mid-run.
+     *
+     * Keyed by container id so nested feedback works: an outer loop's carried
+     * state survives an inner loop running to completion inside one of its steps.
+     */
+    this.feedbackState = /* @__PURE__ */ new Map();
+    this.byId = new Map(nodes.map((node) => [node.id, node]));
+    const byInput = /* @__PURE__ */ new Map();
+    const byNode = /* @__PURE__ */ new Map();
+    const connectedInputs = /* @__PURE__ */ new Set();
+    const connectedOutputs = /* @__PURE__ */ new Set();
+    for (const connection of connections) {
+      connectedInputs.add(
+        `${connection.target.nodeId}\0${connection.target.inputName}`
+      );
+      connectedOutputs.add(
+        `${connection.source.nodeId}\0${connection.source.outputName}`
+      );
+      if (connection.kind !== "data") continue;
+      const inputKey = `${connection.target.nodeId}\0${connection.target.inputName}`;
+      const inputConnections = byInput.get(inputKey) ?? [];
+      inputConnections.push(connection);
+      byInput.set(inputKey, inputConnections);
+      const nodeConnections = byNode.get(connection.target.nodeId) ?? [];
+      nodeConnections.push(connection);
+      byNode.set(connection.target.nodeId, nodeConnections);
+    }
+    this.dataConnectionsByInput = new Map(
+      [...byInput].map(([key, inputConnections]) => [
+        key,
+        Object.freeze(
+          inputConnections.sort(
+            (first, second) => (first.variadicIndex ?? first.order) - (second.variadicIndex ?? second.order)
+          )
+        )
+      ])
+    );
+    this.dataConnectionsByNode = new Map(
+      [...byNode].map(([key, nodeConnections]) => [
+        key,
+        Object.freeze(
+          nodeConnections.sort((first, second) => first.order - second.order)
+        )
+      ])
+    );
+    this.connectedInputs = connectedInputs;
+    this.connectedOutputs = connectedOutputs;
+    this.graphInputs = graphBoundaries(nodes, "cascade.core.Input", "inputName");
+    this.graphOutputs = graphBoundaries(nodes, "cascade.core.Output", "outputName");
+    this.authoredAnnotations = Object.freeze(
+      annotations.map((annotation) => snapshot(annotation))
+    );
+    this.animator = new PropAnimator({
+      nodes,
+      node: (id) => this.byId.get(id),
+      inputNode: (node, index) => {
+        const feeding = this.dataConnectionsByNode.get(node.id) ?? [];
+        const source = feeding[index]?.source.nodeId;
+        return (source ? this.byId.get(source) : void 0) ?? null;
+      },
+      inputValue: (node, name) => this.dataInputValue(node, name),
+      // A failed expression has already fallen back to the stored value, so it
+      // is a diagnostic rather than a stopped run — but it is never silent: a
+      // parameter that quietly reverts is the hardest fault to see in a
+      // hundred rendered frames.
+      report: (nodeId, propName, error) => this.reportDiagnostic({
+        phase: "run",
+        code: "runtime/expression-failed",
+        message: `${nodeId}.${propName}: ${error}`,
+        path: `${nodeId}.${propName}`
+      })
+    });
+    this.animator.setFps(this.fps);
+    this.animator.setFrame(this.frame);
+    this.animator.resolveAll();
+  }
+  get state() {
+    return this.graphState;
+  }
+  /**
+   * Everything that would stop this host running the graph, without running
+   * it: a node whose environment this host is not, a bridged node that cannot
+   * be bridged, a declared capability this host does not install. Empty means
+   * the graph clears the same gate `run` puts it through.
+   */
+  preflight() {
+    return this.preflightDiagnostics(this.nodes);
+  }
+  inspect() {
+    const nodes = this.nodes.map((node) => ({
+      id: node.id,
+      moduleId: node.moduleId,
+      runsOn: node.definition.runsOn,
+      ...node.parent ? { parent: node.parent } : {},
+      inputs: Object.fromEntries(
+        Object.entries(node.definition.inputs ?? {}).map(
+          ([name, definition]) => [
+            name,
+            {
+              kind: definition.kind,
+              type: definition.kind === "trigger" ? "trigger" : definition.type,
+              connected: this.connectedInputs.has(`${node.id}\0${name}`),
+              ...definition.kind === "data" ? { value: snapshot(node.inputs[name]) } : {}
+            }
+          ]
+        )
+      ),
+      outputs: Object.fromEntries(
+        Object.entries(node.definition.outputs ?? {}).map(
+          ([name, definition]) => [
+            name,
+            {
+              kind: definition.kind,
+              type: definition.kind === "trigger" ? "trigger" : definition.type,
+              connected: this.connectedOutputs.has(`${node.id}\0${name}`),
+              ...definition.kind === "data" && node.outputs.has(name) ? { value: snapshot(node.outputs.get(name)) } : {}
+            }
+          ]
+        )
+      ),
+      props: Object.fromEntries(
+        Object.entries(node.definition.props ?? {}).map(
+          ([name, definition]) => [
+            name,
+            { type: definition.type, value: snapshot(node.props[name]) }
+          ]
+        )
+      )
+    }));
+    return Object.freeze({
+      state: this.graphState,
+      interface: Object.freeze({
+        inputs: boundaryInspection(this.graphInputs, "output"),
+        outputs: boundaryInspection(this.graphOutputs, "output")
+      }),
+      nodes: Object.freeze(nodes),
+      connections: Object.freeze(
+        this.connections.map(
+          (connection) => Object.freeze({
+            source: Object.freeze({ ...connection.source }),
+            target: Object.freeze({ ...connection.target })
+          })
+        )
+      ),
+      diagnostics: Object.freeze([...this.diagnostics])
+    });
+  }
+  async setInput(nodeId, inputName2, value) {
+    this.requireReady();
+    const node = this.requireNode(nodeId);
+    const definition = node.definition.inputs?.[inputName2];
+    if (!definition || definition.kind !== "data")
+      misuse(
+        "runtime/invalid-input",
+        `${nodeId}.${inputName2} is not a data input`
+      );
+    node.inputs[inputName2] = runtimeValue(
+      value,
+      definition.type,
+      !("default" in definition),
+      `${nodeId}.${inputName2}`
+    );
+  }
+  setGraphInput(name, value) {
+    const node = this.graphInputs.get(name);
+    if (!node)
+      return Promise.reject(runtimeError("runtime/graph-input-not-found", `Unknown graph input ${name}`));
+    return this.setInput(node.id, "value", value);
+  }
+  async setProp(nodeId, propName, value) {
+    this.requireReady();
+    const node = this.requireNode(nodeId);
+    if (isStructuralProp(node, propName))
+      misuse(
+        "runtime/structural-prop",
+        `${nodeId}.${propName} is structural and requires a graph reload`
+      );
+    if (!node.definition.props?.[propName])
+      misuse("runtime/invalid-prop", `${nodeId}.${propName} is not a prop`);
+    const resolved = runtimeValue(
+      value,
+      node.definition.props[propName].type,
+      false,
+      `${nodeId}.${propName}`
+    );
+    node.props[propName] = resolved;
+    this.rebind(node, propName, resolved);
+  }
+  /**
+   * Keep a bound prop's STORED value in step with a direct write.
+   *
+   * A channel or an expression still wins on the next resolve — setting a
+   * keyed parameter's value does not delete its keys, in Studio or here — but
+   * the value written is the one the parameter falls back to, so dropping it
+   * would make a later `clearChannel` reinstate a number nobody chose.
+   */
+  rebind(node, propName, value) {
+    const binding = node.bindings[propName];
+    if (binding) node.bindings[propName] = { ...binding, value };
+  }
+  reportDiagnostic(diagnostic) {
+    this.diagnostics.push(diagnostic);
+    this.emit({ type: "diagnostic", diagnostic });
+  }
+  async applyPreset(preset) {
+    this.requireReady();
+    if (preset.version !== 1)
+      misuse("runtime/invalid-preset", "Preset version must be 1");
+    const inputDrafts = [];
+    const propDrafts = [];
+    for (const [nodeId, values] of Object.entries(preset.nodes)) {
+      const node = this.requireNode(nodeId);
+      for (const [name, value] of Object.entries(values.inputs ?? {})) {
+        const definition = node.definition.inputs?.[name];
+        if (!definition || definition.kind !== "data")
+          misuse(
+            "runtime/invalid-input",
+            `${nodeId}.${name} is not a data input`
+          );
+        inputDrafts.push([
+          node,
+          name,
+          runtimeValue(
+            value,
+            definition.type,
+            !("default" in definition),
+            `${nodeId}.${name}`
+          )
+        ]);
+      }
+      for (const [name, value] of Object.entries(values.props ?? {})) {
+        const definition = node.definition.props?.[name];
+        if (!definition)
+          misuse("runtime/invalid-prop", `${nodeId}.${name} is not a prop`);
+        if (isStructuralProp(node, name))
+          misuse(
+            "runtime/structural-prop",
+            `${nodeId}.${name} is structural and cannot be changed by a preset`
+          );
+        propDrafts.push([
+          node,
+          name,
+          runtimeValue(value, definition.type, false, `${nodeId}.${name}`)
+        ]);
+      }
+    }
+    for (const [node, name, value] of inputDrafts) node.inputs[name] = value;
+    for (const [node, name, value] of propDrafts) {
+      node.props[name] = value;
+      this.rebind(node, name, value);
+    }
+  }
+  /**
+   * The frame this graph is cooking at, and the rate frames are counted in.
+   *
+   * Separate from `run` so a caller can scrub without cooking — and so that
+   * `setFrame` then `inspect()` reports a keyed parameter at that frame, which
+   * is what a panel needs and what `run` alone cannot give it.
+   */
+  setFrame(frame) {
+    if (!Number.isFinite(frame)) return;
+    this.frame = Math.max(MIN_FRAME, frame);
+    this.animator.setFrame(this.frame);
+    this.animator.resolveAll();
+  }
+  setFps(fps) {
+    if (!Number.isFinite(fps)) return;
+    this.fps = Math.max(1, fps);
+    this.animator.setFps(this.fps);
+    this.animator.resolveAll();
+  }
+  getFrame() {
+    return this.frame;
+  }
+  getFps() {
+    return this.fps;
+  }
+  run(options = {}) {
+    if (options.fps !== void 0) this.setFps(options.fps);
+    if (options.frame !== void 0) this.setFrame(options.frame);
+    else this.animator.resolveAll();
+    return this.trackRun(
+      options.target ?? { kind: "all" },
+      options.signal,
+      options.runId,
+      void 0,
+      options.reuse === true || options.reuse === "strict" ? options.reuse : false
+    );
+  }
+  trigger(nodeId, inputName2, payload, options = {}) {
+    const node = this.requireNode(nodeId);
+    if (node.definition.inputs?.[inputName2]?.kind !== "trigger")
+      return Promise.reject(
+        runtimeError(
+          "runtime/invalid-trigger",
+          `${nodeId}.${inputName2} is not a trigger input`
+        )
+      );
+    return this.trackRun(
+      { kind: "node", nodeId },
+      options.signal,
+      options.runId,
+      { nodeId, inputName: inputName2, payload }
+    );
+  }
+  cancel(reason = "Cancelled") {
+    if (!this.active || this.active.signal.aborted) return;
+    this.graphState = "cancelling";
+    this.active.reason = reason;
+    this.active.signal.abort(reason);
+    this.emit({ type: "run:cancel", runId: this.active.runId, reason });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  getOutput(nodeId, outputName2) {
+    return snapshot(this.requireNode(nodeId).outputs.get(outputName2));
+  }
+  getGraphOutput(name) {
+    const node = this.graphOutputs.get(name);
+    if (!node)
+      misuse("runtime/graph-output-not-found", `Unknown graph output ${name}`);
+    return this.getOutput(node.id, "output");
+  }
+  getOutputs(nodeId) {
+    return immutableMap(
+      [...this.requireNode(nodeId).outputs].map(([name, value]) => [
+        name,
+        snapshot(value)
+      ])
+    );
+  }
+  dispose() {
+    this.disposal ??= this.performDispose();
+    return this.disposal;
+  }
+  trackRun(target, signal, runId, injection, reuse = false) {
+    const running = this.executeRun(target, signal, runId, injection, reuse);
+    this.activeRun = running;
+    const clear = () => {
+      if (this.activeRun === running) this.activeRun = void 0;
+    };
+    void running.then(clear, clear);
+    return running;
+  }
+  async performDispose() {
+    if (this.graphState === "disposed") return;
+    this.cancel("Graph disposed");
+    try {
+      await this.activeRun;
+    } catch {
+    }
+    this.graphState = "disposed";
+    this.listeners.clear();
+    this.onDispose();
+  }
+  async executeRun(target, externalSignal, requestedId, injection, reuse = false) {
+    this.requireReady();
+    const runId = requestedId ?? `run-${this.runCounter++}`;
+    const signal = new MutableAbortSignal(
+      (diagnostic) => this.host.report(diagnostic)
+    );
+    this.active = { runId, signal };
+    this.graphState = "running";
+    const startedAt = this.host.now();
+    const runDiagnostics = [];
+    this.emit({ type: "run:start", runId, target });
+    const relay = () => this.cancel(
+      typeof externalSignal?.reason === "string" ? externalSignal.reason : "Cancelled by external signal"
+    );
+    if (externalSignal?.aborted) relay();
+    else externalSignal?.addEventListener("abort", relay, { once: true });
+    let executionStarted = false;
+    try {
+      const selection = injection ? {
+        reachable: this.triggerReachable(injection.nodeId),
+        initial: this.triggerDataAncestors(injection.nodeId)
+      } : this.runSelection(target);
+      const { reachable, initial } = selection;
+      this.assertPreflight(reachable);
+      if (!signal.aborted)
+        await Promise.all(
+          reachable.filter((node) => !this.isRemote(node)).map((node) => this.loadExecute(node))
+        );
+      executionStarted = true;
+      const queue = [];
+      let sequence = 0;
+      const enqueue = (nodeId, inputName2, payload, source) => {
+        const event = snapshot({
+          id: `${runId}:${sequence}`,
+          runId,
+          sequence: sequence++,
+          ...payload === void 0 ? {} : { payload: snapshot(payload) },
+          source
+        });
+        queue.push({ nodeId, inputName: inputName2, event });
+        this.emit({ type: "trigger:queued", runId, nodeId, inputName: inputName2, event });
+      };
+      const insideFeedback = this.feedbackDescendants();
+      const ordered = topological(this.nodes, this.connections).filter(
+        (node) => initial.includes(node) && !insideFeedback.has(node.id)
+      );
+      const cooked = /* @__PURE__ */ new Set();
+      for (const node of ordered) {
+        if (signal.aborted) break;
+        if (reuse && this.reusable(node) && !(reuse === "strict" && this.feedsFrom(node, cooked))) {
+          this.emit({ type: "node:start", runId, nodeId: node.id });
+          this.emit({ type: "node:complete", runId, nodeId: node.id });
+          continue;
+        }
+        await this.executeNode(node, runId, signal, {}, enqueue);
+        cooked.add(node.id);
+        if (!signal.aborted) node.lastCook = this.cookKey(node);
+      }
+      if (injection && !signal.aborted)
+        enqueue(injection.nodeId, injection.inputName, injection.payload, {
+          kind: "external"
+        });
+      while (queue.length && !signal.aborted) {
+        const next = queue.shift();
+        this.emit({
+          type: "trigger:delivered",
+          runId,
+          nodeId: next.nodeId,
+          inputName: next.inputName,
+          event: next.event
+        });
+        await this.executeNode(
+          this.requireNode(next.nodeId),
+          runId,
+          signal,
+          { [next.inputName]: next.event },
+          enqueue
+        );
+      }
+      return this.finish(
+        runId,
+        signal.aborted ? "cancelled" : "completed",
+        startedAt,
+        runDiagnostics
+      );
+    } catch (error) {
+      if (!executionStarted && error instanceof CascadeRuntimeError)
+        throw error;
+      const diagnostic = {
+        phase: "run",
+        code: "runtime/execution-failed",
+        message: error instanceof Error ? error.message : String(error)
+      };
+      runDiagnostics.push(diagnostic);
+      this.diagnostics.push(diagnostic);
+      this.emit({ type: "diagnostic", runId, diagnostic });
+      return this.finish(
+        runId,
+        signal.aborted ? "cancelled" : "failed",
+        startedAt,
+        runDiagnostics
+      );
+    } finally {
+      externalSignal?.removeEventListener("abort", relay);
+      if (!this.isDisposed()) this.graphState = "ready";
+      this.active = void 0;
+    }
+  }
+  async executeNode(node, runId, signal, triggers, enqueue) {
+    this.emit({ type: "node:start", runId, nodeId: node.id });
+    if (node.moduleId === "cascade.core.Previous") {
+      const container = this.enclosingFeedback(node);
+      const state = container ? this.feedbackState.get(container) : void 0;
+      if (state) {
+        node.outputs.set("value", state.value);
+        node.outputs.set("step", state.step);
+        this.emit({ type: "node:complete", runId, nodeId: node.id });
+        return;
+      }
+    }
+    const inputs = Object.fromEntries(
+      Object.entries(node.definition.inputs ?? {}).map(([name, definition]) => {
+        if (definition.kind === "trigger") return [name, triggers[name]];
+        if (node.moduleId === "cascade.core.Input" && name === "value" && node.parent) {
+          const parent = this.requireNode(node.parent);
+          const index = integerProp(node.props.inputIndex);
+          return [name, this.dataInputValue(parent, `input_${index}`)];
+        }
+        const connections = this.dataConnectionsByInput.get(`${node.id}\0${name}`) ?? [];
+        if (definition.variadic) {
+          const values = connections.map(
+            (connection2) => this.requireNode(connection2.source.nodeId).outputs.get(
+              connection2.source.outputName
+            )
+          );
+          if (!values.length && node.inputs[name] !== void 0)
+            values.push(node.inputs[name]);
+          return [name, Object.freeze(values)];
+        }
+        const connection = connections[0];
+        const value = connection ? this.requireNode(connection.source.nodeId).outputs.get(
+          connection.source.outputName
+        ) : node.inputs[name];
+        return [
+          name,
+          definition.type === "bundle" && definition.fields ? selectBundleFields(value, definition.fields) : value
+        ];
+      })
+    );
+    Object.freeze(inputs);
+    if (readsBundleFields(node)) this.animator.resolveNode(node);
+    if (this.isRemote(node)) {
+      const bridge = this.host.capabilities.serverBridge;
+      if (!bridge)
+        throw runtimeError(
+          "runtime/bridge-missing",
+          `No server bridge for ${node.moduleId}`
+        );
+      const progress2 = {
+        report: (event) => this.emit({
+          type: "node:progress",
+          runId,
+          nodeId: node.id,
+          ...event
+        })
+      };
+      const response = await bridge.execute(
+        {
+          moduleId: node.moduleId,
+          nodeId: node.id,
+          inputs,
+          props: Object.freeze({ ...node.props })
+        },
+        { signal, progress: progress2 }
+      );
+      for (const diagnostic of response.diagnostics) {
+        this.diagnostics.push(diagnostic);
+        this.emit({ type: "diagnostic", runId, diagnostic });
+      }
+      for (const name of Object.keys(node.definition.outputs ?? {}))
+        if (name in response.outputs) {
+          const definition = node.definition.outputs?.[name];
+          if (!definition || definition.kind !== "data") continue;
+          const value = outputValue(
+            response.outputs[name],
+            definition,
+            `${node.id}.${name}`
+          );
+          node.outputs.set(name, value);
+          this.emit({
+            type: "node:output",
+            runId,
+            nodeId: node.id,
+            outputName: name,
+            value
+          });
+        }
+      this.emit({ type: "node:complete", runId, nodeId: node.id });
+      return;
+    }
+    if (!node.execute)
+      throw runtimeError(
+        "runtime/executor-missing",
+        `Executor ${node.moduleId} was not loaded`
+      );
+    const pendingData = /* @__PURE__ */ new Map();
+    const pendingTriggers = [];
+    const outputs = Object.fromEntries(
+      Object.entries(node.definition.outputs ?? {}).map(
+        ([name, definition]) => [
+          name,
+          definition.kind === "trigger" ? {
+            trigger: (payload) => pendingTriggers.push({
+              name,
+              ...payload === void 0 ? {} : { payload: snapshot(payload) }
+            })
+          } : {
+            set: (value) => pendingData.set(
+              name,
+              outputValue(value, definition, `${node.id}.${name}`)
+            )
+          }
+        ]
+      )
+    );
+    const capabilityEntries = [];
+    for (const name of node.definition.capabilities ?? []) {
+      const installed = this.host.capabilities[name];
+      if (name === "gpu" && isGpuHost(installed)) {
+        await installed.ensure();
+        capabilityEntries.push([name, installed.forNode(node.id)]);
+      } else {
+        capabilityEntries.push([
+          name,
+          name === "shell" ? bindShellToRun(this.host.capabilities.shell, signal) : installed
+        ]);
+      }
+    }
+    const capabilities = Object.freeze(Object.fromEntries(capabilityEntries));
+    const props = Object.freeze({ ...node.props });
+    const progress = {
+      report: (event) => this.emit({ type: "node:progress", runId, nodeId: node.id, ...event })
+    };
+    const seed = nodeSeed(this.seed, node.id);
+    await node.execute({
+      nodeId: node.id,
+      inputs,
+      outputs,
+      props,
+      capabilities,
+      signal,
+      progress,
+      seed,
+      // Fresh per cook: a node that draws N numbers draws the same N each time.
+      random: seededRandom(seed)
+    });
+    if (signal.aborted) return;
+    if (node.definition.container === "feedback") {
+      const feedback = await this.runFeedback(node, runId, signal, enqueue);
+      if (signal.aborted) return;
+      pendingData.set("result", feedback.result);
+      pendingData.set("history", feedback.history);
+    }
+    if (node.moduleId === "cascade.core.Subnet") {
+      for (const child of this.nodes) {
+        if (child.parent !== node.id || child.moduleId !== "cascade.core.Output") continue;
+        const name = `output_${integerProp(child.props.outputIndex)}`;
+        if (node.definition.outputs?.[name]?.kind === "data")
+          pendingData.set(name, child.outputs.get("output"));
+      }
+    }
+    for (const name of Object.keys(node.definition.outputs ?? {}))
+      if (pendingData.has(name)) {
+        const value = pendingData.get(name);
+        node.outputs.set(name, value);
+        this.emit({
+          type: "node:output",
+          runId,
+          nodeId: node.id,
+          outputName: name,
+          value: snapshot(value)
+        });
+      }
+    for (const emitted of pendingTriggers)
+      for (const connection of this.connections) {
+        if (connection.kind === "trigger" && connection.source.nodeId === node.id && connection.source.outputName === emitted.name)
+          enqueue(
+            connection.target.nodeId,
+            connection.target.inputName,
+            emitted.payload,
+            { nodeId: node.id, outputName: emitted.name }
+          );
+      }
+    this.emit({ type: "node:complete", runId, nodeId: node.id });
+  }
+  /**
+   * Every reason this host cannot run these nodes, collected rather than
+   * thrown. `assertPreflight` is the run path and raises the first of them;
+   * `preflight()` is the static path and hands the whole list to a caller that
+   * is not executing anything.
+   *
+   * There is deliberately one implementation. `validate` and `check` used to
+   * answer "will this graph run?" without ever consulting a host, so a node
+   * declaring a capability nobody installs passed both and then failed here —
+   * the two commands could not see the fault they exist to report. Any second
+   * copy of these rules would drift back into that.
+   */
+  preflightDiagnostics(nodes) {
+    const diagnostics = [];
+    const push = (code, nodeId, message) => diagnostics.push({ phase: "preflight", code, path: nodeId, message });
+    for (const node of nodes) {
+      if (node.unknownProps.length)
+        push(
+          "runtime/unknown-props",
+          node.id,
+          `${node.moduleId} stores ${node.unknownProps.join(", ")} under "props", and its definition declares no such prop \u2014 ${node.unknownProps.length === 1 ? "that value was" : "those values were"} dropped on load. A prop renamed or removed leaves its value behind; a name that never existed is a typo`
+        );
+      if (node.strayParams.length)
+        push(
+          "runtime/stray-params",
+          node.id,
+          `${node.moduleId} stores ${node.strayParams.join(", ")} under "params", which this runtime does not read \u2014 move ${node.strayParams.length === 1 ? "it" : "them"} to "props" or "inputs", whichever the definition declares, or the ${node.strayParams.length === 1 ? "value is" : "values are"} silently the default`
+        );
+      const remote = this.isRemote(node);
+      const locationWorks = node.definition.runsOn === "portable" || node.definition.runsOn === this.host.environment || remote;
+      if (!locationWorks) {
+        push(
+          "runtime/preflight-environment",
+          node.id,
+          `${node.moduleId} requires ${node.definition.runsOn}`
+        );
+        continue;
+      }
+      if (remote) {
+        const hasTriggers = [
+          ...Object.values(node.definition.inputs ?? {}),
+          ...Object.values(node.definition.outputs ?? {})
+        ].some((port) => port.kind === "trigger");
+        if (hasTriggers)
+          push(
+            "runtime/preflight-bridge-trigger",
+            node.id,
+            `${node.moduleId} cannot send triggers over the server bridge`
+          );
+        const hasTexture = [
+          ...Object.values(node.definition.inputs ?? {}),
+          ...Object.values(node.definition.outputs ?? {})
+        ].some((port) => port.kind === "data" && port.type === "texture");
+        if (hasTexture)
+          push(
+            "runtime/preflight-bridge-texture",
+            node.id,
+            `${node.moduleId} cannot send textures over the server bridge`
+          );
+      } else
+        for (const capability of node.definition.capabilities ?? [])
+          if (!this.host.capabilities[capability])
+            push(
+              "runtime/missing-capability",
+              node.id,
+              `Missing capability ${capability} for ${node.moduleId} (node ${node.id}) \u2014 the ${this.host.environment} host ${this.hostProvides()}`
+            );
+    }
+    diagnostics.push(...this.bundleDiagnostics(nodes));
+    return diagnostics;
+  }
+  /**
+   * Bundle fields read by name, checked against what the producer declares:
+   * a consumer's declared `fields`, an expression's `ch("format.dpi")`, and a
+   * Pick's `field`. A producer that declares no fields (Pack, a subnet Input,
+   * a project node that left them out) cannot be checked and is not. Reading
+   * another node's bundle by absolute path is refused with what to do instead.
+   */
+  bundleDiagnostics(nodes) {
+    const diagnostics = [];
+    const push = (nodeId, code, message, at = nodeId) => diagnostics.push({ phase: "preflight", code, path: at, message });
+    const producerFields = (node, input) => {
+      const connection = this.dataConnectionsByInput.get(`${node.id}\0${input}`)?.[0];
+      if (!connection) return null;
+      const output = this.byId.get(connection.source.nodeId)?.definition.outputs?.[connection.source.outputName];
+      if (output?.kind !== "data" || output.type !== "bundle" || !output.fields) return null;
+      return Object.keys(output.fields);
+    };
+    for (const node of nodes) {
+      for (const [name, input] of Object.entries(node.definition.inputs ?? {})) {
+        if (input.kind !== "data" || input.type !== "bundle" || !input.fields) continue;
+        const known = producerFields(node, name);
+        if (!known) continue;
+        for (const field of input.fields)
+          if (!known.includes(field))
+            push(
+              node.id,
+              "runtime/bundle-unknown-field",
+              unknownFieldMessage(field, known, `${node.id}.${name} (declared fields)`),
+              `${node.id}.${name}`
+            );
+      }
+      if (node.moduleId === "cascade.core.Pick") {
+        const field = String(node.props.field ?? "").trim();
+        const known = producerFields(node, "bundle");
+        if (field && known && !known.includes(field))
+          push(
+            node.id,
+            "runtime/bundle-unknown-field",
+            unknownFieldMessage(field, known, `${node.id}.field`),
+            `${node.id}.field`
+          );
+      }
+      for (const [prop, binding] of Object.entries(node.bindings)) {
+        if (!binding.expression) continue;
+        for (const path6 of expressionPaths(binding.expression)) {
+          const remote = remoteBundlePath(path6);
+          if (remote) {
+            const owner = this.byId.get(remote.node);
+            const output = owner?.definition.outputs?.[remote.port];
+            if (output?.kind === "data" && output.type === "bundle")
+              push(
+                node.id,
+                "runtime/bundle-remote-read",
+                `${node.id}.${prop} reads "${path6}", another node's bundle, without a wire. Wire ${remote.node}.${remote.port} into a bundle input on ${node.id} and read "${remote.port}.${remote.field}" instead`,
+                `${node.id}.${prop}`
+              );
+            continue;
+          }
+          const reference = parseBundleFieldPath(path6);
+          if (!reference) continue;
+          const input = node.definition.inputs?.[reference.port];
+          if (!input) {
+            const ports = Object.entries(node.definition.inputs ?? {}).filter(([, item]) => item.kind === "data" && item.type === "bundle").map(([portName]) => portName);
+            const suggestion = suggestName(reference.port, ports);
+            push(
+              node.id,
+              "runtime/bundle-unknown-port",
+              `${node.id}.${prop} reads "${path6}", but ${node.moduleId} has no input "${reference.port}"` + (suggestion ? ` \u2014 did you mean "${suggestion}.${reference.field}"?` : ""),
+              `${node.id}.${prop}`
+            );
+            continue;
+          }
+          if (input.kind !== "data" || input.type !== "bundle") continue;
+          const known = producerFields(node, reference.port);
+          if (known && !known.includes(reference.field))
+            push(
+              node.id,
+              "runtime/bundle-unknown-field",
+              unknownFieldMessage(reference.field, known, `${node.id}.${prop}`),
+              `${node.id}.${prop}`
+            );
+        }
+      }
+    }
+    return diagnostics;
+  }
+  /**
+   * What the host actually installed, asked of the host rather than written
+   * down. `serverBridge` is left out: it is how a node runs somewhere else,
+   * not a capability a definition can declare.
+   */
+  hostProvides() {
+    const supplied = Object.keys(this.host.capabilities).filter((name) => name !== "serverBridge" && !!this.host.capabilities[name]).sort();
+    return supplied.length ? `provides ${supplied.join(", ")}` : `provides no capabilities`;
+  }
+  assertPreflight(nodes) {
+    const [first] = this.preflightDiagnostics(nodes).filter(
+      (diagnostic) => !RUN_TOLERATED_CODES.has(diagnostic.code)
+    );
+    if (first) throw new CascadeRuntimeError(first.code, [first]);
+  }
+  isRemote(node) {
+    return this.host.environment === "browser" && node.definition.runsOn === "server" && !!this.host.capabilities.serverBridge;
+  }
+  async loadExecute(node) {
+    node.execute ??= await node.registration.loadExecute(
+      this.host.environment
+    );
+  }
+  runSelection(target) {
+    if (target.kind === "all") {
+      const gatedDataDescendants = this.gatedDataDescendants();
+      const initial = this.nodes.filter(
+        (node) => !isGated(node) && !gatedDataDescendants.has(node.id)
+      );
+      const ids = new Set(initial.map((node) => node.id));
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const connection of this.connections) {
+          if (connection.kind === "trigger" && ids.has(connection.source.nodeId) && !ids.has(connection.target.nodeId)) {
+            ids.add(connection.target.nodeId);
+            for (const dependency of this.dataClosure(connection.target.nodeId))
+              ids.add(dependency.id);
+            changed = true;
+          }
+        }
+      }
+      return {
+        initial,
+        reachable: this.nodes.filter((node) => ids.has(node.id))
+      };
+    }
+    const root = this.requireNode(target.nodeId);
+    if (target.kind === "output" && !root.definition.outputs?.[target.outputName])
+      misuse(
+        "runtime/invalid-target",
+        `Unknown output ${target.nodeId}.${target.outputName}`
+      );
+    const reachable = this.dataClosure(root.id);
+    if (reachable.some(isGated))
+      misuse(
+        "runtime/invalid-target",
+        `Target ${root.id} depends on a trigger event`
+      );
+    return { reachable, initial: reachable };
+  }
+  dataClosure(nodeId) {
+    const ids = /* @__PURE__ */ new Set([nodeId]);
+    const dependencies = dataDependencies(this.nodes, this.connections);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const dependency of dependencies)
+        if (ids.has(dependency.targetId) && !ids.has(dependency.sourceId)) {
+          ids.add(dependency.sourceId);
+          changed = true;
+        }
+    }
+    return this.nodes.filter((node) => ids.has(node.id));
+  }
+  gatedDataDescendants() {
+    const outgoing = /* @__PURE__ */ new Map();
+    for (const dependency of dataDependencies(this.nodes, this.connections)) {
+      const targets = outgoing.get(dependency.sourceId) ?? [];
+      targets.push(dependency.targetId);
+      outgoing.set(dependency.sourceId, targets);
+    }
+    const queue = this.nodes.filter(isGated).map((node) => node.id);
+    const descendants = new Set(queue);
+    let queueIndex = 0;
+    while (queueIndex < queue.length) {
+      for (const targetId of outgoing.get(queue[queueIndex++]) ?? []) {
+        if (descendants.has(targetId)) continue;
+        descendants.add(targetId);
+        queue.push(targetId);
+      }
+    }
+    return descendants;
+  }
+  triggerDataAncestors(nodeId) {
+    const dependencies = this.dataClosure(nodeId).filter(
+      (node) => node.id !== nodeId
+    );
+    if (dependencies.some(isGated))
+      misuse(
+        "runtime/invalid-target",
+        `Trigger target ${nodeId} depends on another trigger event`
+      );
+    return dependencies;
+  }
+  triggerReachable(nodeId) {
+    const ids = /* @__PURE__ */ new Set([this.requireNode(nodeId).id]);
+    const dependencies = dataDependencies(this.nodes, this.connections);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const connection of this.connections) {
+        if (connection.kind === "trigger" && ids.has(connection.source.nodeId) && !ids.has(connection.target.nodeId)) {
+          ids.add(connection.target.nodeId);
+          changed = true;
+        }
+      }
+      for (const dependency of dependencies)
+        if (ids.has(dependency.targetId) && !ids.has(dependency.sourceId)) {
+          ids.add(dependency.sourceId);
+          changed = true;
+        }
+    }
+    return this.nodes.filter((node) => ids.has(node.id));
+  }
+  finish(runId, status, startedAt, diagnostics) {
+    const finishedAt = this.host.now();
+    const outputs = immutableMap(
+      this.nodes.map((node) => [node.id, this.getOutputs(node.id)])
+    );
+    const result = Object.freeze({
+      runId,
+      status,
+      outputs,
+      diagnostics: Object.freeze([...diagnostics]),
+      timings: Object.freeze({
+        startedAt,
+        finishedAt,
+        durationMs: finishedAt - startedAt
+      })
+    });
+    this.emit({ type: "run:complete", result });
+    return result;
+  }
+  emit(event) {
+    for (const listener of [...this.listeners])
+      try {
+        listener(event);
+      } catch (error) {
+        this.host.report({
+          phase: "event",
+          code: "runtime/listener-failed",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+  }
+  requireReady() {
+    if (this.graphState !== "ready")
+      misuse("runtime/invalid-state", `Graph is ${this.graphState}`);
+  }
+  isDisposed() {
+    return this.graphState === "disposed";
+  }
+  /**
+   * Every node under a feedback container, transitively.
+   *
+   * These are excluded from the main cook order — the container runs them, once
+   * per step. Computed once per run rather than per step: the hierarchy cannot
+   * change mid-run, and this is walked for every node in the order.
+   */
+  /**
+   * Early cutoff for `run({ reuse: true })`: a node whose wired inputs are the
+   * very same values and whose resolved props are equal keeps its outputs.
+   *
+   * Sound because a definition-v1 node may observe only its inputs, its props
+   * and declared capabilities, and time reaches it through props. Upstream
+   * reuse keeps output identity, so one unchanged stage skips everything below
+   * it that is unchanged too. Trigger-driven, feedback and remote nodes always
+   * cook. Off by default: a host opts in when it re-runs a graph on every edit.
+   */
+  /** Whether any data input of `node` (or, for a subnet, any inner output)
+   *  comes from a node in `cooked`. */
+  feedsFrom(node, cooked) {
+    for (const name of Object.keys(node.definition.inputs ?? {})) {
+      for (const connection of this.dataConnectionsByInput.get(`${node.id}\0${name}`) ?? [])
+        if (cooked.has(connection.source.nodeId)) return true;
+    }
+    if (node.moduleId === "cascade.core.Input" && node.parent && cooked.size) return true;
+    if (node.moduleId === "cascade.core.Subnet") {
+      for (const child of this.nodes) if (child.parent === node.id && cooked.has(child.id)) return true;
+    }
+    return false;
+  }
+  reusable(node) {
+    const last = node.lastCook;
+    if (!last || this.isRemote(node) || node.definition.container === "feedback") return false;
+    if (Object.values(node.definition.inputs ?? {}).some((input) => input.kind === "trigger")) return false;
+    if (Object.values(node.definition.outputs ?? {}).some((output) => output.kind === "trigger")) return false;
+    const next = this.cookKey(node);
+    return sameValues(last.inputs, next.inputs, Object.is) && sameValues(last.props, next.props, sameJson);
+  }
+  cookKey(node) {
+    const inputs = [];
+    for (const [name, definition] of Object.entries(node.definition.inputs ?? {})) {
+      if (definition.kind !== "data") continue;
+      if (node.moduleId === "cascade.core.Input" && name === "value" && node.parent) {
+        const parent = this.requireNode(node.parent);
+        inputs.push(this.dataInputValue(parent, `input_${integerProp(node.props.inputIndex)}`));
+        continue;
+      }
+      const connections = this.dataConnectionsByInput.get(`${node.id}\0${name}`) ?? [];
+      if (!connections.length) inputs.push(node.inputs[name]);
+      for (const connection of connections)
+        inputs.push(this.requireNode(connection.source.nodeId).outputs.get(connection.source.outputName));
+    }
+    if (node.moduleId === "cascade.core.Subnet") {
+      for (const child of this.nodes)
+        if (child.parent === node.id && child.moduleId === "cascade.core.Output") inputs.push(child.outputs.get("output"));
+    }
+    return { inputs, props: Object.keys(node.definition.props ?? {}).map((name) => node.props[name]) };
+  }
+  feedbackDescendants() {
+    const containers = new Set(
+      this.nodes.filter((node) => node.definition.container === "feedback").map((node) => node.id)
+    );
+    if (!containers.size) return /* @__PURE__ */ new Set();
+    const inside = /* @__PURE__ */ new Set();
+    for (const node of this.nodes) {
+      let parent = node.parent;
+      const seen = /* @__PURE__ */ new Set();
+      while (parent && !seen.has(parent)) {
+        seen.add(parent);
+        if (containers.has(parent)) {
+          inside.add(node.id);
+          break;
+        }
+        parent = this.byId.get(parent)?.parent;
+      }
+    }
+    return inside;
+  }
+  /**
+   * Run a feedback container's contents `steps` times and return the last
+   * result.
+   *
+   * The order the children run in is the graph's own topological order
+   * restricted to this container's descendants, which is what makes the forces
+   * inside behave like nodes rather than like a list: wiring one into another
+   * changes the order they apply in.
+   */
+  async runFeedback(node, runId, signal, enqueue) {
+    const initial = this.dataInputValue(node, "initial");
+    const requested = this.dataInputValue(node, "steps");
+    const steps = Math.max(0, Math.trunc(Number(requested ?? 0)));
+    if (!Number.isFinite(steps))
+      throw runtimeError(
+        "runtime/feedback-steps",
+        `${node.id}.steps is not a finite number`
+      );
+    const children = topological(this.nodes, this.connections).filter(
+      (child) => this.enclosingFeedback(child) === node.id
+    );
+    const sink = children.find(
+      (child) => child.parent === node.id && child.moduleId === "cascade.core.Output" && integerProp(child.props.outputIndex) === 0
+    );
+    if (steps > 0 && !sink)
+      throw runtimeError(
+        "runtime/feedback-no-output",
+        `${node.id} has no cascade.core.Output inside it, so a step has no result to carry. Add one and wire the step's result into it.`
+      );
+    const keep = Math.max(0, integerProp(node.props.history));
+    const history = [];
+    let carried = initial;
+    try {
+      for (let step = 0; step < steps; step += 1) {
+        if (signal.aborted) break;
+        this.feedbackState.set(node.id, { value: carried, step });
+        for (const child of children) {
+          if (signal.aborted) break;
+          await this.executeNode(child, runId, signal, {}, enqueue);
+        }
+        if (signal.aborted) break;
+        carried = sink.outputs.get("output");
+        if (keep > 0) {
+          history.push(carried);
+          if (history.length > keep) history.shift();
+        }
+      }
+      return Object.freeze({
+        result: carried,
+        history: Object.freeze(history)
+      });
+    } finally {
+      this.feedbackState.delete(node.id);
+    }
+  }
+  /** The nearest ancestor that is a feedback container, or undefined. */
+  enclosingFeedback(node) {
+    let parent = node.parent;
+    const seen = /* @__PURE__ */ new Set();
+    while (parent && !seen.has(parent)) {
+      seen.add(parent);
+      const candidate = this.byId.get(parent);
+      if (candidate?.definition.container === "feedback") return candidate.id;
+      parent = candidate?.parent;
+    }
+    return void 0;
+  }
+  requireNode(id) {
+    const node = this.byId.get(id);
+    if (!node) misuse("runtime/node-not-found", `Unknown node ${id}`);
+    return node;
+  }
+  dataInputValue(node, inputName2) {
+    const connection = this.connections.find(
+      (item) => item.kind === "data" && item.target.nodeId === node.id && item.target.inputName === inputName2
+    );
+    return connection ? this.requireNode(connection.source.nodeId).outputs.get(
+      connection.source.outputName
+    ) : node.inputs[inputName2];
+  }
+};
+function bindShellToRun(shell, runSignal) {
+  if (!shell) return void 0;
+  const options = (value) => ({
+    ...value,
+    signal: combineAbortSignals(runSignal, value?.signal)
+  });
+  return Object.freeze({
+    run: (command, args, value) => shell.run(command, args, options(value)),
+    runJson: (command, args, value) => shell.runJson(command, args, options(value))
+  });
+}
+function combineAbortSignals(first, second) {
+  if (!second || first === second) return first;
+  const wrappers = /* @__PURE__ */ new Map();
+  return {
+    get aborted() {
+      return first.aborted || second.aborted;
+    },
+    get reason() {
+      return first.aborted ? first.reason : second.reason;
+    },
+    addEventListener(_type, listener, options) {
+      if (first.aborted || second.aborted) {
+        listener();
+        return;
+      }
+      const wrapped = () => {
+        first.removeEventListener("abort", wrapped);
+        second.removeEventListener("abort", wrapped);
+        wrappers.delete(listener);
+        listener();
+      };
+      wrappers.set(listener, wrapped);
+      first.addEventListener("abort", wrapped, options);
+      second.addEventListener("abort", wrapped, options);
+    },
+    removeEventListener(_type, listener) {
+      const wrapped = wrappers.get(listener);
+      if (!wrapped) return;
+      first.removeEventListener("abort", wrapped);
+      second.removeEventListener("abort", wrapped);
+      wrappers.delete(listener);
+    }
+  };
+}
+function materialize(authored, registration) {
+  const inputs = {};
+  const props = {};
+  for (const [name, definition] of Object.entries(
+    registration.definition.inputs ?? {}
+  ))
+    if (definition.kind === "data" && "default" in definition)
+      inputs[name] = runtimeValue(
+        definition.default,
+        definition.type,
+        false,
+        `${authored.id}.${name}`
+      );
+  if (Array.isArray(authored.inputs))
+    for (const saved of authored.inputs) {
+      const definition = registration.definition.inputs?.[saved.name];
+      if (definition?.kind === "data") {
+        inputs[saved.name] = runtimeValue(
+          "defaultValue" in saved ? saved.defaultValue : saved.value,
+          definition.type,
+          !("default" in definition),
+          `${authored.id}.${saved.name}`
+        );
+      }
+    }
+  else if (authored.inputs)
+    for (const [name, saved] of Object.entries(authored.inputs)) {
+      const definition = registration.definition.inputs?.[name];
+      if (definition?.kind === "data")
+        inputs[name] = runtimeValue(
+          saved,
+          definition.type,
+          !("default" in definition),
+          `${authored.id}.${name}`
+        );
+    }
+  for (const [name, definition] of Object.entries(
+    registration.definition.props ?? {}
+  ))
+    props[name] = runtimeValue(
+      definition.default,
+      definition.type,
+      false,
+      `${authored.id}.${name}`
+    );
+  if (Array.isArray(authored.props))
+    misuse(
+      "runtime/props-not-a-map",
+      `Node ${authored.id} stores props as a list. "props" is a map of name to value; "params" was the list. Every value in it is being dropped, silently, and the graph would run on its defaults`
+    );
+  const bindings = {};
+  const storedProps = authored.props ?? {};
+  for (const [name, definition] of Object.entries(
+    registration.definition.props ?? {}
+  )) {
+    if (!definition.expression || name in storedProps) continue;
+    bindings[name] = {
+      value: props[name],
+      expression: definition.expression
+    };
+  }
+  for (const [name, saved] of Object.entries(storedProps)) {
+    const definition = registration.definition.props?.[name];
+    if (!definition) continue;
+    const object = saved && typeof saved === "object" && "value" in saved ? saved : null;
+    const value = runtimeValue(
+      object ? object.value : saved,
+      definition.type,
+      false,
+      `${authored.id}.${name}`
+    );
+    props[name] = value;
+    if (!object) {
+      delete bindings[name];
+      continue;
+    }
+    const channel = deserializeChannel(object.channel);
+    const expression = typeof object.expression === "string" && object.expression ? object.expression : void 0;
+    const binding = {
+      value,
+      ...expression ? { expression } : {},
+      ...isEmptyChannel(channel) ? {} : { channel }
+    };
+    if (isBoundProp(binding)) bindings[name] = binding;
+  }
+  return {
+    id: authored.id,
+    moduleId: registration.moduleId,
+    ...authored.parent ? { parent: authored.parent } : {},
+    registration,
+    definition: registration.definition,
+    inputs,
+    props,
+    bindings,
+    strayParams: strayParams(authored, registration),
+    unknownProps: unknownProps(authored, registration),
+    outputs: /* @__PURE__ */ new Map()
+  };
+}
+function unknownProps(authored, registration) {
+  const props = authored.props;
+  if (!props || Array.isArray(props)) return [];
+  const declared = registration.definition.props ?? {};
+  return Object.keys(props).filter((name) => !(name in declared));
+}
+function strayParams(authored, registration) {
+  const definition = registration.definition;
+  const declared = /* @__PURE__ */ new Set([
+    ...Object.keys(definition.props ?? {}),
+    ...Object.keys(definition.inputs ?? {})
+  ]);
+  const names = Array.isArray(authored.params) ? authored.params.map((saved) => saved?.name) : Object.keys(authored.params ?? {});
+  return names.filter(
+    (name) => typeof name === "string" && declared.has(name)
+  );
+}
+function specializeCoreRegistration(registration, authored, nodes) {
+  if (registration.moduleId === "cascade.core.Input" || registration.moduleId === "cascade.core.Output") {
+    const type = savedDataType(authored.props?.dataType);
+    const inputName2 = registration.moduleId === "cascade.core.Input" ? "value" : "input";
+    return Object.freeze({
+      ...registration,
+      definition: Object.freeze({
+        ...registration.definition,
+        inputs: Object.freeze({
+          [inputName2]: dataInputDefinition(type)
+        }),
+        outputs: Object.freeze({
+          output: { kind: "data", type }
+        })
+      })
+    });
+  }
+  if (registration.moduleId !== "cascade.core.Subnet") return registration;
+  const children = nodes.filter((candidate) => candidate.parent === authored.id);
+  const inputs = indexedBoundaryPorts(children, "cascade.core.Input", "inputIndex", "input");
+  const outputs = indexedBoundaryPorts(children, "cascade.core.Output", "outputIndex", "output");
+  return Object.freeze({
+    ...registration,
+    definition: Object.freeze({
+      ...registration.definition,
+      ...Object.keys(inputs).length ? { inputs: Object.freeze(inputs) } : {},
+      ...Object.keys(outputs).length ? { outputs: Object.freeze(outputs) } : {}
+    })
+  });
+}
+function indexedBoundaryPorts(nodes, moduleId2, propName, prefix) {
+  const boundaries = nodes.filter((node) => (node.module ?? node.type) === moduleId2).map((node) => ({
+    index: savedIntegerProp(node.props?.[propName]),
+    type: savedDataType(node.props?.dataType)
+  })).filter((boundary) => boundary.index >= 0);
+  const max = boundaries.length ? Math.max(...boundaries.map(({ index }) => index)) : -1;
+  const types = new Map(boundaries.map(({ index, type }) => [index, type]));
+  return Object.fromEntries(
+    Array.from({ length: max + 1 }, (_, index) => [
+      `${prefix}_${index}`,
+      prefix === "input" ? dataInputDefinition(types.get(index) ?? "any") : { kind: "data", type: types.get(index) ?? "any" }
+    ])
+  );
+}
+function dataInputDefinition(type) {
+  return type === "any" ? { kind: "data", type, default: null } : { kind: "data", type };
+}
+function savedDataType(value) {
+  const type = savedStringProp(value);
+  return type || "any";
+}
+function savedStringProp(value) {
+  const unwrapped = value && typeof value === "object" && "value" in value ? value.value : value;
+  return typeof unwrapped === "string" ? unwrapped : "";
+}
+function savedIntegerProp(value) {
+  const unwrapped = value && typeof value === "object" && "value" in value ? value.value : value;
+  return typeof unwrapped === "number" && Number.isInteger(unwrapped) ? unwrapped : 0;
+}
+function integerProp(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : 0;
+}
+function graphBoundaries(nodes, moduleId2, nameProp) {
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.parent || node.moduleId !== moduleId2) continue;
+    const name = savedStringProp(node.props[nameProp]).trim() || node.id;
+    if (boundaries.has(name))
+      misuse("runtime/duplicate-graph-boundary", `Duplicate graph boundary name ${name}`);
+    boundaries.set(name, node);
+  }
+  return boundaries;
+}
+function boundaryInspection(boundaries, portName) {
+  return Object.freeze(Object.fromEntries(
+    [...boundaries].map(([name, node]) => [
+      name,
+      Object.freeze({
+        nodeId: node.id,
+        type: node.definition.outputs?.[portName]?.kind === "data" ? node.definition.outputs[portName].type : "any"
+      })
+    ])
+  ));
+}
+function isStructuralProp(node, name) {
+  if (node.moduleId === "cascade.core.Input")
+    return name === "inputIndex" || name === "inputName" || name === "dataType";
+  if (node.moduleId === "cascade.core.Output")
+    return name === "outputIndex" || name === "outputName" || name === "dataType";
+  return false;
+}
+function materializeConnection(connection, index, nodes) {
+  const endpoints = Array.isArray(connection) ? {
+    source: {
+      nodeId: connection[0][0],
+      outputName: connection[0][2] ?? outputName(nodes.get(connection[0][0]), connection[0][1])
+    },
+    target: {
+      nodeId: connection[1][0],
+      inputName: connection[1][2] ?? inputName(nodes.get(connection[1][0]), connection[1][1])
+    }
+  } : {
+    source: {
+      nodeId: connection.source.nodeId,
+      outputName: connection.source.outputName
+    },
+    target: {
+      nodeId: connection.target.nodeId,
+      inputName: connection.target.inputName
+    }
+  };
+  const source = nodes.get(endpoints.source.nodeId);
+  const target = nodes.get(endpoints.target.nodeId);
+  if (!source || !target)
+    misuse(
+      "runtime/invalid-connection",
+      `Connection ${index} references an unknown node`
+    );
+  const output = source.definition.outputs?.[endpoints.source.outputName];
+  let input = target.definition.inputs?.[endpoints.target.inputName];
+  let variadicIndex;
+  if (!input && /^input_\d+$/.test(endpoints.target.inputName)) {
+    const variadic = variadicInputName(target);
+    if (variadic !== void 0) {
+      variadicIndex = Number(endpoints.target.inputName.slice("input_".length));
+      endpoints.target.inputName = variadic;
+      input = target.definition.inputs?.[variadic];
+    }
+  }
+  if (!output || !input)
+    misuse(
+      "runtime/invalid-connection",
+      `Connection ${index} references an unknown port`
+    );
+  if (output.kind !== input.kind)
+    misuse(
+      "runtime/connection-kind",
+      `Connection ${index} mixes ${output.kind} and ${input.kind}`
+    );
+  if (output.kind === "data" && input.kind === "data" && !canConnectTypes(output.type, input.type))
+    misuse(
+      "runtime/connection-type",
+      `Connection ${index} has incompatible types ${output.type} and ${input.type}`
+    );
+  if (output.kind === "data" && input.kind === "data" && output.type === "bundle" && input.type === "bundle" && !bundleSchemasCompatible(output.schema, input.schema))
+    misuse(
+      "runtime/connection-schema",
+      `Connection ${index} wires a ${output.schema} bundle into an input that takes ${input.schema}`
+    );
+  return Object.freeze({
+    source: Object.freeze(endpoints.source),
+    target: Object.freeze(endpoints.target),
+    kind: output.kind,
+    order: index,
+    ...variadicIndex === void 0 ? {} : { variadicIndex }
+  });
+}
+function validateCardinality(nodes, connections) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const connection of connections) {
+    if (connection.kind !== "data") continue;
+    const key = `${connection.target.nodeId}\0${connection.target.inputName}`;
+    const count = (counts.get(key) ?? 0) + 1;
+    counts.set(key, count);
+    const input = nodes.get(connection.target.nodeId)?.definition.inputs?.[connection.target.inputName];
+    if (count > 1 && input?.kind === "data" && !input.variadic)
+      misuse(
+        "runtime/input-cardinality",
+        `${connection.target.nodeId}.${connection.target.inputName} accepts one connection`
+      );
+  }
+}
+function validateHierarchy(nodes, byId) {
+  for (const node of nodes) {
+    if (!node.parent) continue;
+    const parent = byId.get(node.parent);
+    if (!parent)
+      misuse(
+        "runtime/parent-not-found",
+        `Node ${node.id} references missing parent ${node.parent}`
+      );
+    if (parent.definition.container !== "subnet" && parent.definition.container !== "feedback")
+      misuse(
+        "runtime/parent-not-container",
+        `Node ${node.id} parent ${node.parent} is not a container`
+      );
+  }
+  for (const node of nodes) {
+    const visited = /* @__PURE__ */ new Set([node.id]);
+    let parentId = node.parent;
+    while (parentId) {
+      if (visited.has(parentId))
+        misuse(
+          "runtime/parent-cycle",
+          `Node hierarchy contains a cycle through ${parentId}`
+        );
+      visited.add(parentId);
+      parentId = byId.get(parentId)?.parent;
+    }
+  }
+}
+function snapshotRegistration(registration) {
+  if (registration.kind === "legacy-dynamic")
+    return Object.freeze({ ...registration });
+  const definition = snapshot(registration.definition);
+  return Object.freeze({ ...registration, definition });
+}
+function isGated(node) {
+  return Object.values(node.definition.inputs ?? {}).some(
+    (input) => input.kind === "trigger"
+  );
+}
+function outputName(node, index) {
+  const name = Object.keys(node?.definition.outputs ?? {})[index];
+  if (!name)
+    misuse("runtime/invalid-connection", `Unknown output index ${index}`);
+  return name;
+}
+function variadicInputName(node) {
+  const names = Object.entries(node.definition.inputs ?? {}).filter(([, input]) => input.kind === "data" && input.variadic === true).map(([name]) => name);
+  return names.length === 1 ? names[0] : void 0;
+}
+function inputName(node, index) {
+  const name = Object.keys(node?.definition.inputs ?? {})[index];
+  if (!name)
+    misuse("runtime/invalid-connection", `Unknown input index ${index}`);
+  return name;
+}
+function validateTopology(nodes, connections) {
+  topological(nodes, connections);
+}
+function topological(nodes, connections) {
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const indegree = new Map(nodes.map((node) => [node.id, 0]));
+  const outgoing = new Map(nodes.map((node) => [node.id, []]));
+  for (const dependency of graphDependencies(nodes, connections)) {
+    outgoing.get(dependency.sourceId).push(dependency.targetId);
+    indegree.set(
+      dependency.targetId,
+      indegree.get(dependency.targetId) + 1
+    );
+  }
+  const queue = nodes.filter((node) => indegree.get(node.id) === 0);
+  const result = [];
+  let queueIndex = 0;
+  while (queueIndex < queue.length) {
+    const node = queue[queueIndex++];
+    result.push(node);
+    for (const id of outgoing.get(node.id)) {
+      indegree.set(id, indegree.get(id) - 1);
+      if (indegree.get(id) === 0)
+        queue.push(byId.get(id));
+    }
+  }
+  if (result.length !== nodes.length)
+    misuse("runtime/cycle", "Graph contains a data or trigger cycle");
+  return result;
+}
+function graphDependencies(nodes, connections) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const connection of connections) {
+    const dependency = {
+      sourceId: connection.source.nodeId,
+      targetId: connection.target.nodeId
+    };
+    dependencies.set(`${dependency.sourceId}\0${dependency.targetId}`, dependency);
+  }
+  for (const dependency of dataDependencies(nodes, connections))
+    dependencies.set(`${dependency.sourceId}\0${dependency.targetId}`, dependency);
+  return [...dependencies.values()];
+}
+function dataDependencies(nodes, connections) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const connection of connections) {
+    if (connection.kind !== "data") continue;
+    const dependency = {
+      sourceId: connection.source.nodeId,
+      targetId: connection.target.nodeId
+    };
+    dependencies.set(`${dependency.sourceId}\0${dependency.targetId}`, dependency);
+  }
+  for (const node of nodes) {
+    if (!node.parent) continue;
+    if (node.moduleId === "cascade.core.Input") {
+      const inputName2 = `input_${integerProp(node.props.inputIndex)}`;
+      const source = connections.find(
+        (connection) => connection.kind === "data" && connection.target.nodeId === node.parent && connection.target.inputName === inputName2
+      );
+      if (source) {
+        const dependency = {
+          sourceId: source.source.nodeId,
+          targetId: node.id
+        };
+        dependencies.set(`${dependency.sourceId}\0${dependency.targetId}`, dependency);
+      }
+    } else if (node.moduleId === "cascade.core.Output") {
+      const dependency = { sourceId: node.id, targetId: node.parent };
+      dependencies.set(`${dependency.sourceId}\0${dependency.targetId}`, dependency);
+    }
+  }
+  const parents = new Map(nodes.map((node) => [node.id, node.parent]));
+  const feedbackContainers = new Set(
+    nodes.filter((node) => node.definition.container === "feedback").map((node) => node.id)
+  );
+  if (feedbackContainers.size) {
+    const feedbackLineage = (id) => {
+      const lineage = [];
+      const seen = /* @__PURE__ */ new Set();
+      let current = id;
+      while (current && !seen.has(current)) {
+        seen.add(current);
+        if (feedbackContainers.has(current)) lineage.push(current);
+        current = parents.get(current);
+      }
+      return lineage;
+    };
+    const add = (sourceId, targetId) => {
+      if (sourceId === targetId) return;
+      const dependency = { sourceId, targetId };
+      dependencies.set(`${sourceId}\0${targetId}`, dependency);
+    };
+    for (const connection of connections) {
+      if (connection.kind !== "data") continue;
+      const sourceLineage = feedbackLineage(connection.source.nodeId);
+      const targetLineage = feedbackLineage(connection.target.nodeId);
+      const sourceSet = new Set(sourceLineage);
+      const targetSet = new Set(targetLineage);
+      const crossedFrom = sourceLineage.filter((id) => !targetSet.has(id));
+      const crossedInto = targetLineage.filter((id) => !sourceSet.has(id));
+      if (crossedFrom.length > 0 && crossedInto.length > 0) {
+        for (const sourceId of crossedFrom)
+          for (const targetId of crossedInto) add(sourceId, targetId);
+      } else if (crossedFrom.length > 0) {
+        for (const sourceId of crossedFrom)
+          add(sourceId, connection.target.nodeId);
+      } else {
+        for (const targetId of crossedInto)
+          add(connection.source.nodeId, targetId);
+      }
+    }
+  }
+  return [...dependencies.values()];
+}
+function runtimeError(code, message) {
+  return new CascadeRuntimeError(code, [{ phase: "runtime", code, message }]);
+}
+function misuse(code, message) {
+  throw runtimeError(code, message);
+}
+function snapshot(value) {
+  return cloneValue(value, /* @__PURE__ */ new WeakSet());
+}
+function immutableMap(entries) {
+  const source = new Map(entries);
+  let view;
+  view = Object.freeze({
+    get size() {
+      return source.size;
+    },
+    has(key) {
+      return source.has(key);
+    },
+    get(key) {
+      return source.get(key);
+    },
+    entries() {
+      return source.entries();
+    },
+    keys() {
+      return source.keys();
+    },
+    values() {
+      return source.values();
+    },
+    [Symbol.iterator]() {
+      return source[Symbol.iterator]();
+    },
+    forEach(callback, thisArg) {
+      source.forEach((value, key) => callback.call(thisArg, value, key, view));
+    }
+  });
+  return view;
+}
+function cloneValue(value, ancestors) {
+  if (typeof value === "number" && !Number.isFinite(value))
+    misuse("runtime/non-serializable-value", "Runtime numbers must be finite");
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint")
+    misuse(
+      "runtime/non-serializable-value",
+      `Runtime values cannot contain ${typeof value}`
+    );
+  if (value === void 0 || value === null || typeof value !== "object")
+    return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
+    return value;
+  if (ancestors.has(value))
+    misuse(
+      "runtime/non-serializable-value",
+      "Runtime values cannot contain cycles"
+    );
+  ancestors.add(value);
+  const clone = Array.isArray(value) ? value.map((item) => cloneValue(item, ancestors)) : Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      key,
+      cloneValue(item, ancestors)
+    ])
+  );
+  ancestors.delete(value);
+  return Object.freeze(clone);
+}
+var TUPLE_LENGTHS = {
+  vec2: 2,
+  vec3: 3,
+  vec4: 4,
+  vec2i: 2,
+  vec3i: 3,
+  vec4i: 4,
+  mat2: 4,
+  mat3: 9,
+  mat4: 16,
+  color: 4
+};
+function outputValue(value, definition, path6) {
+  if (definition.type !== "bundle" || !definition.fields)
+    return runtimeValue(value, definition.type, false, path6);
+  const fields = definition.fields;
+  const problem = bundleValueProblem(value, fields);
+  if (problem) misuse("runtime/value-type", `${path6} ${problem}`);
+  if (isBundleValue(value))
+    for (const [field, item] of Object.entries(value))
+      runtimeValue(item, bundleFieldType(fields[field]), true, `${path6}.${field}`);
+  return runtimeValue(value, "bundle", false, path6);
+}
+function expressionPaths(expression) {
+  const paths = [];
+  const pattern = /\b(?:ch|chs|chv)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  let match;
+  while ((match = pattern.exec(expression)) !== null) paths.push(match[1]);
+  return paths;
+}
+function readsBundleFields(node) {
+  for (const binding of Object.values(node.bindings))
+    if (binding.expression)
+      for (const reference of bundleFieldReferences(binding.expression)) {
+        const input = node.definition.inputs?.[reference.port];
+        if (input?.kind === "data" && input.type === "bundle") return true;
+      }
+  return false;
+}
+function runtimeValue(value, type, allowUndefined, path6) {
+  if (value === void 0) {
+    if (allowUndefined) return void 0;
+    misuse("runtime/value-type", `${path6} requires a ${type} value`);
+  }
+  const tupleLength = TUPLE_LENGTHS[type];
+  const valid = type === "float" && typeof value === "number" && Number.isFinite(value) || type === "int" && typeof value === "number" && Number.isInteger(value) || type === "bool" && typeof value === "boolean" || type === "string" && typeof value === "string" || tupleLength !== void 0 && Array.isArray(value) && value.length === tupleLength && value.every(
+    (item) => type.endsWith("i") ? typeof item === "number" && Number.isInteger(item) : typeof item === "number" && Number.isFinite(item)
+  ) || type === "bundle" && isBundleValue(value) || !tupleLength && type !== "bundle" && type !== "float" && type !== "int" && type !== "bool" && type !== "string";
+  if (!valid) misuse("runtime/value-type", `${path6} is not a valid ${type}`);
+  return snapshot(value);
+}
+function sameValues(a, b, equal) {
+  return a.length === b.length && a.every((value, index) => equal(value, b[index]));
+}
+function sameJson(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+
+// packages/runtime/src/node.ts
+function createNodeRuntimeHost(options) {
+  const {
+    modules,
+    legacyShell,
+    now = () => Date.now(),
+    report = () => {
+    },
+    ...capabilities
+  } = options;
+  return {
+    environment: "server",
+    modules,
+    legacyShell,
+    capabilities,
+    now,
+    report
+  };
+}
+
+// packages/runtime/src/definition/architecture.ts
+var AMBIENT_STATE = /* @__PURE__ */ new Set([
+  "globalThis",
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "indexedDB",
+  "process",
+  "Bun",
+  "Deno"
+]);
+function validateNodeModuleArchitecture(source, fileName, ts2) {
+  const file = ts2.createSourceFile(
+    fileName,
+    source,
+    ts2.ScriptTarget.Latest,
+    true,
+    ts2.ScriptKind.TS
+  );
+  const diagnostics = [];
+  const exportsDefinition = file.statements.some(
+    (statement) => ts2.isVariableStatement(statement) && isDefinition(statement)
+  );
+  for (const statement of file.statements) {
+    if (ts2.isVariableStatement(statement) && !isDefinition(statement)) {
+      const superseded = supersededByDefinition(statement);
+      add(
+        statement,
+        "module-state",
+        superseded ? `\`${superseded}\` belongs inside the definition, not beside it \u2014 a definition-v1 node declares it as \`${superseded}: ...\` in \`export const definition\`, and a module-level copy is the module state this rule forbids. A dynamic node without a definition still declares it here.` : "Node modules may not declare module-level values; use a pure function or pass state through ports, props, and declared capabilities"
+      );
+    } else if (ts2.isClassDeclaration(statement) || ts2.isEnumDeclaration(statement) || ts2.isModuleDeclaration(statement)) {
+      add(
+        statement,
+        "module-state",
+        "Node modules may not declare classes, enums, or namespaces because they can retain module-global state"
+      );
+    } else if (ts2.isExpressionStatement(statement)) {
+      add(
+        statement,
+        "top-level-effect",
+        "Node modules may not run top-level effects"
+      );
+    } else if (ts2.isImportDeclaration(statement) && !statement.importClause) {
+      add(
+        statement,
+        "side-effect-import",
+        "Side-effect imports are not allowed in node modules"
+      );
+    } else if (ts2.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts2.isStringLiteral(statement.moduleSpecifier) && importsSiblingNode(fileName, statement.moduleSpecifier.text)) {
+      add(
+        statement.moduleSpecifier,
+        "node-import",
+        "A node may not import another node implementation; connect the nodes with a graph wire"
+      );
+    }
+  }
+  visit(file);
+  return diagnostics;
+  function visit(node) {
+    if (ts2.isTypeNode(node) || ts2.isImportDeclaration(node)) return;
+    if (ts2.isIdentifier(node) && AMBIENT_STATE.has(node.text) && isReference(node)) {
+      add(
+        node,
+        "ambient-state",
+        `${node.text} is ambient state; receive data through ports, props, or a declared capability`
+      );
+    }
+    if (ts2.isCallExpression(node) && node.expression.kind === ts2.SyntaxKind.ImportKeyword) {
+      add(
+        node,
+        "dynamic-import",
+        "Dynamic imports are not allowed in deterministic node execution"
+      );
+    }
+    ts2.forEachChild(node, visit);
+  }
+  function isReference(node) {
+    const parent = node.parent;
+    return !(ts2.isPropertyAccessExpression(parent) && parent.name === node || ts2.isPropertyAssignment(parent) && parent.name === node || ts2.isMethodDeclaration(parent) && parent.name === node || ts2.isPropertyDeclaration(parent) && parent.name === node);
+  }
+  function supersededByDefinition(statement) {
+    if (!exportsDefinition) return null;
+    const declaration = statement.declarationList.declarations[0];
+    if (statement.declarationList.declarations.length !== 1) return null;
+    if (!declaration || !ts2.isIdentifier(declaration.name)) return null;
+    return declaration.name.text === "icon" || declaration.name.text === "runsOn" ? declaration.name.text : null;
+  }
+  function isDefinition(statement) {
+    return Boolean(statement.declarationList.flags & ts2.NodeFlags.Const) && Boolean(statement.modifiers?.some((item) => item.kind === ts2.SyntaxKind.ExportKeyword)) && statement.declarationList.declarations.length === 1 && ts2.isIdentifier(statement.declarationList.declarations[0].name) && statement.declarationList.declarations[0].name.text === "definition";
+  }
+  function add(node, code, message) {
+    const point = file.getLineAndCharacterOfPosition(node.getStart(file));
+    diagnostics.push({
+      phase: "architecture",
+      code: `architecture/${code}`,
+      message,
+      file: fileName,
+      line: point.line + 1,
+      column: point.character + 1
+    });
+  }
+}
+function importsSiblingNode(fileName, specifier) {
+  if (!specifier.startsWith(".")) return false;
+  const file = normalize(fileName).split("/");
+  const nodesIndex = file.lastIndexOf("nodes");
+  if (nodesIndex < 0 || !file[nodesIndex + 1]) return false;
+  const sourceNode = file[nodesIndex + 1];
+  const resolved = normalize([...file.slice(0, -1), ...specifier.split("/")].join("/")).split("/");
+  const resolvedNodesIndex = resolved.lastIndexOf("nodes");
+  return resolvedNodesIndex >= 0 && Boolean(resolved[resolvedNodesIndex + 1]) && resolved[resolvedNodesIndex + 1] !== sourceNode;
+}
+function normalize(value) {
+  const output = [];
+  for (const part of value.split("\\").join("/").split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") output.pop();
+    else output.push(part);
+  }
+  return output.join("/");
+}
+
+// src/cli/nodeFiles.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+function createNodeFileCapability(project) {
+  const within2 = (relative, what) => {
+    try {
+      return project.resolve(relative.replace(/^\.?\//, ""));
+    } catch (error) {
+      throw new Error(
+        `files: ${what} outside the project is refused \u2014 ${relative} (${error instanceof Error ? error.message : String(error)})`
+      );
+    }
+  };
+  const cacheOnly = (relative) => {
+    const clean = relative.replace(/^\.?\//, "");
+    if (!clean.startsWith(".cascade-cache/"))
+      throw new Error(
+        `files: writes are confined to .cascade-cache/ \u2014 got ${clean}. A node's output is derived data, and the same rule applies in the browser.`
+      );
+    return within2(clean, "writing");
+  };
+  const live = (options) => {
+    if (options.signal.aborted) throw new Error("files: cancelled");
+  };
+  return {
+    async read(relative, options) {
+      live(options);
+      return new Uint8Array(await fs.readFile(within2(relative, "reading")));
+    },
+    async write(relative, data, options) {
+      live(options);
+      const full = cacheOnly(relative);
+      await fs.mkdir(path.dirname(full), { recursive: true });
+      await fs.writeFile(full, data);
+    },
+    async list(relative, options) {
+      live(options);
+      const full = within2(relative, "listing");
+      try {
+        const entries = await fs.readdir(full, { withFileTypes: true });
+        return entries.map((entry) => entry.isDirectory() ? `${entry.name}/` : entry.name).sort();
+      } catch (error) {
+        if (error.code === "ENOENT") return [];
+        throw error;
+      }
+    },
+    async stat(relative, options) {
+      live(options);
+      try {
+        const stats = await fs.stat(within2(relative, "reading"));
+        return { size: stats.size, modifiedAt: stats.mtimeMs };
+      } catch (error) {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+    }
+  };
+}
+
+// src/cli/nodeAssets.ts
+import path3 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/cli/headlessIo.ts
+import crypto from "node:crypto";
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+
+// server/src/runtime/io.ts
+var IO_BRIDGE_KEY = "__cascadeIoBridge";
+function installIoBridge(bridge) {
+  const globals = globalThis;
+  const previous = globals[IO_BRIDGE_KEY];
+  globals[IO_BRIDGE_KEY] = bridge ?? void 0;
+  return () => {
+    globals[IO_BRIDGE_KEY] = previous;
+  };
+}
+
+// src/cli/headlessIo.ts
+var CACHE_DIR = ".cascade-cache";
+function contentAddressed(relative, body) {
+  const hash = crypto.createHash("sha1").update(body).digest("hex").slice(0, 12);
+  const directory = path2.posix.dirname(relative);
+  const name = path2.posix.basename(relative);
+  const [stem, ...rest] = name.split(".");
+  const tail = rest.length ? `.${rest.join(".")}` : "";
+  return path2.posix.join(directory, `${stem}.${hash}${tail}`);
+}
+function createIoBridge(project) {
+  return {
+    async read(relative) {
+      const full = project.resolveMedia(relative.replace(/^\.?\//, ""));
+      try {
+        return await fs2.readFile(full);
+      } catch (error) {
+        throw new Error(`cascade/io: cannot load ${relative} \u2014 ${error instanceof Error ? error.message : error}`);
+      }
+    },
+    async write(relative, data) {
+      const clean = relative.replace(/^\.?\//, "");
+      if (!clean.startsWith(`${CACHE_DIR}/`)) {
+        throw new Error(`cascade/io: writes are confined to ${CACHE_DIR}/ \u2014 got ${clean}`);
+      }
+      if (!data.byteLength) throw new Error(`cascade/io: refusing to write an empty file to ${clean}`);
+      const target = contentAddressed(clean, data);
+      const full = project.resolve(target);
+      await fs2.mkdir(path2.dirname(full), { recursive: true });
+      await fs2.writeFile(full, data);
+      return target;
+    }
+  };
+}
+function installProjectIo(project) {
+  return installIoBridge(createIoBridge(project));
+}
+
+// src/cli/nodeAssets.ts
+var CACHE_DIR2 = ".cascade-cache";
+function assetFileName(suggested) {
+  const base = path3.posix.basename(String(suggested ?? "").split("\\").join("/").trim());
+  const safe2 = base.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
+  return safe2 || "asset.bin";
+}
+function createNodeAssetCapability(project) {
+  const io = createIoBridge(project);
+  return {
+    async read(ref) {
+      return io.read(ref.path);
+    },
+    async write(data, metadata) {
+      const written = await io.write(`${CACHE_DIR2}/${assetFileName(metadata.suggestedName)}`, data);
+      return { path: written, ...metadata.mediaType ? { mediaType: metadata.mediaType } : {} };
+    },
+    async resolveUrl(ref) {
+      const full = project.resolveMedia(String(ref.path).replace(/^\.?\//, ""));
+      return { value: pathToFileURL(full).href, release: () => {
+      } };
+    }
+  };
+}
+
+// src/cli/imageOutputs.ts
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg", ".ppm", ".pgm", ".tif", ".tiff", ".exr", ".bmp", ".avif", ".hdr"]);
+function looksLikeImage(value) {
+  const file = imagePath(value);
+  if (!file) return false;
+  const mediaType = value && typeof value === "object" ? value.mediaType : void 0;
+  if (typeof mediaType === "string") return mediaType.startsWith("image/");
+  return IMAGE_EXTENSIONS.has(path4.extname(file).toLowerCase());
+}
+function collectImageOutputs(graph, options = {}) {
+  const wanted = new Set(options.nodes ?? []);
+  const extra = new Set(options.extra ?? []);
+  const found = [];
+  const inspection = graph.inspect();
+  const isAssertion = (moduleId2) => moduleId2.startsWith("cascade.assert.");
+  const assertions = new Set(inspection.nodes.filter((node) => isAssertion(node.moduleId)).map((node) => node.id));
+  const consumed = new Set(inspection.connections.filter((connection) => !assertions.has(connection.target.nodeId)).map((connection) => `${connection.source.nodeId}\0${connection.source.outputName}`));
+  for (const node of inspection.nodes) {
+    const named = wanted.has(node.id) || extra.has(node.id);
+    if (wanted.size && !named) continue;
+    if (!named && assertions.has(node.id)) continue;
+    const ports = Object.entries(node.outputs).filter(([, port]) => port.value !== void 0 && (port.type === "image" || port.type === "any" && looksLikeImage(port.value)));
+    for (const [name, port] of ports) {
+      if (!named && port.connected && consumed.has(`${node.id}\0${name}`)) continue;
+      found.push({ nodeId: node.id, port: name, value: port.value, shared: ports.length > 1 });
+    }
+  }
+  return found;
+}
+function unknownNodes(graph, ids) {
+  const known = new Set(graph.inspect().nodes.map((node) => node.id));
+  return ids.filter((id) => !known.has(id));
+}
+var safe = (text) => text.replace(/[^a-zA-Z0-9_-]/g, "_");
+function outputStem(output) {
+  return output.shared ? `${safe(output.nodeId)}.${safe(output.port)}` : safe(output.nodeId);
+}
+function stillFileName(output, source) {
+  return `${outputStem(output)}${path4.extname(source) || ".png"}`;
+}
+async function saveStillImages(graph, project, options) {
+  const missing = unknownNodes(graph, [...options.nodes ?? [], ...options.extra ?? []]);
+  if (missing.length) throw new Error(`No node ${missing.map((id) => `"${id}"`).join(", ")} in this graph (--node/--out-node take node ids; cascade graph read lists them).`);
+  const outputs = collectImageOutputs(graph, options);
+  const out = options.out ? outDirectory(options.out, (relative) => project.resolve(relative)) : void 0;
+  if (out) await fs3.mkdir(out.directory, { recursive: true });
+  const saved = [];
+  for (const output of outputs) {
+    const relative = imagePath(output.value)?.replace(/^\.?\//, "");
+    if (!relative) continue;
+    const source = path4.isAbsolute(relative) ? relative : project.resolveMedia(relative);
+    if (!out) {
+      saved.push({ node: output.nodeId, port: output.port, source });
+      continue;
+    }
+    const name = stillFileName(output, relative);
+    await fs3.copyFile(source, path4.join(out.directory, name));
+    saved.push({ node: output.nodeId, port: output.port, source, file: out.spell(name) });
+  }
+  if (out && !saved.length) {
+    throw new Error("--out: no image output to save. The graph has no unconsumed image port; name one with --node, or a mid-graph one with --out-node.");
+  }
+  return saved;
+}
+function outDirectory(out, resolveInProject) {
+  if (path4.isAbsolute(out)) {
+    const directory = path4.resolve(out);
+    return { directory, spell: (name) => path4.join(directory, name) };
+  }
+  return { directory: resolveInProject(out), spell: (name) => path4.posix.join(out.split(path4.sep).join("/"), name) };
+}
+
+// src/cli/headlessGpu.ts
+var MISSING_GPU_MESSAGE = 'Cascade cannot load the optional Dawn WebGPU renderer. Install "webgpu@0.6.0" on a supported platform and run again.';
+function createDawnGpuHost() {
+  return createGpuHost({
+    async acquire() {
+      let dawn;
+      try {
+        dawn = await import("webgpu");
+      } catch (cause) {
+        throw Object.assign(new Error(MISSING_GPU_MESSAGE), { cause });
+      }
+      let gpu = dawn.create([]);
+      let device;
+      try {
+        const adapter = await gpu.requestAdapter();
+        if (!adapter) throw new Error("Dawn found no WebGPU adapter. Check GPU drivers and backend availability; headless rendering still needs a hardware or explicitly configured software adapter.");
+        device = await adapter.requestDevice();
+        const info = adapter.info;
+        return { device, info: {
+          vendor: info.vendor,
+          architecture: info.architecture,
+          device: info.device,
+          description: info.description
+        }, limits: device.limits, release: () => {
+          gpu = void 0;
+        } };
+      } catch (error) {
+        device?.destroy();
+        gpu = void 0;
+        throw error;
+      }
+    }
+  });
+}
+
+// src/cli/projectRuntime.ts
+function createProjectHost(file, registrations) {
+  const project = new ProjectRoot(path5.dirname(path5.resolve(file)));
+  return createNodeRuntimeHost({
+    modules: resolver(registrations),
+    shell: project.shell,
+    // `assets` is the browser's alone until it is given here, and
+    // `cascade.geo.SvgExport` declares it — so an export graph passed both
+    // `validate` and `check` and then refused to run. See ./nodeAssets.ts
+    // for where the file lands and why.
+    assets: createNodeAssetCapability(project),
+    // Same reason as `assets` above, found the same way: `files` was valid in
+    // the contract and installed by nobody, so a node declaring it ran with
+    // `undefined` — and the workaround that worked was an undeclared `node:fs`
+    // import, which is the invisible version of the thing declarations exist
+    // to make visible. See ./nodeFiles.ts for the containment rules.
+    files: createNodeFileCapability(project),
+    gpu: createDawnGpuHost()
+  });
+}
+async function preflightAgainstRunHost(file, registrations, document2) {
+  let host;
+  let checkable = true;
+  try {
+    host = createProjectHost(file, registrations);
+  } catch (error) {
+    console.warn(`Capability check skipped: ${error instanceof Error ? error.message : error}`);
+    host = createNodeRuntimeHost({ modules: resolver(registrations) });
+    checkable = false;
+  }
+  const runtime = createRuntime({ host, nodes: registrations });
+  let diagnostics = [];
+  try {
+    const graph = await runtime.load(document2);
+    if (checkable) diagnostics = graph.preflight();
+  } finally {
+    await runtime.dispose();
+    await disposeProjectGpu(host);
+  }
+  if (!diagnostics.length) return;
+  const { errors, warnings } = classifyPreflight(diagnostics);
+  reportPreflightWarnings(host, warnings);
+  if (!errors.length) return;
+  const bundleOnly = errors.every((item) => item.code.startsWith("runtime/bundle-"));
+  throw new Error([
+    bundleOnly ? "Bundle fields do not match what their producers declare:" : `This graph cannot run on the ${host.environment} host that "cascade run" uses:`,
+    ...errors.map(line),
+    ...capabilityAdvice(host, errors)
+  ].join("\n"));
+}
+function reportPreflightWarnings(host, warnings) {
+  const elsewhere = warnings.filter((item) => item.code === "runtime/preflight-environment");
+  const lossy = warnings.filter((item) => item.code === "runtime/stray-params" || item.code === "runtime/unknown-props");
+  if (elsewhere.length) {
+    console.warn([
+      `Not checkable here \u2014 ${elsewhere.length === 1 ? "one node" : `${elsewhere.length} nodes`} in this graph target${elsewhere.length === 1 ? "s" : ""} another host:`,
+      ...elsewhere.map(line),
+      `  The CLI runs the ${host.environment} host, so "cascade run" cannot run this graph. Nothing above says the graph is wrong.`
+    ].join("\n"));
+  }
+  if (lossy.length) {
+    console.warn([
+      `Stored values were dropped on load \u2014 ${lossy.length === 1 ? "one node" : `${lossy.length} nodes`}:`,
+      ...lossy.map(line),
+      `  This graph will run, on the defaults, and look like it worked.`
+    ].join("\n"));
+  }
+}
+function line(item) {
+  return `  ${item.code}${item.path ? ` [${item.path}]` : ""}: ${item.message}`;
+}
+function classifyPreflight(diagnostics) {
+  return {
+    errors: diagnostics.filter((item) => !PREFLIGHT_WARNING_CODES.has(item.code)),
+    warnings: diagnostics.filter((item) => PREFLIGHT_WARNING_CODES.has(item.code))
+  };
+}
+function capabilityAdvice(host, diagnostics) {
+  const missing = [...new Set(diagnostics.filter((item) => item.code === "runtime/missing-capability").map((item) => /Missing capability (\w+)/.exec(item.message)?.[1] ?? "").filter(Boolean))];
+  if (!missing.length) return [];
+  const hostCapabilities = CAPABILITIES_BY_ENVIRONMENT[host.environment] ?? [];
+  return missing.map((name) => hostCapabilities.includes(name) ? `  ${name}: declared in @cascade/contracts but not installed by the host \u2014 drop it from the definition, or install it where the host is built (createProjectHost, src/cli/projectRuntime.ts).` : `  ${name}: a ${environmentOwning(name)} capability. The CLI runs the ${host.environment} host, so no CLI run can supply it.`);
+}
+function environmentOwning(capability) {
+  const owners = Object.entries(CAPABILITIES_BY_ENVIRONMENT).filter(([, names]) => names.includes(capability)).map(([environment]) => environment);
+  return owners.length ? owners.join("/") : "unknown";
+}
+function reportUnresolved(prepared, strict = false) {
+  if (!prepared.unresolved.length) return 0;
+  const count = prepared.unresolved.length;
+  const summary = [
+    `${count === 1 ? "One module has no file" : `${count} modules have no file`}:`,
+    ...prepared.unresolved.map(line)
+  ].join("\n");
+  if (strict) throw new Error(summary);
+  console.warn(summary);
+  return count;
+}
+function usesDeterministicHost(document2, prepared) {
+  const nodes = Array.isArray(document2?.nodes) ? document2.nodes : [];
+  const deterministicCount = nodes.filter((node) => prepared.deterministic.has(moduleId(node))).length;
+  if (!nodes.length || deterministicCount === 0) return false;
+  if (deterministicCount !== nodes.length) {
+    throw new Error("Mixed deterministic and dynamic graphs are not executable until the bounded legacy adapter is implemented");
+  }
+  return true;
+}
+async function validateProjectGraph(file, document2, strict = false) {
+  const prepared = await prepare(file, document2, false);
+  const unresolved = reportUnresolved(prepared, strict);
+  const nodes = document2.nodes;
+  if (nodes.some((node) => !prepared.deterministic.has(moduleId(node)))) {
+    validateDynamicDocument(document2);
+    return unresolved;
+  }
+  await preflightAgainstRunHost(file, prepared.registrations, document2);
+  return unresolved;
+}
+async function checkProjectGraph(file, document2, strict = false) {
+  const prepared = await prepare(file, document2, false);
+  const unresolved = reportUnresolved(prepared, strict);
+  const nodes = document2.nodes;
+  const dynamic = [...new Set(nodes.map(moduleId).filter((id) => id && !prepared.deterministic.has(id)))];
+  if (dynamic.length) {
+    throw new Error(`Static check requires definition-v1 modules; dynamic modules: ${dynamic.join(", ")}`);
+  }
+  await preflightAgainstRunHost(file, prepared.registrations, document2);
+  return unresolved;
+}
+async function runDeterministicProjectGraph(file, document2, entryNode, observe, afterRun) {
+  const prepared = await prepare(file, document2, true);
+  reportUnresolved(prepared);
+  if (!usesDeterministicHost(document2, prepared)) return false;
+  const host = createProjectHost(file, prepared.registrations);
+  const runtime = createRuntime({
+    host,
+    nodes: prepared.registrations
+  });
+  let graph;
+  try {
+    graph = await runtime.load(document2);
+    observe?.(graph);
+    reportPreflightWarnings(
+      host,
+      classifyPreflight(graph.preflight()).warnings.filter((item) => item.code === "runtime/stray-params" || item.code === "runtime/unknown-props")
+    );
+    const result = await graph.run(entryNode ? { target: { kind: "node", nodeId: entryNode } } : {});
+    if (result.status !== "completed") {
+      throw new Error(result.diagnostics.map((item) => item.message).join("\n") || `Graph ${result.status}`);
+    }
+    await afterRun?.(graph);
+    return true;
+  } finally {
+    try {
+      await runtime.dispose();
+    } finally {
+      await disposeProjectGpu(host);
+    }
+  }
+}
+async function cookProjectGraph(file, document2, target, observe) {
+  const prepared = await prepare(file, document2, true);
+  reportUnresolved(prepared);
+  if (!usesDeterministicHost(document2, prepared))
+    throw new Error("This graph mixes execution styles or uses dynamic modules; only definition-v1 graphs can be cooked for their values");
+  const host = createProjectHost(file, prepared.registrations);
+  const runtime = createRuntime({ host, nodes: prepared.registrations });
+  try {
+    const graph = await runtime.load(document2);
+    observe?.(graph);
+    const result = await graph.run(target ? { target: { kind: "node", nodeId: target } } : {});
+    if (result.status !== "completed")
+      throw new Error(result.diagnostics.map((item) => item.message).join("\n") || `Graph ${result.status}`);
+    const outputs = /* @__PURE__ */ new Map();
+    for (const node of graph.inspect().nodes) outputs.set(node.id, new Map(graph.getOutputs(node.id)));
+    return { outputs, assets: host.capabilities?.assets };
+  } finally {
+    try {
+      await runtime.dispose();
+    } finally {
+      await disposeProjectGpu(host);
+    }
+  }
+}
+async function renderDeterministicProjectFrames(file, document2, options) {
+  const prepared = await prepare(file, document2, true);
+  reportUnresolved(prepared);
+  if (!usesDeterministicHost(document2, prepared)) return null;
+  const project = new ProjectRoot(path5.dirname(path5.resolve(file)));
+  const host = createProjectHost(file, prepared.registrations);
+  const runtime = createRuntime({
+    host,
+    nodes: prepared.registrations
+  });
+  let graph;
+  const width = sequenceWidth(options.end);
+  const frames = [];
+  const files = [];
+  let aborted = false;
+  let gpu;
+  const started = performance.now();
+  try {
+    graph = await runtime.load(document2);
+    options.observe?.(graph);
+    reportPreflightWarnings(host, classifyPreflight(graph.preflight()).warnings);
+    const targets = options.nodes?.length ? options.nodes : options.entryNode ? [options.entryNode] : [];
+    const extra = options.outNodes ?? [];
+    const out = outDirectory(options.out, (relative) => project.resolve(relative));
+    await fs4.mkdir(out.directory, { recursive: true });
+    const missing = unknownNodes(graph, [...targets, ...extra]);
+    if (missing.length) throw new Error(`No node ${missing.map((id) => `"${id}"`).join(", ")} in this graph (--node/--out-node take node ids; cascade graph read lists them).`);
+    for await (const frame of options.frameSource ?? frameRange(options.start, options.end, options.step ?? 1)) {
+      const frameStarted = performance.now();
+      if (options.signal?.aborted) {
+        aborted = true;
+        break;
+      }
+      const result = await graph.run({
+        frame,
+        /**
+         * Only what this frame changed cooks: a node whose props (time
+         * reaches nodes through props) and inputs are unchanged, and that
+         * nothing which cooked this frame feeds, keeps its outputs from the
+         * last frame. Strict, so an upstream that re-ran is never trusted on
+         * equal values. The morph's Moments and Match cook once per film.
+         */
+        ...options.fresh ? {} : { reuse: "strict" },
+        ...options.fps === void 0 ? {} : { fps: options.fps },
+        /**
+         * One named node narrows the COOK as well as the output, because the
+         * runtime can walk back from a single target. Several cannot be
+         * expressed as one target, so the graph cooks whole and only the saving
+         * narrows — which is still the bulk of the win when the outputs are
+         * 18 MB PNGs.
+         */
+        ...targets.length === 1 && !extra.length ? { target: { kind: "node", nodeId: targets[0] } } : {}
+      });
+      if (result.status !== "completed") {
+        throw new Error(
+          `frame ${frame} ${result.status} \u2014 ${result.diagnostics.map((item) => item.message).join("; ") || "no diagnostics"}`
+        );
+      }
+      const outputs = collectImageOutputs(graph, { nodes: targets, extra });
+      if (!outputs.length) {
+        throw new Error(
+          targets.length || extra.length ? `No image output on ${[...targets, ...extra].join(", ")} \u2014 check that the node has an image output (or a Null passing one).` : "No image output to save: the graph has no unconsumed image port. Name the node to render with --node, or a mid-graph one to save as well with --out-node."
+        );
+      }
+      const written = [];
+      for (const output of outputs) {
+        const source = imagePath(output.value);
+        if (!source) continue;
+        const name = sequenceFileName(output.nodeId, frame, source, width, output.shared ? output.port : void 0);
+        const relative = source.replace(/^\.?\//, "");
+        await fs4.copyFile(project.resolveMedia(relative), path5.join(out.directory, name));
+        files.push(out.spell(name));
+        written.push({ nodeId: output.nodeId, port: output.port, source: relative, file: out.spell(name) });
+      }
+      frames.push(frame);
+      await options.onFrame?.({ frame, outputs: written, durationMs: performance.now() - frameStarted });
+      if (options.verbose) console.log(`  frame ${frame}`);
+    }
+    try {
+      gpu = { renderer: "dawn", adapter: host.capabilities.gpu.adapterInfo };
+    } catch {
+    }
+  } finally {
+    try {
+      await runtime.dispose();
+    } finally {
+      await disposeProjectGpu(host);
+    }
+  }
+  return { frames, files, aborted, fps: graph.getFps(), durationMs: performance.now() - started, ...gpu ? { gpu } : {} };
+}
+async function disposeProjectGpu(host) {
+  await host.capabilities.gpu?.dispose();
+}
+async function inspectProjectGraph(file, document2) {
+  const prepared = await prepare(file, document2, false);
+  reportUnresolved(prepared);
+  const registrations = new Map(
+    [...headlessBuiltinRegistrations, ...prepared.registrations].map((item) => [item.moduleId, item])
+  );
+  const nodes = document2.nodes.map((node) => {
+    const id = moduleId(node);
+    return {
+      id: node.id,
+      module: id,
+      classification: prepared.deterministic.has(id) ? "definition-v1" : "dynamic",
+      ...prepared.deterministic.has(id) ? { definition: registrations.get(id)?.definition } : {}
+    };
+  });
+  return {
+    file: path5.resolve(file),
+    version: document2.version ?? null,
+    deterministic: nodes.length > 0 && nodes.every((node) => node.classification === "definition-v1"),
+    nodes,
+    connections: Array.isArray(document2.connections) ? document2.connections.length : 0
+  };
+}
+async function prepare(file, document2, compileExecutors) {
+  if (!document2 || typeof document2 !== "object" || !Array.isArray(document2.nodes)) {
+    throw new Error("Graph document must contain a nodes array");
+  }
+  const projectRoot = path5.dirname(path5.resolve(file));
+  const registrations = [];
+  const deterministic = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const unresolved = [];
+  for (const node of document2.nodes) {
+    const id = moduleId(node);
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    if (builtinNodeRegistration(id)) {
+      deterministic.add(id);
+      continue;
+    }
+    const headless = headlessBuiltin(id);
+    if (headless) {
+      deterministic.add(id);
+      registrations.push(headless);
+      continue;
+    }
+    const resolved = await projectModuleFile(projectRoot, node, id);
+    const moduleFile = resolved.file;
+    if (!moduleFile) {
+      unresolved.push(unresolvedModule(id, node, resolved.tried, projectRoot));
+      registrations.push(savedRegistration(id, node));
+      continue;
+    }
+    const source = await fs4.readFile(moduleFile, "utf8");
+    const mentionsDefinition = /\bexport\s+const\s+definition\b/.test(source);
+    const extracted = extractNodeDefinition(source, moduleFile, ts);
+    if (!extracted.ok) {
+      const reExport = reExportedDefinition(source);
+      if (reExport) throw new Error(formatDiagnostic(reExport(moduleFile)));
+      if (!mentionsDefinition && extracted.diagnostics.every((item) => item.code === "definition/missing-export")) {
+        registrations.push(savedRegistration(id, node));
+        continue;
+      }
+      throw new Error(extracted.diagnostics.map(formatDiagnostic).join("\n"));
+    }
+    const architectureDiagnostics = validateNodeModuleArchitecture(source, moduleFile, ts);
+    if (architectureDiagnostics.length) {
+      throw new Error(architectureDiagnostics.map(formatDiagnostic).join("\n"));
+    }
+    let executor;
+    deterministic.add(id);
+    registrations.push({
+      kind: "definition-v1",
+      moduleId: id,
+      definition: extracted.definition,
+      loadExecute: compileExecutors ? () => executor ??= compileExecute(projectRoot, moduleFile) : async () => {
+        throw new Error("Static validation never loads execute");
+      }
+    });
+  }
+  return { registrations, deterministic, unresolved };
+}
+async function projectModuleFile(root, node, id) {
+  const tried = [];
+  const source = node.source;
+  if (source && typeof source === "object" && source.type === "project" && typeof source.file === "string") {
+    const candidate2 = path5.resolve(root, source.file);
+    if (within(root, candidate2)) {
+      tried.push(candidate2);
+      if (await exists(candidate2)) return { file: candidate2, tried };
+    }
+  }
+  if (!id.startsWith("project.")) return { file: null, tried };
+  const name = id.slice("project.".length);
+  const candidate = path5.resolve(root, "nodes", name, "index.ts");
+  if (!within(root, candidate)) return { file: null, tried };
+  tried.push(candidate);
+  return { file: await exists(candidate) ? candidate : null, tried };
+}
+function reExportedDefinition(source) {
+  const named = /\bexport\s*\{[^}]*\bdefinition\b[^}]*\}\s*from\s*['"]/.test(source);
+  const star = /\bexport\s*\*\s*from\s*['"]/.test(source);
+  if (!named && !star) return null;
+  const what = named ? "this module re-exports `definition` from another file" : "this module has a star re-export and no `definition` of its own";
+  return (file) => ({
+    phase: "prepare",
+    code: "definition/re-exported",
+    file,
+    message: `${what}, and a definition cannot arrive that way \u2014 it is read statically from this file. Write the literal here, or keep the stub for \`execute\` only and leave this module dynamic. Without this the node loads as dynamic and every command reports success.`
+  });
+}
+function unresolvedModule(id, node, tried, root) {
+  const relative = tried.map((candidate) => path5.relative(root, candidate) || candidate);
+  const where = relative.length ? `looked for ${relative.join(" and ")}` : `no project file is possible for this module id \u2014 a project module is named "project.<dir>" or carries a source file`;
+  return {
+    phase: "prepare",
+    code: "project/module-not-found",
+    path: node.id,
+    message: `${id} has no module file \u2014 ${where}. Only known legacy modules can use saved-port compatibility, for inspection only; unknown and explicit project modules are rejected`
+  };
+}
+async function compileExecute(projectRoot, moduleFile) {
+  const cache = path5.join(projectRoot, ".cascade-cache", "nodes");
+  await fs4.mkdir(cache, { recursive: true });
+  const output = path5.join(cache, `${path5.basename(path5.dirname(moduleFile))}.mjs`);
+  const staging = `${output}.${process.pid}.${Date.now()}.tmp`;
+  await build({
+    entryPoints: [moduleFile],
+    outfile: staging,
+    bundle: true,
+    packages: "external",
+    platform: "node",
+    target: "node20",
+    format: "esm",
+    sourcemap: "inline",
+    plugins: [cliImageModule()]
+  });
+  await fs4.rename(staging, output);
+  const loaded = await import(`${pathToFileURL2(output).href}?v=${Date.now()}`);
+  if (typeof loaded.execute !== "function") throw new Error(`${moduleFile} does not export execute`);
+  return loaded.execute;
+}
+function cliImageModule() {
+  const here = path5.dirname(fileURLToPath(import.meta.url));
+  const source = [
+    path5.join(here, "runtime", "image.ts"),
+    // dist/cli/runtime, copied by build-cli
+    path5.join(here, "..", "..", "server", "src", "runtime", "image.ts")
+    // running from src
+  ].find((candidate) => existsSync(candidate));
+  return {
+    name: "cascade-cli-image",
+    setup(builder) {
+      if (!source) return;
+      builder.onResolve({ filter: /^(?:@field\/)?cascade\/image$/ }, () => ({ path: source }));
+    }
+  };
+}
+function savedRegistration(moduleId2, node) {
+  return {
+    kind: "definition-v1",
+    moduleId: moduleId2,
+    definition: savedDefinition(node),
+    loadExecute: async () => {
+      throw new Error(`Legacy module ${moduleId2} cannot run through the deterministic runtime`);
+    }
+  };
+}
+function savedDefinition(node) {
+  const inputs = portDefinitions(node.inputs, "input");
+  const outputs = portDefinitions(node.outputs, "output");
+  const used = new Set(Object.keys(inputs));
+  const props = Object.fromEntries(Object.entries(node.props ?? {}).filter(([name]) => !used.has(name)).map(([name, value]) => [name, {
+    type: "any",
+    default: jsonValue(value && typeof value === "object" && "value" in value ? value.value : value)
+  }]));
+  return {
+    apiVersion: 1,
+    runsOn: "portable",
+    inputs,
+    outputs,
+    props
+  };
+}
+function validateDynamicDocument(document2) {
+  if (!Array.isArray(document2.nodes)) throw new Error("Graph document must contain a nodes array");
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of document2.nodes) {
+    if (!node || typeof node.id !== "string" || !node.id || !moduleId(node)) {
+      throw new Error("Every graph node must have a non-empty id and module");
+    }
+    if (ids.has(node.id)) throw new Error(`Duplicate node id: ${node.id}`);
+    ids.add(node.id);
+  }
+  if (document2.connections !== void 0 && !Array.isArray(document2.connections)) {
+    throw new Error("Graph connections must be an array");
+  }
+  for (const [index, connection] of (document2.connections ?? []).entries()) {
+    const endpoints = Array.isArray(connection) ? connection : [connection?.source, connection?.target];
+    if (endpoints.length !== 2) throw new Error(`Connection ${index} must have two endpoints`);
+    for (const endpoint of endpoints) {
+      const nodeId = Array.isArray(endpoint) ? endpoint[0] : endpoint?.nodeId;
+      if (typeof nodeId !== "string" || !ids.has(nodeId)) {
+        throw new Error(`Connection ${index} references an unknown node`);
+      }
+    }
+  }
+}
+function portDefinitions(value, direction) {
+  if (!Array.isArray(value)) return {};
+  return Object.fromEntries(value.flatMap((port, index) => {
+    const name = typeof port?.name === "string" && /^[A-Za-z][A-Za-z0-9_]*$/.test(port.name) ? port.name : `${direction}_${index}`;
+    if (port?.portType === "trigger" || port?.dataType === "trigger") return [[name, { kind: "trigger" }]];
+    const definition = { kind: "data", type: cascadeType(port?.dataType) };
+    if (direction === "input" && ("defaultValue" in (port ?? {}) || "value" in (port ?? {}))) {
+      definition.default = jsonValue("defaultValue" in port ? port.defaultValue : port.value);
+    }
+    return [[name, definition]];
+  }));
+}
+function moduleId(node) {
+  return typeof node?.module === "string" ? node.module : typeof node?.type === "string" ? node.type : "";
+}
+function cascadeType(value) {
+  if (value === "number") return "float";
+  if (value === "boolean") return "bool";
+  return typeof value === "string" && value !== "trigger" ? value : "any";
+}
+function jsonValue(value) {
+  try {
+    return value === void 0 ? null : JSON.parse(JSON.stringify(value));
+  } catch {
+    return null;
+  }
+}
+function resolver(registrations) {
+  const modules = new Map(registrations.map((registration) => [registration.moduleId, registration]));
+  return { resolve: async (id) => modules.get(id) ?? null };
+}
+function formatDiagnostic(diagnostic) {
+  const location = diagnostic.file ? `${diagnostic.file}${diagnostic.line ? `:${diagnostic.line}:${diagnostic.column}` : ""}: ` : "";
+  return `${location}${diagnostic.code}: ${diagnostic.message}`;
+}
+function within(root, candidate) {
+  const relative = path5.relative(path5.resolve(root), candidate);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+async function exists(file) {
+  try {
+    await fs4.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function moduleDefinitions(file, ids) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const id of new Set(ids)) {
+    const builtin = headlessBuiltin(id);
+    if (builtin) {
+      definitions.set(id, builtin.definition);
+      continue;
+    }
+    try {
+      const prepared = await prepare(file, { nodes: [{ id: "probe", module: id }] }, false);
+      definitions.set(id, prepared.deterministic.has(id) ? prepared.registrations[0]?.definition : void 0);
+    } catch {
+      definitions.set(id, void 0);
+    }
+  }
+  return definitions;
+}
+function builtinModuleIds() {
+  return headlessBuiltinRegistrations.map((registration) => registration.moduleId);
+}
+async function diagnoseGraph(file, document2) {
+  const errors = [];
+  const warnings = [];
+  try {
+    const prepared = await prepare(file, document2, false);
+    for (const item of prepared.unresolved) warnings.push(line(item).trim());
+    const nodes = document2.nodes;
+    if (nodes.some((node) => !prepared.deterministic.has(moduleId(node)))) {
+      validateDynamicDocument(document2);
+      return { errors, warnings };
+    }
+    let host;
+    try {
+      host = createProjectHost(file, prepared.registrations);
+    } catch {
+      host = createNodeRuntimeHost({ modules: resolver(prepared.registrations) });
+    }
+    const runtime = createRuntime({ host, nodes: prepared.registrations });
+    try {
+      const graph = await runtime.load(document2);
+      const classified = classifyPreflight(graph.preflight());
+      errors.push(...classified.errors.map((item) => line(item).trim()));
+      warnings.push(...classified.warnings.map((item) => line(item).trim()));
+    } finally {
+      await runtime.dispose();
+      await disposeProjectGpu(host);
+    }
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return { errors, warnings };
+}
+
+export {
+  PREFLIGHT_WARNING_CODES,
+  createRuntime,
+  validateNodeModuleArchitecture,
+  installProjectIo,
+  saveStillImages,
+  createProjectHost,
+  classifyPreflight,
+  validateProjectGraph,
+  checkProjectGraph,
+  runDeterministicProjectGraph,
+  cookProjectGraph,
+  renderDeterministicProjectFrames,
+  inspectProjectGraph,
+  projectModuleFile,
+  moduleId,
+  moduleDefinitions,
+  builtinModuleIds,
+  diagnoseGraph
+};
+//# sourceMappingURL=chunk-EUIAC3U3.js.map