@field/cascade 0.3.0 → 0.3.1

package/dist/contracts/capabilities.d.ts

@@ -1,4 +1,4 @@
-import type { AssetRef, ImageRef, JsonValue, TextureHandle } from "./values.js";
+import type { AssetRef, ImageRef, JsonValue } from "./values.js";
 export interface CascadeAbortSignal {
     readonly aborted: boolean;
     readonly reason?: unknown;
@@ -66,10 +66,73 @@ export interface PythonCapability {
         progress: ProgressReporter;
     }): Promise<JsonValue | AssetRef | ImageRef>;
 }
-export interface WebGLCapability {
-    createTexture(descriptor: JsonValue, options: {
-        signal: CascadeAbortSignal;
-    }): Promise<ResourceLease<TextureHandle>>;
+/**
+ * A GPU a node can compute on, and the state that has to outlive one cook.
+ *
+ * This replaces `WebGLCapability`, which nothing implemented, nothing declared
+ * and no host installed — its one method was WebGL2-shaped, and keeping both
+ * names would have meant two devices in one page. Two devices cannot exchange
+ * a texture: an allocation made on one is not bindable, sampleable or copyable
+ * on the other, and the failure is a validation error at bind time rather than
+ * anything a graph author would recognise. So a shared device is not a
+ * preference, it is the precondition for a chain of GPU nodes at all.
+ *
+ * **Stage 0 deliberately carries three members and no textures.** Ports still
+ * pass `image`, so every picture is byte-identical to before; what this buys is
+ * one device instead of one per node module, an owner for `device.lost`, and
+ * somewhere legitimate to keep a pipeline — which is what lets the
+ * `architecture/ambient-state` rule stay strict. The texture store, the
+ * generation-stamped handles and the readback are Stage 1, and the shape of
+ * this interface is meant to be lived with for a few days first.
+ *
+ * The `GPUDevice` type comes from `@webgpu/types`, added to this package's
+ * `tsconfig.json` as its only `types` entry. Contracts compiles with
+ * `lib: ["ES2022"]` and no DOM on purpose — it is the vocabulary both hosts
+ * share, so pulling in the whole browser would let a browser-only type reach a
+ * portable definition by accident. A hand-written stub was the alternative and
+ * would have been worse than a dependency: it would shadow the genuine
+ * `GPUDevice` at the node's own call site, so every real method call would
+ * stop typechecking.
+ *
+ * The device is raw on purpose. A wrapped pipeline API would be a second thing
+ * to learn, would lag the spec, and would fight the reason to reach for WebGPU
+ * at all, which is that you write WGSL and encode passes. The capability wraps
+ * only what carries lifetime or identity, because those are the parts a host
+ * has to be able to account for.
+ */
+export interface GpuCapability {
+    /**
+     * The one device for this page. Shared by every node declaring `gpu`, which
+     * is the whole point — see the note above on why two would be useless.
+     */
+    readonly device: GPUDevice;
+    /**
+     * Who is actually rendering, recorded so a difference between two runs of
+     * the same graph is attributable rather than a mystery. WebGPU output can
+     * differ across adapters, and today there is no way to answer "which one".
+     */
+    readonly adapterInfo: Readonly<{
+        vendor: string;
+        architecture: string;
+        device: string;
+        description: string;
+    }>;
+    /** What this adapter will actually allow — `maxTextureDimension3D` and the
+     *  rest. Read at runtime rather than assumed; the 3D default is far below
+     *  the 2D one and a hard-coded guess would be wrong on some machines. */
+    readonly limits: Readonly<Record<string, number>>;
+    /**
+     * A resource that outlives one cook — a compiled pipeline, a sampler, a
+     * bind group layout. Keyed per node by the host, so two instances of one
+     * module do not share a cache entry and a module-level `Map` is never the
+     * right answer again.
+     *
+     * `create` runs once per key. `destroy` is called when the entry is dropped:
+     * when the device is lost, or when the graph disposes. This is the member
+     * that makes `architecture/module-state` keepable — it was previously
+     * forbidding the only available way to hold a pipeline.
+     */
+    cache<T>(key: string, create: (device: GPUDevice) => T, destroy?: (value: T) => void): T;
 }
 export interface ShellRunResult {
     readonly stdout: string;
@@ -102,7 +165,7 @@ export interface CapabilityMap {
     readonly assets: AssetCapability;
     readonly media: MediaCapability;
     readonly python: PythonCapability;
-    readonly webgl: WebGLCapability;
+    readonly gpu: GpuCapability;
     readonly shell: ShellCapability;
 }
 export type NodeCapabilityName = keyof CapabilityMap;

package/dist/contracts/definition.d.ts

@@ -1,7 +1,7 @@
 import type { CapabilityMap, CascadeAbortSignal, NodeCapabilityName, ProgressReporter } from "./capabilities.js";
 import type { CascadeType, CoreType, JsonValue, NamespacedType, SerializableValueForType, ValueForType } from "./values.js";
 export type RuntimeEnvironment = "portable" | "browser" | "server";
-export type CapabilityForEnvironment<E extends RuntimeEnvironment> = E extends "portable" ? "assets" | "media" : E extends "browser" ? "assets" | "media" | "webgl" : "files" | "assets" | "media" | "python" | "shell";
+export type CapabilityForEnvironment<E extends RuntimeEnvironment> = E extends "portable" ? "assets" | "media" : E extends "browser" ? "assets" | "media" | "gpu" : "files" | "assets" | "media" | "python" | "shell";
 export type DataTypeForEnvironment<E extends RuntimeEnvironment> = E extends "browser" ? CascadeType : Exclude<CascadeType, "texture">;
 type ControlFor<T extends CascadeType> = T extends "float" ? "number" | "slider" | "range" : T extends "int" ? "int" | "slider" | "range" : T extends "bool" ? "boolean" : T extends "string" ? "text" | "textarea" | "select" : T extends "vec2" | "vec3" | "vec4" | "vec2i" | "vec3i" | "vec4i" ? "vector" : T extends "mat2" | "mat3" | "mat4" ? "matrix" : T extends "color" ? "color" : T extends "image" ? "image" : T extends "asset" ? "asset" | "select" : T extends "texture" ? never : "select";
 /**
@@ -80,6 +80,26 @@ export type PropDefinition<T extends PropDataType> = {
     readonly default: SerializableValueForType<T>;
     readonly label?: string;
     readonly description?: string;
+    /**
+     * An expression the prop starts with, so a node can come out of the box
+     * already moving — `sine-oscillator` and `ripple` baked in `$T` as dynamic
+     * nodes and shipped a static 0 once converted, which is what this restores.
+     * Marcus's decision, 2026-09-08, asked as a taste question about his own
+     * tool: a node like that should self-animate when dropped.
+     *
+     * **It is a default, so it loses to a stored value like any other.** A
+     * document that saved a plain number for this prop keeps that number and
+     * does not silently start animating on load. That is the mirror of the
+     * dropped-`params` fault: whatever the author set has to win, and the test
+     * for this asserts the losing case rather than the winning one.
+     *
+     * Applied only when the document stored nothing at all for the prop. It is a
+     * real expression once applied, not a hidden fallback — visible in the
+     * Inspector, editable, and deletable, which is how a stored expression
+     * already reads and the only version that does not lie about where the
+     * number came from.
+     */
+    readonly expression?: string;
 } & NumericMetadata<T> & AcceptMetadata<T> & SelectMetadata<T>;
 export type AnyPropDefinition = {
     [T in PropDataType]: PropDefinition<T>;

package/dist/contracts/schema.js

@@ -41,10 +41,13 @@ const dataProperties = {
 const data = object(dataProperties, ["kind", "type"]);
 const output = object({ kind: dataProperties.kind, type: dataProperties.type, description }, ["kind", "type"]);
 const { kind: _kind, variadic: _variadic, ...propProperties } = dataProperties;
-const prop = object({ ...propProperties, label: { type: "string" } }, [
-    "type",
-    "default",
-]);
+const prop = object({
+    ...propProperties,
+    label: { type: "string" },
+    // Props only, not inputs: an input's value comes from whatever is wired to
+    // it, so a default expression there would be describing the wrong thing.
+    expression: { type: "string", minLength: 1 },
+}, ["type", "default"]);
 function environmentCapabilities(runsOn, capabilities) {
     return {
         if: { properties: { runsOn: { const: runsOn } } },
@@ -72,7 +75,7 @@ export const nodeDefinitionSchema = {
     }, ["apiVersion", "runsOn"]),
     allOf: [
         environmentCapabilities("portable", ["assets", "media"]),
-        environmentCapabilities("browser", ["assets", "media", "webgl"]),
+        environmentCapabilities("browser", ["assets", "media", "gpu"]),
         environmentCapabilities("server", [
             "files",
             "assets",

package/dist/contracts/validate.js

@@ -14,7 +14,7 @@ const CONTROLS = new Set(["number", "slider", "range", "int", "boolean", "text",
  */
 export const CAPABILITIES_BY_ENVIRONMENT = {
     portable: ["assets", "media"],
-    browser: ["assets", "media", "webgl"],
+    browser: ["assets", "media", "gpu"],
     server: ["files", "assets", "media", "python", "shell"],
 };
 const ALLOWED = CAPABILITIES_BY_ENVIRONMENT;
@@ -22,7 +22,7 @@ const fields = (names) => new Set(names.split(" "));
 const TOP_FIELDS = fields("apiVersion runsOn container capabilities label description icon inputs outputs props");
 const DATA_FIELDS = fields("kind type default description variadic min max step accept control options");
 const OUTPUT_FIELDS = fields("kind type description");
-const PROP_FIELDS = fields("type default label description min max step accept control options");
+const PROP_FIELDS = fields("type default label description min max step accept control options expression");
 function diagnostic(code, message, path) {
     return { phase: "definition", code: `definition/${code}`, message, path };
 }
@@ -194,6 +194,15 @@ export function validateNodeDefinition(value) {
                     !Number.isFinite(raw.step) ||
                     raw.step <= 0))
                 add("invalid-step", "step must be greater than zero", `${path}.step`);
+            if (section === "props" &&
+                "expression" in raw &&
+                (typeof raw.expression !== "string" || raw.expression.length === 0))
+                add("invalid-expression", "expression must be a non-empty string", `${path}.expression`);
+            for (const field of ["min", "max"]) {
+                if (field in raw &&
+                    (typeof raw[field] !== "number" || !Number.isFinite(raw[field])))
+                    add(`invalid-${field}`, `${field} must be a finite number`, `${path}.${field}`);
+            }
             if (typeof raw.min === "number" &&
                 typeof raw.max === "number" &&
                 raw.min > raw.max)

package/dist/gpu.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `cascade/gpu` — WebGPU's flag namespaces as plain values.
+ *
+ * Small, and it was load-bearing. TypeScript's DOM library declares the WebGPU
+ * *interfaces* but not the constant objects, so the only way to reach
+ * `GPUTextureUsage.RENDER_ATTACHMENT` was off `globalThis` — which
+ * `architecture/ambient-state` correctly forbids inside a node module, because
+ * an ambient read makes a node's inputs invisible to the static reader that
+ * lets `cascade check` say anything without cooking.
+ *
+ * So a sketch had to choose between a rule and a working shader, and it chose
+ * a project library file to hide the read in. Both stay honest now: the rule
+ * keeps its teeth and a node imports these instead. That is the whole reason
+ * this file exists, and it is why it had to land with the capability rather
+ * than after it — a rule whose only workaround is removed at the same moment
+ * is a rule; one enforced a release earlier is a nuisance.
+ *
+ * The values are fixed by the WebGPU specification, not by an implementation,
+ * which is what makes writing them down safe rather than a guess. They are
+ * checked against a real browser's own globals in `tests/gpu-usage-flags.test.ts`
+ * — the numbers below were verified against Chrome rather than recalled.
+ */
+/** `GPUBufferUsage`. */
+export declare const BufferUsage: {
+    readonly MAP_READ: 1;
+    readonly MAP_WRITE: 2;
+    readonly COPY_SRC: 4;
+    readonly COPY_DST: 8;
+    readonly INDEX: 16;
+    readonly VERTEX: 32;
+    readonly UNIFORM: 64;
+    readonly STORAGE: 128;
+    readonly INDIRECT: 256;
+    readonly QUERY_RESOLVE: 512;
+};
+/** `GPUTextureUsage`. */
+export declare const TextureUsage: {
+    readonly COPY_SRC: 1;
+    readonly COPY_DST: 2;
+    readonly TEXTURE_BINDING: 4;
+    readonly STORAGE_BINDING: 8;
+    readonly RENDER_ATTACHMENT: 16;
+    /**
+     * Chrome 147 has this and it is newer than the rest — verified present
+     * 2026-09-08 alongside the others, but do not assume every implementation
+     * carries it. Included rather than omitted deliberately: leaving it out
+     * would send a node that wants it back to `globalThis`, which is the exact
+     * ambient read this file exists to remove, so an honest constant with a
+     * caveat beats an omission that forces a rule violation.
+     */
+    readonly TRANSIENT_ATTACHMENT: 32;
+};
+/** `GPUShaderStage`, for a bind group layout entry's `visibility`. */
+export declare const ShaderStage: {
+    readonly VERTEX: 1;
+    readonly FRAGMENT: 2;
+    readonly COMPUTE: 4;
+};
+/** `GPUMapMode`, for `buffer.mapAsync`. */
+export declare const MapMode: {
+    readonly READ: 1;
+    readonly WRITE: 2;
+};
+/** `GPUColorWrite`, for a colour target's `writeMask`. */
+export declare const ColorWrite: {
+    readonly RED: 1;
+    readonly GREEN: 2;
+    readonly BLUE: 4;
+    readonly ALPHA: 8;
+    readonly ALL: 15;
+};

package/dist/gpu.js

@@ -0,0 +1,53 @@
+// server/src/runtime/gpu.ts
+var BufferUsage = {
+  MAP_READ: 1,
+  MAP_WRITE: 2,
+  COPY_SRC: 4,
+  COPY_DST: 8,
+  INDEX: 16,
+  VERTEX: 32,
+  UNIFORM: 64,
+  STORAGE: 128,
+  INDIRECT: 256,
+  QUERY_RESOLVE: 512
+};
+var TextureUsage = {
+  COPY_SRC: 1,
+  COPY_DST: 2,
+  TEXTURE_BINDING: 4,
+  STORAGE_BINDING: 8,
+  RENDER_ATTACHMENT: 16,
+  /**
+   * Chrome 147 has this and it is newer than the rest — verified present
+   * 2026-09-08 alongside the others, but do not assume every implementation
+   * carries it. Included rather than omitted deliberately: leaving it out
+   * would send a node that wants it back to `globalThis`, which is the exact
+   * ambient read this file exists to remove, so an honest constant with a
+   * caveat beats an omission that forces a rule violation.
+   */
+  TRANSIENT_ATTACHMENT: 32
+};
+var ShaderStage = {
+  VERTEX: 1,
+  FRAGMENT: 2,
+  COMPUTE: 4
+};
+var MapMode = {
+  READ: 1,
+  WRITE: 2
+};
+var ColorWrite = {
+  RED: 1,
+  GREEN: 2,
+  BLUE: 4,
+  ALPHA: 8,
+  ALL: 15
+};
+export {
+  BufferUsage,
+  ColorWrite,
+  MapMode,
+  ShaderStage,
+  TextureUsage
+};
+//# sourceMappingURL=gpu.js.map

package/dist/index.html

@@ -4,7 +4,7 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Cascade</title>
-  <script type="module" crossorigin src="/assets/index-HTCN44kj.js"></script>
+  <script type="module" crossorigin src="/assets/index-CMcH8AgP.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/legacy-CAj2_7QE.js">
   <link rel="modulepreload" crossorigin href="/assets/index-client-BoJgsN9M.js">
   <link rel="modulepreload" crossorigin href="/assets/nodeTypeUtils-BBA1JqHx.js">

package/dist/runtime/runtime.d.ts

@@ -16,9 +16,29 @@ import type { CascadeRuntime, CreateRuntimeOptions } from "./types.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 declare const PREFLIGHT_WARNING_CODES: ReadonlySet<string>;
 export declare function createRuntime(options: CreateRuntimeOptions): CascadeRuntime;

package/dist/runtime/runtime.js

@@ -21,14 +21,46 @@ 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",
 ]);
+/**
+ * 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",
+]);
 class MutableAbortSignal {
     report;
     aborted = false;
@@ -148,6 +180,10 @@ class Graph {
     onDispose;
     graphState = "ready";
     byId;
+    dataConnectionsByInput;
+    dataConnectionsByNode;
+    connectedInputs;
+    connectedOutputs;
     listeners = new Set();
     diagnostics = [];
     active;
@@ -173,6 +209,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 +244,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 +289,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 +300,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 +608,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)
@@ -740,7 +796,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 +810,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 +856,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);
@@ -949,7 +1023,21 @@ 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}`);
     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 +1049,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
@@ -1265,6 +1357,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 +1366,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/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 Omit<RuntimeCapabilities, "gpu"> {
     readonly modules: RuntimeHost["modules"];
     readonly legacyShell?: LegacyShellBindingFactory & Readonly<{
         kind: "server-direct";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@field/cascade",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Visual programming for generative art",
   "license": "MIT",
   "author": "FIELD.IO <marcus@field.io>",
@@ -83,6 +83,10 @@
       "types": "./dist/io.d.ts",
       "default": "./dist/io.js"
     },
+    "./gpu": {
+      "types": "./dist/gpu.d.ts",
+      "default": "./dist/gpu.js"
+    },
     "./net": {
       "types": "./dist/net.d.ts",
       "default": "./dist/net.js"

package/dist/assets/geo-DUvVbLnx.js

@@ -1 +0,0 @@
-import{b as e,f as t,s as n,x as r}from"./index-HTCN44kj.js";r(n,{assets:e});export{t as geoLibrary};