@field/cascade 0.2.22 → 0.3.1

package/dist/runtime/params/resolve.js

@@ -0,0 +1,62 @@
+/**
+ * The one place a parameter becomes a value.
+ *
+ * Three bindings, in one order: a keyframe channel, an expression, the stored
+ * value. That order was implemented once, in Studio's `Node.evalParm`, which
+ * meant the deterministic runtime had no answer at all — a definition-v1 prop
+ * carrying `$T` or a drawn curve rendered as a static number offline. Copying
+ * `evalParm` into the runtime would have produced a second answer to the same
+ * question, which is exactly the two-parameter-stores mistake this codebase
+ * has already paid for once. So the order moved here, into the neutral
+ * runtime, and both hosts call it.
+ *
+ * What it deliberately does NOT own: the expression *engine*. Evaluation is
+ * passed in as a callback, because each host has its own scope (Studio's
+ * `ExpressionEngine` reaches into the compatibility graph; the runtime binds
+ * its own node map) and its own error bookkeeping (Studio stores the message
+ * on the prop for the Inspector to show). Keeping evaluation out is also what
+ * keeps this module dependent on nothing but the channel sampler — no cycle
+ * between `animation` and `expressions`, and no clock anywhere: the frame is a
+ * value the caller hands in, which is what keeps a cook deterministic.
+ */
+import { isEmptyChannel, sampleChannel } from "../animation/channel.js";
+/** True when a parameter carries something beyond its stored value, and so has
+ *  to be resolved per frame rather than read once. */
+export function isBoundProp(binding) {
+    if (!binding)
+        return false;
+    return !!binding.expression || !isEmptyChannel(binding.channel);
+}
+/**
+ * Resolve a parameter at a frame.
+ *
+ * A parameter may carry both a channel and an expression, and the channel
+ * wins. The expression is kept, inert, and comes back when the channel is
+ * deleted: silently discarding what an author wrote is the worse of the two
+ * failures. `contracts/animation.ts` states the same rule for the document, so
+ * the file format and the resolver agree by construction.
+ *
+ * An empty channel resolves to nothing rather than to zero, so a parameter
+ * whose last key was deleted falls through to its expression or its value
+ * instead of snapping to the origin.
+ */
+export function resolvePropBinding(binding, context) {
+    if (!isEmptyChannel(binding.channel)) {
+        const sampled = sampleChannel(binding.channel, context.frame);
+        if (sampled !== undefined)
+            return { value: sampled, source: "channel" };
+    }
+    if (binding.expression && context.evaluateExpression) {
+        const result = context.evaluateExpression(binding.expression);
+        // A failed expression falls back to the stored value and reports why. The
+        // alternative — a hole in the middle of a render — is the one outcome
+        // nobody can act on.
+        if (result?.error) {
+            return { value: binding.value, source: "value", error: result.error };
+        }
+        if (result)
+            return { value: result.value, source: "expression" };
+    }
+    return { value: binding.value, source: "value" };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/runtime/runtime.d.ts

@@ -1,3 +1,45 @@
 import type { CascadeRuntime, CreateRuntimeOptions } from "./types.js";
+/**
+ * Preflight codes that describe something other than "this graph cannot run
+ * here", so `run` proceeds and a checker reports them as warnings.
+ *
+ * False positives are worse than blindness: a validator that cries wolf gets
+ * ignored, and then it is no better than the one that saw nothing. So the line
+ * is drawn at what the diagnostic is about.
+ *
+ * `preflight-environment` is about the checker's reach — a node saying
+ * `runsOn: 'browser'` claims nothing about the CLI and is not defective
+ * because somebody validated it from a terminal.
+ *
+ * `stray-params` is about the document — values were lost on the way in, which
+ * is worth saying loudly and is not a reason to refuse to run: a graph with a
+ * leftover `params` array runs perfectly well on its defaults, which is
+ * precisely the problem.
+ *
+ * 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;
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime/runtime.js

@@ -1,6 +1,66 @@
-import { canConnectTypes, validateNodeDefinition, } from "cascade/contracts";
+import { canConnectTypes, validateNodeDefinition, } from "@field/cascade/contracts";
 import { CascadeRuntimeError } from "./error.js";
 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";
+/**
+ * Preflight codes that describe something other than "this graph cannot run
+ * here", so `run` proceeds and a checker reports them as warnings.
+ *
+ * False positives are worse than blindness: a validator that cries wolf gets
+ * ignored, and then it is no better than the one that saw nothing. So the line
+ * is drawn at what the diagnostic is about.
+ *
+ * `preflight-environment` is about the checker's reach — a node saying
+ * `runsOn: 'browser'` claims nothing about the CLI and is not defective
+ * because somebody validated it from a terminal.
+ *
+ * `stray-params` is about the document — values were lost on the way in, which
+ * is worth saying loudly and is not a reason to refuse to run: a graph with a
+ * leftover `params` array runs perfectly well on its defaults, which is
+ * precisely the problem.
+ *
+ * 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;
@@ -120,6 +180,10 @@ class Graph {
     onDispose;
     graphState = "ready";
     byId;
+    dataConnectionsByInput;
+    dataConnectionsByNode;
+    connectedInputs;
+    connectedOutputs;
     listeners = new Set();
     diagnostics = [];
     active;
@@ -129,19 +193,91 @@ class Graph {
     authoredAnnotations;
     graphInputs;
     graphOutputs;
+    /**
+     * The graph's animated parameters, and the clock they resolve against.
+     *
+     * The clock is a value the caller sets per run (`run({ frame })`), never one
+     * this graph reads: same graph plus same frame gives the same output, which
+     * is the only reason a headless render can be trusted.
+     */
+    animator;
+    frame = MIN_FRAME;
+    fps = DEFAULT_FPS;
     constructor(host, nodes, connections, onDispose, annotations = []) {
         this.host = host;
         this.nodes = nodes;
         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)));
+        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) : undefined) ?? null;
+            },
+            // 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);
+        // Resolve once at load, so `inspect()` and a preset applied before any run
+        // both see the parameter at the graph's own first frame rather than the
+        // number that was last saved.
+        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,
@@ -153,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]) }
                         : {}),
@@ -165,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)) }
                         : {}),
@@ -212,7 +346,26 @@ class Graph {
             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`);
-        node.props[propName] = runtimeValue(value, node.definition.props[propName].type, false, `${nodeId}.${propName}`);
+        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();
@@ -247,10 +400,50 @@ class Graph {
         }
         for (const [node, name, value] of inputDrafts)
             node.inputs[name] = value;
-        for (const [node, name, value] of propDrafts)
+        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 = {}) {
+        // The frame belongs to the run, not to the graph's history: a render loop
+        // states which frame it wants and gets exactly that, with no dependence on
+        // what the previous run left behind.
+        if (options.fps !== undefined)
+            this.setFps(options.fps);
+        if (options.frame !== undefined)
+            this.setFrame(options.frame);
+        // Every bound parameter, resolved before any node executes — so a node
+        // still receives a plain number and never reads a clock.
+        else
+            this.animator.resolveAll();
         return this.trackRun(options.target ?? { kind: "all" }, options.signal, options.runId);
     }
     trigger(nodeId, inputName, payload, options = {}) {
@@ -339,7 +532,7 @@ class Graph {
                 }
                 : this.runSelection(target);
             const { reachable, initial } = selection;
-            this.preflight(reachable);
+            this.assertPreflight(reachable);
             if (!signal.aborted)
                 await Promise.all(reachable
                     .filter((node) => !this.isRemote(node))
@@ -415,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)
@@ -504,6 +694,7 @@ class Graph {
             report: (event) => this.emit({ type: "node:progress", runId, nodeId: node.id, ...event }),
         };
         await node.execute({
+            nodeId: node.id,
             inputs,
             outputs,
             props,
@@ -544,33 +735,70 @@ class Graph {
             }
         this.emit({ type: "node:complete", runId, nodeId: node.id });
     }
-    preflight(nodes) {
+    /**
+     * 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.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);
             const locationWorks = node.definition.runsOn === "portable" ||
                 node.definition.runsOn === this.host.environment ||
                 remote;
-            if (!locationWorks)
-                throw runtimeError("runtime/preflight-environment", `${node.moduleId} requires ${node.definition.runsOn}`);
+            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)
-                    throw runtimeError("runtime/preflight-bridge-trigger", `${node.moduleId} cannot send triggers over the server bridge`);
+                    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)
-                    throw runtimeError("runtime/preflight-bridge-texture", `${node.moduleId} cannot send textures over the server bridge`);
+                    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])
-                        throw runtimeError("runtime/missing-capability", `Missing capability ${capability} for ${node.moduleId}`);
+                        push("runtime/missing-capability", node.id, `Missing capability ${capability} for ${node.moduleId} (node ${node.id}) — the ${this.host.environment} host ${this.hostProvides()}`);
         }
+        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" &&
@@ -582,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) {
@@ -627,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);
@@ -776,12 +1022,52 @@ 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}`);
-    for (const [name, saved] of Object.entries(authored.props ?? {})) {
+    const bindings = {};
+    // 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)
-            props[name] = runtimeValue(saved && typeof saved === "object" && "value" in saved
-                ? saved.value
-                : saved, definition.type, false, `${authored.id}.${name}`);
+        if (!definition)
+            continue;
+        // `{ value, expression?, channel? }` — the object form declared in
+        // contracts/animation.ts. A bare value is the same prop with nothing more
+        // to say, which is what every older file on disk contains.
+        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;
+        // 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
+            : undefined;
+        const binding = {
+            value,
+            ...(expression ? { expression } : {}),
+            ...(isEmptyChannel(channel) ? {} : { channel }),
+        };
+        // Only a prop that actually carries something, so `animated` stays a real
+        // question and an unanimated graph pays nothing for this.
+        if (isBoundProp(binding))
+            bindings[name] = binding;
     }
     return {
         id: authored.id,
@@ -791,9 +1077,43 @@ function materialize(authored, registration) {
         definition: registration.definition,
         inputs,
         props,
+        bindings,
+        strayParams: strayParams(authored, registration),
         outputs: new Map(),
     };
 }
+/**
+ * The names a document stored under `params` that this runtime will not read.
+ *
+ * Nothing above consults `params`: the loops that fill `inputs` and `props`
+ * read the definition and then the document's own `inputs` and `props`, so a
+ * value left in `params` is dropped without a word and the parameter keeps its
+ * default. That is not a hypothetical — on `cascade-logo` it put a seed back to
+ * 7 and two rasterizers back to 1024, so three nodes wrote one file and the
+ * drawing changed, with every command still reporting success.
+ *
+ * **Inputs count, not just props.** The first version of this checked props
+ * alone and so was blind to exactly the case the conversions produce most: a
+ * parameter another node drives has to be declared as an `inputs` entry,
+ * because a v1 prop cannot be promoted to a pin. `field-logo`'s `angle` is one,
+ * and a negative control over the pre-migration document named five nodes and
+ * missed that one.
+ *
+ * Only names the definition actually declares are reported. A leftover key
+ * naming nothing is a different fault, and reporting it would make this fire on
+ * documents where no value was lost.
+ */
+function strayParams(authored, registration) {
+    const definition = registration.definition;
+    const declared = 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") {
@@ -1037,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)) {
@@ -1045,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)