@field/cascade 0.3.0 → 0.4.0

package/dist/runtime/runtime.js

@@ -4,6 +4,7 @@ import { builtinNodeRegistrations } from "./builtins/index.js";
 import { deserializeChannel, isEmptyChannel } from "./animation/channel.js";
 import { PropAnimator, isBoundProp } from "./params/index.js";
 import { DEFAULT_FPS, MIN_FRAME } from "./expressions/time.js";
+import { isGpuHost } from "./gpu.js";
 /**
  * Preflight codes that describe something other than "this graph cannot run
  * here", so `run` proceeds and a checker reports them as warnings.
@@ -21,13 +22,47 @@ import { DEFAULT_FPS, MIN_FRAME } from "./expressions/time.js";
  * leftover `params` array runs perfectly well on its defaults, which is
  * precisely the problem.
  *
- * This set lives here rather than in the CLI because the run path and the
- * check path both need it, and it was a duplicated rule that let `validate`
- * and `check` pass graphs `run` then rejected.
+ * It was briefly an error, and Marcus reverted that on 2026-09-08 with the
+ * evidence that decides it: while converting sixty-two nodes across four
+ * sketches, every one of them was a mixed graph for most of the day, and as an
+ * error an unconverted or half-converted sketch **stops validating at all** —
+ * which is the one thing you need while converting it. The warning is the
+ * conversion checklist; as an error it is a locked door on the room you are
+ * working in.
+ *
+ * The fair case for the error was that the warning never fired, and that was
+ * true: `check` bailed on dynamic modules before preflight ran. The fix for
+ * that was the reporting *order*, not the severity.
+ *
+ * This set lives here rather than in the CLI because both paths read it, and a
+ * duplicated copy is what let `validate` and `check` pass graphs `run` then
+ * rejected.
+ *
+ * **It classifies a static check, and it is not the run gate.** Those are
+ * different questions and conflating them was a real bug of mine, caught by
+ * Codex's own comment on 2026-09-08: *execution is stricter.* A server run must
+ * still refuse a browser node — you cannot cook WebGPU headlessly, so tolerating
+ * it means executing and failing on an undefined capability instead of saying
+ * why. What a static check downgrades is the *checker's reach*; what a run
+ * tolerates is much narrower. See `RUN_TOLERATED_CODES`.
  */
 export const PREFLIGHT_WARNING_CODES = new Set([
     "runtime/preflight-environment",
     "runtime/stray-params",
+    "runtime/unknown-props",
+]);
+/**
+ * The only preflight code that does not stop a run.
+ *
+ * A stranded `params` value is a fact about the document: the graph cooks
+ * perfectly well on its defaults, which is exactly the problem, and refusing to
+ * run is the worse answer. Everything else in the preflight is a reason this
+ * host cannot execute this graph — an environment mismatch and a missing
+ * capability both mean the cook would fail partway with a worse message.
+ */
+const RUN_TOLERATED_CODES = new Set([
+    "runtime/stray-params",
+    "runtime/unknown-props",
 ]);
 class MutableAbortSignal {
     report;
@@ -148,6 +183,10 @@ class Graph {
     onDispose;
     graphState = "ready";
     byId;
+    dataConnectionsByInput;
+    dataConnectionsByNode;
+    connectedInputs;
+    connectedOutputs;
     listeners = new Set();
     diagnostics = [];
     active;
@@ -173,6 +212,34 @@ class Graph {
         this.connections = connections;
         this.onDispose = onDispose;
         this.byId = new Map(nodes.map((node) => [node.id, node]));
+        const byInput = new Map();
+        const byNode = new Map();
+        const connectedInputs = new Set();
+        const connectedOutputs = 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)));
@@ -180,10 +247,7 @@ class Graph {
             nodes,
             node: (id) => this.byId.get(id),
             inputNode: (node, index) => {
-                const feeding = this.connections
-                    .filter((connection) => connection.kind === "data" &&
-                    connection.target.nodeId === node.id)
-                    .sort((a, b) => a.order - b.order);
+                const feeding = this.dataConnectionsByNode.get(node.id) ?? [];
                 const source = feeding[index]?.source.nodeId;
                 return (source ? this.byId.get(source) : undefined) ?? null;
             },
@@ -228,8 +292,7 @@ class Graph {
                 {
                     kind: definition.kind,
                     type: definition.kind === "trigger" ? "trigger" : definition.type,
-                    connected: this.connections.some((connection) => connection.target.nodeId === node.id &&
-                        connection.target.inputName === name),
+                    connected: this.connectedInputs.has(`${node.id}\0${name}`),
                     ...(definition.kind === "data"
                         ? { value: snapshot(node.inputs[name]) }
                         : {}),
@@ -240,8 +303,7 @@ class Graph {
                 {
                     kind: definition.kind,
                     type: definition.kind === "trigger" ? "trigger" : definition.type,
-                    connected: this.connections.some((connection) => connection.source.nodeId === node.id &&
-                        connection.source.outputName === name),
+                    connected: this.connectedOutputs.has(`${node.id}\0${name}`),
                     ...(definition.kind === "data" && node.outputs.has(name)
                         ? { value: snapshot(node.outputs.get(name)) }
                         : {}),
@@ -549,10 +611,7 @@ class Graph {
                 const index = integerProp(node.props.inputIndex);
                 return [name, this.dataInputValue(parent, `input_${index}`)];
             }
-            const connections = this.connections.filter((item) => item.kind === "data" &&
-                item.target.nodeId === node.id &&
-                item.target.inputName === name).sort((first, second) => (first.variadicIndex ?? first.order) -
-                (second.variadicIndex ?? second.order));
+            const connections = this.dataConnectionsByInput.get(`${node.id}\0${name}`) ?? [];
             if (definition.variadic) {
                 const values = connections.map((connection) => this.requireNode(connection.source.nodeId).outputs.get(connection.source.outputName));
                 if (!values.length && node.inputs[name] !== undefined)
@@ -627,12 +686,23 @@ class Graph {
                     set: (value) => pendingData.set(name, runtimeValue(value, definition.type, false, `${node.id}.${name}`)),
                 },
         ]));
-        const capabilities = Object.freeze(Object.fromEntries((node.definition.capabilities ?? []).map((name) => [
-            name,
-            name === "shell"
-                ? bindShellToRun(this.host.capabilities.shell, signal)
-                : this.host.capabilities[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 }),
@@ -695,6 +765,8 @@ class Graph {
         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 — ${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 — 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);
@@ -740,7 +812,7 @@ class Graph {
             : `provides no capabilities`;
     }
     assertPreflight(nodes) {
-        const [first] = this.preflightDiagnostics(nodes).filter((diagnostic) => !PREFLIGHT_WARNING_CODES.has(diagnostic.code));
+        const [first] = this.preflightDiagnostics(nodes).filter((diagnostic) => !RUN_TOLERATED_CODES.has(diagnostic.code));
         if (first)
             throw new CascadeRuntimeError(first.code, [first]);
     }
@@ -754,7 +826,8 @@ class Graph {
     }
     runSelection(target) {
         if (target.kind === "all") {
-            const initial = this.nodes.filter((node) => !isGated(node) && !this.hasGatedDataAncestor(node.id));
+            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) {
@@ -799,8 +872,25 @@ class Graph {
         }
         return this.nodes.filter((node) => ids.has(node.id));
     }
-    hasGatedDataAncestor(nodeId) {
-        return this.dataClosure(nodeId).some(isGated);
+    gatedDataDescendants() {
+        const outgoing = 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);
@@ -948,8 +1038,41 @@ function materialize(authored, registration) {
         }
     for (const [name, definition] of Object.entries(registration.definition.props ?? {}))
         props[name] = runtimeValue(definition.default, definition.type, false, `${authored.id}.${name}`);
+    /**
+     * `props` is a map and `params` was a list, and a migration that changes the
+     * key without changing the shape leaves an array here.
+     *
+     * Fatal, and the reason is what it costs: `Object.entries` of an array gives
+     * keys `"0"`, `"1"`, which match no declared prop, so **every authored value
+     * is dropped and every signal stays green.** Measured on 2026-09-08 —
+     * preflight empty, the prop back at its default, `cascade run` reporting
+     * `completed`. `cloud-plots` rendered a whole picture against no moment and
+     * was reported as working on the strength of an exit code.
+     *
+     * An error rather than a warning, unlike a leftover under `params`: that is a
+     * real state an unconverted sketch is legitimately in and must keep
+     * validating, whereas `props` as an array is never valid — the schema
+     * declares a record — and nothing passes through it on the way to being
+     * right. Same reasoning as `definition/re-exported`.
+     */
+    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 = {};
-    for (const [name, saved] of Object.entries(authored.props ?? {})) {
+    // A declared default expression, applied only where the document stored
+    // nothing at all for the prop. The loop below then runs over what *was*
+    // stored, so an authored value or an authored expression overwrites this —
+    // which is the whole contract: a default expression is a default, and a file
+    // that saved a plain number keeps its number rather than quietly animating.
+    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;
@@ -961,8 +1084,12 @@ function materialize(authored, registration) {
             : null;
         const value = runtimeValue(object ? object.value : saved, definition.type, false, `${authored.id}.${name}`);
         props[name] = value;
-        if (!object)
+        // A stored plain value is an author's decision and beats the declared
+        // default expression, so any binding seeded above has to go.
+        if (!object) {
+            delete bindings[name];
             continue;
+        }
         const channel = deserializeChannel(object.channel);
         const expression = typeof object.expression === "string" && object.expression
             ? object.expression
@@ -987,6 +1114,7 @@ function materialize(authored, registration) {
         props,
         bindings,
         strayParams: strayParams(authored, registration),
+        unknownProps: unknownProps(authored, registration),
         outputs: new Map(),
     };
 }
@@ -1011,6 +1139,27 @@ function materialize(authored, registration) {
  * naming nothing is a different fault, and reporting it would make this fire on
  * documents where no value was lost.
  */
+/**
+ * Names stored under `props` that the definition does not declare.
+ *
+ * The mirror of `strayParams`, and the gap that one had: it asks *is anything
+ * still under the old key*, which is blind to *did what arrived under the new
+ * key arrive in the right form*. One is a leftover, the other is a botched
+ * move, and the second is worse because it looks finished.
+ *
+ * A warning rather than an error, because unlike an array container this is a
+ * state a real document reaches honestly: a prop renamed or removed from a
+ * definition leaves its value behind, and the graph runs on the defaults. Same
+ * class as a leftover under `params`, and the same severity for the same
+ * reason — a sketch mid-conversion must keep validating.
+ */
+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 = new Set([
@@ -1265,6 +1414,7 @@ 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)) {
@@ -1273,13 +1423,14 @@ function topological(nodes, connections) {
     }
     const queue = nodes.filter((node) => indegree.get(node.id) === 0);
     const result = [];
-    while (queue.length) {
-        const node = queue.shift();
+    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(nodes.find((candidate) => candidate.id === id));
+                queue.push(byId.get(id));
         }
     }
     if (result.length !== nodes.length)

package/dist/runtime/series/index.d.ts

@@ -0,0 +1,41 @@
+import type { CascadeAbortSignal, CascadePreset, CascadeSeries, SeriesInstanceResult } from "@field/cascade/contracts";
+import type { LoadedCascadeGraph } from "../types.js";
+/**
+ * The graph's current values for those keys, as a preset.
+ *
+ * Read through `inspect()` rather than from the nodes directly, so the values
+ * are the same snapshots every other reader gets. A key the graph does not
+ * have is left out rather than defaulted: `applyPreset` is the thing that
+ * decides an unknown key is a misuse, and it should keep deciding that.
+ */
+export declare function seriesBaseline(graph: LoadedCascadeGraph, series: CascadeSeries): CascadePreset;
+export interface RunSeriesOptions {
+    readonly signal?: CascadeAbortSignal;
+    readonly frame?: number;
+    readonly fps?: number;
+    /**
+     * The instance to cook first, by id.
+     *
+     * *"Making changes to the underlying network re-renders the current selected
+     * item first then the entire series."* The order of the results is always the
+     * series' own order whatever this says — only the order of the **work**
+     * changes, because the caller is watching one instance and waiting for a
+     * list would defeat the point.
+     */
+    readonly first?: string;
+    /** Called as each instance finishes, in cook order rather than list order,
+     *  so a gallery can fill in as results arrive instead of after all of them. */
+    readonly onInstance?: (result: SeriesInstanceResult) => void;
+}
+export interface SeriesRunResult {
+    /** In the series' own order, whatever order the work ran in. */
+    readonly instances: readonly SeriesInstanceResult[];
+    /** By record id, which is the address everything downstream uses. */
+    readonly byId: ReadonlyMap<string, SeriesInstanceResult>;
+    readonly status: "completed" | "cancelled" | "failed";
+}
+/** Ids must be unique, or an instance has no address at all — and every
+ *  judgement, override and cache key in the plan hangs off that address. */
+export declare function validateSeries(series: CascadeSeries): void;
+export declare function runSeries(graph: LoadedCascadeGraph, series: CascadeSeries, options?: RunSeriesOptions): Promise<SeriesRunResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/series/index.js

@@ -0,0 +1,167 @@
+/**
+ * Cooking a graph once per parameter set.
+ *
+ * Step 1 of `PLAN series.md`, and headless on purpose: it is the foundation the
+ * gallery and the scheduler stand on, and it is verifiable without a picture.
+ *
+ * **The whole difficulty is that a parameter set is sparse.** `applyPreset`
+ * mutates the runtime, and instance 3 overriding `seed` while instance 4 does
+ * not means instance 4 inherits instance 3's seed unless something puts it
+ * back. That is accidental feedback — in the one mechanism specified as having
+ * none — and it would show up as a series where the pictures are subtly wrong
+ * in an order-dependent way, which is close to the worst failure this system
+ * could have: re-run it and the same instance renders differently, so it reads
+ * as a flaky renderer rather than as a bug.
+ *
+ * So every instance is cooked from the same baseline. The baseline is itself a
+ * `CascadePreset`, holding the graph's current value for **every key any
+ * instance touches** — the union, computed once — which means restoring is the
+ * same validated code path as applying, rather than a second one that can
+ * disagree with it.
+ */
+/** Every `node.input` and `node.prop` any instance in the series overrides. */
+function overriddenKeys(series) {
+    const keys = new Map();
+    for (const instance of series.instances) {
+        for (const [nodeId, values] of Object.entries(instance.parameters.nodes)) {
+            let entry = keys.get(nodeId);
+            if (!entry) {
+                entry = { inputs: new Set(), props: new Set() };
+                keys.set(nodeId, entry);
+            }
+            for (const name of Object.keys(values.inputs ?? {}))
+                entry.inputs.add(name);
+            for (const name of Object.keys(values.props ?? {}))
+                entry.props.add(name);
+        }
+    }
+    return keys;
+}
+/**
+ * The graph's current values for those keys, as a preset.
+ *
+ * Read through `inspect()` rather than from the nodes directly, so the values
+ * are the same snapshots every other reader gets. A key the graph does not
+ * have is left out rather than defaulted: `applyPreset` is the thing that
+ * decides an unknown key is a misuse, and it should keep deciding that.
+ */
+export function seriesBaseline(graph, series) {
+    const wanted = overriddenKeys(series);
+    const inspection = graph.inspect();
+    const nodes = {};
+    for (const node of inspection.nodes) {
+        const entry = wanted.get(node.id);
+        if (!entry)
+            continue;
+        const inputs = {};
+        const props = {};
+        for (const name of entry.inputs) {
+            if (node.inputs[name] !== undefined)
+                inputs[name] = node.inputs[name].value;
+        }
+        for (const name of entry.props) {
+            if (node.props[name] !== undefined)
+                props[name] = node.props[name].value;
+        }
+        if (Object.keys(inputs).length > 0 || Object.keys(props).length > 0) {
+            nodes[node.id] = {
+                ...(Object.keys(inputs).length > 0 ? { inputs } : {}),
+                ...(Object.keys(props).length > 0 ? { props } : {}),
+            };
+        }
+    }
+    return { version: 1, nodes };
+}
+/** Ids must be unique, or an instance has no address at all — and every
+ *  judgement, override and cache key in the plan hangs off that address. */
+export function validateSeries(series) {
+    if (series.version !== 1) {
+        throw new Error("Series version must be 1");
+    }
+    const seen = new Set();
+    for (const instance of series.instances) {
+        if (!instance.id)
+            throw new Error("Every series instance needs an id");
+        if (seen.has(instance.id)) {
+            throw new Error(`Duplicate series instance id ${instance.id}`);
+        }
+        seen.add(instance.id);
+    }
+}
+function collect(graph, collection) {
+    return "graphOutput" in collection
+        ? graph.getGraphOutput(collection.graphOutput)
+        : graph.getOutput(collection.nodeId, collection.output);
+}
+/** The cook order: the selected instance, then the rest in the series' order. */
+function cookOrder(series, first) {
+    const order = series.instances.map((_, index) => index);
+    if (first === undefined)
+        return order;
+    const selected = series.instances.findIndex(instance => instance.id === first);
+    if (selected < 0)
+        return order;
+    return [selected, ...order.filter(index => index !== selected)];
+}
+export async function runSeries(graph, series, options = {}) {
+    validateSeries(series);
+    // Before the first `applyPreset` and not after, or the baseline is already
+    // instance one's.
+    const baseline = seriesBaseline(graph, series);
+    const results = new Array(series.instances.length);
+    let cancelled = false;
+    try {
+        for (const index of cookOrder(series, options.first)) {
+            if (options.signal?.aborted) {
+                cancelled = true;
+                break;
+            }
+            const instance = series.instances[index];
+            // Baseline first, every time. A sparse set does not clear what the
+            // previous instance changed, and inheriting it is accidental feedback.
+            await graph.applyPreset(baseline);
+            await graph.applyPreset(instance.parameters);
+            const run = await graph.run({
+                ...(options.signal ? { signal: options.signal } : {}),
+                ...(options.frame === undefined ? {} : { frame: options.frame }),
+                ...(options.fps === undefined ? {} : { fps: options.fps }),
+            });
+            const result = {
+                id: instance.id,
+                index,
+                status: run.status,
+                // A run that did not complete has no value worth collecting, and
+                // reading the port anyway would hand back the previous instance's
+                // picture under this instance's id.
+                value: run.status === "completed" ? collect(graph, series.collect) : undefined,
+                diagnostics: run.diagnostics,
+                durationMs: run.timings.durationMs,
+            };
+            results[index] = result;
+            options.onInstance?.(result);
+            if (run.status === "cancelled") {
+                cancelled = true;
+                break;
+            }
+        }
+    }
+    finally {
+        // Leave the graph as it was found. A series is a way of looking at a graph,
+        // not an edit to it, and a Studio session that ran one and was left on the
+        // last instance's parameters would be indistinguishable from one the author
+        // had changed by hand.
+        await graph.applyPreset(baseline);
+    }
+    const completed = results.filter((result) => Boolean(result));
+    const status = cancelled
+        ? "cancelled"
+        : completed.some(result => result.status === "failed")
+            ? "failed"
+            : "completed";
+    return {
+        instances: completed,
+        byId: new Map(completed.map(result => [result.id, result])),
+        status,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/runtime/types.d.ts

@@ -1,4 +1,4 @@
-import type { AssetCapability, AssetRef, CascadeAbortSignal, CascadeDocument, CascadePreset, Diagnostic, FileCapability, ImageRef, JsonValue, MediaCapability, NodeDefinition, NodeExecute, ProgressReporter, PythonCapability, SerializableValue, ShellCapability, TextureHandle, WebGLCapability } from "@field/cascade/contracts";
+import type { AssetCapability, AssetRef, CascadeAbortSignal, CascadeDocument, CascadePreset, Diagnostic, FileCapability, ImageRef, JsonValue, MediaCapability, NodeDefinition, NodeExecute, ProgressReporter, PythonCapability, SerializableValue, ShellCapability, TextureHandle, GpuCapability } from "@field/cascade/contracts";
 export type { CascadeDocument, CascadeDocumentAnnotation, CascadeDocumentConnection, CascadeDocumentNode, CascadePreset, } from "@field/cascade/contracts";
 export interface DefinitionNodeRegistration<D extends NodeDefinition = NodeDefinition> {
     readonly kind: "definition-v1";
@@ -31,7 +31,7 @@ export interface RuntimeCapabilities {
     readonly assets?: AssetCapability;
     readonly media?: MediaCapability;
     readonly python?: PythonCapability;
-    readonly webgl?: WebGLCapability;
+    readonly gpu?: GpuCapability;
     readonly shell?: ShellCapability;
     readonly serverBridge?: ServerBridgeCapability;
 }
@@ -246,7 +246,7 @@ export interface LoadedCascadeGraph {
     getOutputs(nodeId: string): ReadonlyMap<string, unknown>;
     dispose(): Promise<void>;
 }
-export interface NodeRuntimeHostOptions extends Omit<RuntimeCapabilities, "webgl"> {
+export interface NodeRuntimeHostOptions extends RuntimeCapabilities {
     readonly modules: RuntimeHost["modules"];
     readonly legacyShell?: LegacyShellBindingFactory & Readonly<{
         kind: "server-direct";