@field/cascade 0.5.1 → 0.6.0

package/dist/cli/index.js

@@ -1653,8 +1653,8 @@ function frameRange(start, end, step2 = 1) {
   for (let i = 0; i < count; i++) frames[i] = start + i * step2;
   return frames;
 }
-async function runFrameRange(clock2, options) {
-  const { start, end, step: step2 = 1, onFrame, signal, restoreFrame = true } = options;
+async function runFrameRange(clock2, options2) {
+  const { start, end, step: step2 = 1, onFrame, signal, restoreFrame = true } = options2;
   const frames = frameRange(start, end, step2);
   const previousFrame = clock2.getFrameFraction();
   const visited = [];
@@ -1842,7 +1842,7 @@ var init_params = __esm({
 function isGpuHost(value) {
   return !!value && typeof value.ensure === "function" && typeof value.forNode === "function" && typeof value.dispose === "function";
 }
-function createGpuHost(options) {
+function createGpuHost(options2) {
   let active = null;
   let starting = null;
   let disposal = null;
@@ -1905,7 +1905,7 @@ function createGpuHost(options) {
     });
   }
   async function start() {
-    const result = await options.acquire();
+    const result = await options2.acquire();
     const acquired = {
       device: result.device,
       info: {
@@ -2323,7 +2323,7 @@ var init_builder = __esm({
     init_src();
     init_attributes();
     GeometryBuilder = class {
-      constructor(options = {}) {
+      constructor(options2 = {}) {
         this.positions = [];
         this.vertexPoints = [];
         this.offsets = [0];
@@ -2333,8 +2333,8 @@ var init_builder = __esm({
         this.detail = {};
         this.pointGroups = /* @__PURE__ */ new Map();
         this.primitiveGroups = /* @__PURE__ */ new Map();
-        this.size = options.positionSize ?? 2;
-        this.storage = options.positionStorage ?? "f64";
+        this.size = options2.positionSize ?? 2;
+        this.storage = options2.positionStorage ?? "f64";
       }
       get pointCount() {
         return this.positions.length / this.size;
@@ -2369,7 +2369,7 @@ var init_builder = __esm({
        * closed primitive does not repeat its first point: `closed` is topology, not
        * a duplicated vertex.
        */
-      addPrimitive(points, options = {}) {
+      addPrimitive(points, options2 = {}) {
         const index = this.primitiveCount;
         for (const point of points) {
           if (!Number.isInteger(point) || point < 0 || point >= this.pointCount)
@@ -2380,17 +2380,17 @@ var init_builder = __esm({
           this.vertexPoints.push(point);
         }
         this.offsets.push(this.vertexPoints.length);
-        this.kinds.push(PRIMITIVE_KINDS.indexOf(options.kind ?? "poly"));
-        this.closed.push(options.closed ? 1 : 0);
+        this.kinds.push(PRIMITIVE_KINDS.indexOf(options2.kind ?? "poly"));
+        this.closed.push(options2.closed ? 1 : 0);
         return index;
       }
       /** Append points and one primitive over them, the common generator case. */
-      addPolygon(flat, options = {}) {
+      addPolygon(flat, options2 = {}) {
         const first = this.addPoints(flat);
         const points = [];
         for (let index = first; index < this.pointCount; index += 1)
           points.push(index);
-        return this.addPrimitive(points, options);
+        return this.addPrimitive(points, options2);
       }
       setAttribute(level, name, attribute) {
         if (level === "point" && name === POSITION_ATTRIBUTE)
@@ -2711,20 +2711,20 @@ var init_transform = __esm({
 });
 
 // packages/runtime/src/geometry/copy.ts
-function copyToPoints(source, target, options = {}) {
+function copyToPoints(source, target, options2 = {}) {
   const width = positionSize(source) === 3 ? 3 : 2;
-  const selection = options.targetGroup === void 0 || options.targetGroup === "" ? void 0 : groupMask(target, "point", options.targetGroup) ?? geometryError(
+  const selection = options2.targetGroup === void 0 || options2.targetGroup === "" ? void 0 : groupMask(target, "point", options2.targetGroup) ?? geometryError(
     "missing-group",
-    `point group ${options.targetGroup} is not present on the target`
+    `point group ${options2.targetGroup} is not present on the target`
   );
   const indices = selection === void 0 ? range(target.pointCount) : groupIndices(selection);
   if (indices.length === 0 || source.pointCount === 0)
     return emptyGeometry(width);
-  const orient = options.useTargetOrientations ?? true;
+  const orient = options2.useTargetOrientations ?? true;
   const pscale = orient ? numericAttribute(target.point.pscale, "point.pscale", [1]) : void 0;
   const normal = orient ? numericAttribute(target.point.N, "point.N", [2, 3]) : void 0;
-  const copyNumber = options.copyNumberAttribute ?? "copynum";
-  const transfer = options.transferTargetAttributes ?? true ? Object.keys(target.point).filter(
+  const copyNumber = options2.copyNumberAttribute ?? "copynum";
+  const transfer = options2.transferTargetAttributes ?? true ? Object.keys(target.point).filter(
     (name) => name !== POSITION_ATTRIBUTE && !Object.prototype.hasOwnProperty.call(source.point, name)
   ) : [];
   const copies = [];
@@ -2794,9 +2794,9 @@ function finitePair(value, code) {
   if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]))
     geometryError(code, "both components must be finite");
 }
-function rectangleGeometry(options = {}) {
-  const [width, height] = options.size ?? [1, 1];
-  const [cx, cy] = options.center ?? [0, 0];
+function rectangleGeometry(options2 = {}) {
+  const [width, height] = options2.size ?? [1, 1];
+  const [cx, cy] = options2.center ?? [0, 0];
   finitePair([width, height], "rectangle-size");
   finitePair([cx, cy], "rectangle-center");
   if (width < 0 || height < 0)
@@ -2809,16 +2809,16 @@ function rectangleGeometry(options = {}) {
   builder.addPolygon([x0, y0, x1, y0, x1, y1, x0, y1], { closed: true });
   return builder.build();
 }
-function circleGeometry(options = {}) {
-  const [cx, cy] = options.center ?? [0, 0];
-  const [rx, ry] = options.radius ?? [1, 1];
+function circleGeometry(options2 = {}) {
+  const [cx, cy] = options2.center ?? [0, 0];
+  const [rx, ry] = options2.radius ?? [1, 1];
   finitePair([cx, cy], "circle-center");
   finitePair([rx, ry], "circle-radius");
   if (rx < 0 || ry < 0)
     geometryError("circle-radius", "circle radius must not be negative");
   const builder = new GeometryBuilder();
-  if ((options.type ?? "bezier") === "poly") {
-    const divisions = options.divisions ?? 32;
+  if ((options2.type ?? "bezier") === "poly") {
+    const divisions = options2.divisions ?? 32;
     if (!Number.isSafeInteger(divisions) || divisions < 3)
       geometryError(
         "circle-divisions",
@@ -2956,10 +2956,10 @@ var init_resample = __esm({
 });
 
 // packages/runtime/src/geometry/svg.ts
-function geometryToSvg(geometry, options = {}) {
-  validateOptions(options);
-  const margin = options.margin ?? 0;
-  const explicit = options.bounds;
+function geometryToSvg(geometry, options2 = {}) {
+  validateOptions(options2);
+  const margin = options2.margin ?? 0;
+  const explicit = options2.bounds;
   const bounds = explicit ? void 0 : geometryBounds(geometry);
   const minX = explicit ? explicit[0] - margin : bounds === void 0 ? 0 : bounds.min[0] - margin;
   const minY = explicit ? explicit[1] - margin : bounds === void 0 ? 0 : bounds.min[1] - margin;
@@ -2967,14 +2967,14 @@ function geometryToSvg(geometry, options = {}) {
   const maxY = explicit ? explicit[3] + margin : bounds === void 0 ? 1 : bounds.max[1] + margin;
   const spanX = Math.max(maxX - minX, Number.EPSILON);
   const spanY = Math.max(maxY - minY, Number.EPSILON);
-  const width = options.width && options.width > 0 ? options.width : spanX;
-  const height = options.height && options.height > 0 ? options.height : spanY;
-  const precision = options.precision ?? 3;
+  const width = options2.width && options2.width > 0 ? options2.width : spanX;
+  const height = options2.height && options2.height > 0 ? options2.height : spanY;
+  const precision = options2.precision ?? 3;
   const number = (value) => format(value, precision);
-  const stroke = options.stroke ?? BLACK;
-  const strokeWidth = options.strokeWidth ?? 1;
-  const fill = options.fill ?? BLACK;
-  const filled = (options.fillMode ?? "none") === "solid";
+  const stroke = options2.stroke ?? BLACK;
+  const strokeWidth = options2.strokeWidth ?? 1;
+  const fill = options2.fill ?? BLACK;
+  const filled = (options2.fillMode ?? "none") === "solid";
   const colour = geometry.primitive.Cd;
   const strokeWidths = numericAttribute(geometry.primitive.width, "primitive.width", [1]);
   const opacities = numericAttribute(geometry.primitive.opacity, "primitive.opacity", [1]);
@@ -3037,7 +3037,7 @@ function geometryToSvg(geometry, options = {}) {
   const position = positionAttribute(geometry);
   for (let point = 0; point < geometry.pointCount; point += 1) {
     if (loose[point] !== 1) continue;
-    const radius = pointScale === void 0 ? options.pointRadius ?? 0.5 : readComponent(pointScale, point);
+    const radius = pointScale === void 0 ? options2.pointRadius ?? 0.5 : readComponent(pointScale, point);
     const paint = paintOf(pointColour, point, "point") ?? stroke;
     const transparent = Color.alpha(paint) < 1;
     body.push(
@@ -3051,13 +3051,13 @@ function geometryToSvg(geometry, options = {}) {
   }
   const root = [
     `<svg xmlns="http://www.w3.org/2000/svg" width="${number(width)}" height="${number(height)}" viewBox="${number(minX)} ${number(-maxY)} ${number(spanX)} ${number(spanY)}">`,
-    ...options.background ? [indent(
-      `<rect x="${number(minX)}" y="${number(-maxY)}" width="${number(spanX)}" height="${number(spanY)}" fill="${Color.toHex(options.background)}" />`,
+    ...options2.background ? [indent(
+      `<rect x="${number(minX)}" y="${number(-maxY)}" width="${number(spanX)}" height="${number(spanY)}" fill="${Color.toHex(options2.background)}" />`,
       1
     )] : [],
     indent("<!-- Geometry is +Y up; SVG is +Y down. This is the one flip. -->", 1),
     indent(
-      `<g transform="scale(1,-1)" fill="${filled ? Color.toHex(fill) : "none"}"${filled && Color.alpha(fill) < 1 ? ` fill-opacity="${number(Color.alpha(fill))}"` : ""} stroke="${Color.toHex(stroke)}"${Color.alpha(stroke) < 1 ? ` stroke-opacity="${number(Color.alpha(stroke))}"` : ""} stroke-width="${number(strokeWidth)}"${options.opacity !== void 0 && options.opacity !== 1 ? ` opacity="${number(options.opacity)}"` : ""}>`,
+      `<g transform="scale(1,-1)" fill="${filled ? Color.toHex(fill) : "none"}"${filled && Color.alpha(fill) < 1 ? ` fill-opacity="${number(Color.alpha(fill))}"` : ""} stroke="${Color.toHex(stroke)}"${Color.alpha(stroke) < 1 ? ` stroke-opacity="${number(Color.alpha(stroke))}"` : ""} stroke-width="${number(strokeWidth)}"${options2.opacity !== void 0 && options2.opacity !== 1 ? ` opacity="${number(options2.opacity)}"` : ""}>`,
       1
     ),
     ...body,
@@ -3110,25 +3110,25 @@ function format(value, precision) {
   const rounded = Number.parseFloat(value.toFixed(precision));
   return Object.is(rounded, -0) ? "0" : String(rounded);
 }
-function validateOptions(options) {
+function validateOptions(options2) {
   for (const [name, value] of [
-    ["width", options.width],
-    ["height", options.height],
-    ["margin", options.margin],
-    ["strokeWidth", options.strokeWidth],
-    ["opacity", options.opacity],
-    ["pointRadius", options.pointRadius]
+    ["width", options2.width],
+    ["height", options2.height],
+    ["margin", options2.margin],
+    ["strokeWidth", options2.strokeWidth],
+    ["opacity", options2.opacity],
+    ["pointRadius", options2.pointRadius]
   ]) {
     if (value !== void 0 && !Number.isFinite(value))
       geometryError("svg-option", `${name} must be finite`);
   }
-  if ((options.width ?? 0) < 0 || (options.height ?? 0) < 0)
+  if ((options2.width ?? 0) < 0 || (options2.height ?? 0) < 0)
     geometryError("svg-option", "width and height must not be negative");
-  if ((options.strokeWidth ?? 0) < 0 || (options.pointRadius ?? 0) < 0)
+  if ((options2.strokeWidth ?? 0) < 0 || (options2.pointRadius ?? 0) < 0)
     geometryError("svg-option", "strokeWidth and pointRadius must not be negative");
-  if (options.opacity !== void 0 && (options.opacity < 0 || options.opacity > 1))
+  if (options2.opacity !== void 0 && (options2.opacity < 0 || options2.opacity > 1))
     geometryError("svg-option", "opacity must be between 0 and 1");
-  const precision = options.precision ?? 3;
+  const precision = options2.precision ?? 3;
   if (!Number.isSafeInteger(precision) || precision < 0 || precision > 15)
     geometryError("svg-precision", "precision must be an integer from 0 to 15");
 }
@@ -3842,7 +3842,7 @@ var init_core = __esm({
       previousRegistration
     ]);
     registrationsById = new Map(
-      coreNodeRegistrations.map((registration) => [registration.moduleId, registration])
+      coreNodeRegistrations.map((registration2) => [registration2.moduleId, registration2])
     );
   }
 });
@@ -4223,24 +4223,24 @@ function multiply(matrix, x, y, z) {
     (row) => matrix[row] * x + matrix[4 + row] * y + matrix[8 + row] * z + matrix[12 + row]
   );
 }
-function renderScene(geometry, options) {
-  const [width, height] = options.size;
-  const canvas = options.surface(
+function renderScene(geometry, options2) {
+  const [width, height] = options2.size;
+  const canvas = options2.surface(
     Math.max(1, Math.round(width)),
     Math.max(1, Math.round(height))
   );
   const context = canvas.getContext("2d");
   if (!context) throw new Error("no 2D context on this surface");
-  if (options.background && options.background[3] > 0) {
-    context.fillStyle = css(options.background);
+  if (options2.background && options2.background[3] > 0) {
+    context.fillStyle = css(options2.background);
     context.fillRect(0, 0, canvas.width, canvas.height);
   }
-  for (const one of geometry) drawGeometry(context, canvas, one, options);
+  for (const one of geometry) drawGeometry(context, canvas, one, options2);
   return canvas;
 }
-function drawGeometry(context, canvas, geometry, options) {
-  const view = viewMatrix(options.camera);
-  const projection = projectionMatrix(options.camera);
+function drawGeometry(context, canvas, geometry, options2) {
+  const view = viewMatrix(options2.camera);
+  const projection = projectionMatrix(options2.camera);
   const position = geometry.point[POSITION_ATTRIBUTE];
   if (!position || position.storage === "string") return;
   const size = position.size;
@@ -4265,15 +4265,15 @@ function drawGeometry(context, canvas, geometry, options) {
   const widths = numericAttribute(geometry.primitive.width, "primitive.width", [1]);
   context.lineCap = "round";
   context.lineJoin = "round";
-  context.globalAlpha = options.opacity;
+  context.globalAlpha = options2.opacity;
   const { vertexPoints, offsets, closed } = geometry.topology;
   const drawn = /* @__PURE__ */ new Set();
   for (let primitive = 0; primitive < geometry.primitiveCount; primitive += 1) {
     const from = offsets[primitive];
     const to = offsets[primitive + 1];
     if (to - from < 2) continue;
-    context.strokeStyle = colours ? css(readElement(colours, primitive)) : css(options.stroke);
-    context.lineWidth = widths ? readElement(widths, primitive)[0] : options.strokeWidth;
+    context.strokeStyle = colours ? css(readElement(colours, primitive)) : css(options2.stroke);
+    context.lineWidth = widths ? readElement(widths, primitive)[0] : options2.strokeWidth;
     context.beginPath();
     let open = false;
     for (let vertex = from; vertex < to; vertex += 1) {
@@ -4296,14 +4296,14 @@ function drawGeometry(context, canvas, geometry, options) {
     }
     context.stroke();
   }
-  if (options.drawPoints && options.pointRadius > 0) {
-    context.fillStyle = css(options.stroke);
+  if (options2.drawPoints && options2.pointRadius > 0) {
+    context.fillStyle = css(options2.stroke);
     for (let index = 0; index < projected.length; index += 1) {
       if (drawn.has(index)) continue;
       const at = projected[index];
       if (at.w <= 0) continue;
       context.beginPath();
-      context.arc(at.x, at.y, options.pointRadius, 0, Math.PI * 2);
+      context.arc(at.x, at.y, options2.pointRadius, 0, Math.PI * 2);
       context.fill();
     }
   }
@@ -4485,17 +4485,300 @@ var init_geo = __esm({
       svgExportRegistration
     ]);
     registrationsById2 = new Map(
-      geoNodeRegistrations.map((registration) => [
-        registration.moduleId,
-        registration
+      geoNodeRegistrations.map((registration2) => [
+        registration2.moduleId,
+        registration2
       ])
     );
   }
 });
 
+// packages/runtime/src/builtins/math/definitions.ts
+function asComponents(value, label2) {
+  if (typeof value === "number") return [value];
+  if (Array.isArray(value) && value.every((part) => typeof part === "number"))
+    return value;
+  if (value === void 0 || value === null) return [0];
+  throw new Error(
+    `${label2} needs a number or a vector of numbers, and got ${describe(value)}`
+  );
+}
+function describe(value) {
+  if (Array.isArray(value)) return `an array of ${value.length}`;
+  return `a ${typeof value}`;
+}
+function combine(left, right, operate) {
+  const a = asComponents(left, "the first input");
+  const b = asComponents(right, "the second input");
+  if (a.length !== b.length && a.length !== 1 && b.length !== 1)
+    throw new Error(
+      `cannot combine a vector of ${a.length} with a vector of ${b.length}`
+    );
+  const width = Math.max(a.length, b.length);
+  const out = [];
+  for (let index = 0; index < width; index += 1)
+    out.push(operate(a[a.length === 1 ? 0 : index], b[b.length === 1 ? 0 : index]));
+  return width === 1 ? out[0] : out;
+}
+function map(value, operate) {
+  const components = asComponents(value, "the input");
+  const out = components.map(operate);
+  return out.length === 1 ? out[0] : out;
+}
+function divide(a, b) {
+  return b === 0 ? 0 : a / b;
+}
+function options(table) {
+  return Object.keys(table).map((value) => ({ value, label: label(value) }));
+}
+function label(value) {
+  return value.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function executeBinary(context) {
+  const operate = BINARY[context.props.operation];
+  if (!operate)
+    throw new Error(
+      `cascade.math.Binary has no operation "${context.props.operation}"`
+    );
+  context.outputs.value.set(combine(context.inputs.a, context.inputs.b, operate));
+}
+function executeUnary(context) {
+  const operate = UNARY[context.props.operation];
+  if (!operate)
+    throw new Error(
+      `cascade.math.Unary has no operation "${context.props.operation}"`
+    );
+  context.outputs.value.set(map(context.inputs.value, operate));
+}
+function executeClamp(context) {
+  const lower = combine(context.inputs.value, context.inputs.min, Math.max);
+  context.outputs.value.set(combine(lower, context.inputs.max, Math.min));
+}
+function executeMix(context) {
+  const bias = context.inputs.bias ?? 0.5;
+  const delta = combine(context.inputs.b, context.inputs.a, (b, a) => b - a);
+  context.outputs.value.set(
+    combine(context.inputs.a, delta, (a, d) => a + d * bias)
+  );
+}
+function executeCompare(context) {
+  const operation = context.props.operation;
+  const test = COMPARE[operation];
+  if (!test)
+    throw new Error(`cascade.math.Compare has no test "${context.props.operation}"`);
+  const a = context.inputs.a ?? 0;
+  const b = context.inputs.b ?? 0;
+  const tolerance = context.props.tolerance;
+  if (tolerance > 0 && (operation === "equal" || operation === "not-equal")) {
+    const near = Math.abs(a - b) <= tolerance;
+    context.outputs.result.set(operation === "equal" ? near : !near);
+    return;
+  }
+  context.outputs.result.set(test(a, b));
+}
+function registration(name, definition, execute2) {
+  return {
+    kind: "definition-v1",
+    moduleId: `cascade.math.${name}`,
+    definition,
+    loadExecute: async () => execute2
+  };
+}
+var BINARY, DEG2, UNARY, COMPARE, binaryDefinition, unaryDefinition, clampDefinition, mixDefinition, compareDefinition, binaryRegistration, unaryRegistration, clampRegistration, mixRegistration, compareRegistration, mathNodeRegistrations, mathNodeDefinitions;
+var init_definitions2 = __esm({
+  "packages/runtime/src/builtins/math/definitions.ts"() {
+    "use strict";
+    BINARY = {
+      add: (a, b) => a + b,
+      subtract: (a, b) => a - b,
+      multiply: (a, b) => a * b,
+      divide,
+      power: (a, b) => a ** b,
+      modulo: (a, b) => b === 0 ? 0 : a % b,
+      min: (a, b) => Math.min(a, b),
+      max: (a, b) => Math.max(a, b),
+      atan2: (a, b) => Math.atan2(a, b)
+    };
+    DEG2 = Math.PI / 180;
+    UNARY = {
+      abs: Math.abs,
+      negate: (a) => -a,
+      floor: Math.floor,
+      ceil: Math.ceil,
+      round: Math.round,
+      sqrt: (a) => a < 0 ? 0 : Math.sqrt(a),
+      sign: Math.sign,
+      // Trigonometry in RADIANS, matching the expression engine, where bare `sin`
+      // is radians too. `radians` and `degrees` are here for the conversion, and
+      // the divergence from `Transform`'s degrees is recorded in AGENTS.md.
+      sin: Math.sin,
+      cos: Math.cos,
+      tan: Math.tan,
+      asin: (a) => Math.asin(Math.max(-1, Math.min(1, a))),
+      acos: (a) => Math.acos(Math.max(-1, Math.min(1, a))),
+      exp: Math.exp,
+      log: (a) => a <= 0 ? 0 : Math.log(a),
+      radians: (a) => a * DEG2,
+      degrees: (a) => a / DEG2,
+      /** The fractional part, always positive — `fract(-0.25)` is `0.75`, which is
+       *  what a repeating pattern wants and what GLSL's `fract` does. */
+      fract: (a) => a - Math.floor(a)
+    };
+    COMPARE = {
+      greater: (a, b) => a > b,
+      "greater-or-equal": (a, b) => a >= b,
+      less: (a, b) => a < b,
+      "less-or-equal": (a, b) => a <= b,
+      equal: (a, b) => a === b,
+      "not-equal": (a, b) => a !== b
+    };
+    binaryDefinition = {
+      apiVersion: 1,
+      label: "Binary Math",
+      description: "Two values, one operation. Component-wise, and a scalar broadcasts against a vector.",
+      icon: "Plus",
+      runsOn: "portable",
+      inputs: {
+        a: { kind: "data", type: "any", default: 0, description: "First value." },
+        b: { kind: "data", type: "any", default: 0, description: "Second value." }
+      },
+      outputs: { value: { kind: "data", type: "any" } },
+      props: {
+        operation: {
+          type: "string",
+          default: "add",
+          control: "select",
+          options: options(BINARY),
+          label: "Operation"
+        }
+      }
+    };
+    unaryDefinition = {
+      apiVersion: 1,
+      label: "Unary Math",
+      description: "One value, one operation. Trigonometry is in radians.",
+      icon: "FunctionSquare",
+      runsOn: "portable",
+      inputs: {
+        value: { kind: "data", type: "any", default: 0 }
+      },
+      outputs: { value: { kind: "data", type: "any" } },
+      props: {
+        operation: {
+          type: "string",
+          default: "abs",
+          control: "select",
+          options: options(UNARY),
+          label: "Operation"
+        }
+      }
+    };
+    clampDefinition = {
+      apiVersion: 1,
+      label: "Clamp",
+      description: "Hold a value between two bounds.",
+      icon: "Brackets",
+      runsOn: "portable",
+      inputs: {
+        value: { kind: "data", type: "any", default: 0 },
+        min: { kind: "data", type: "any", default: 0 },
+        max: { kind: "data", type: "any", default: 1 }
+      },
+      outputs: { value: { kind: "data", type: "any" } },
+      props: {}
+    };
+    mixDefinition = {
+      apiVersion: 1,
+      label: "Mix",
+      description: "Blend between two values. Houdini's lerp.",
+      icon: "Blend",
+      runsOn: "portable",
+      inputs: {
+        a: { kind: "data", type: "any", default: 0, description: "The value at 0." },
+        b: { kind: "data", type: "any", default: 1, description: "The value at 1." },
+        bias: {
+          kind: "data",
+          type: "float",
+          default: 0.5,
+          min: 0,
+          max: 1,
+          step: 0.01,
+          description: "Not clamped: past 0..1 this extrapolates, which is useful."
+        }
+      },
+      outputs: { value: { kind: "data", type: "any" } },
+      props: {}
+    };
+    compareDefinition = {
+      apiVersion: 1,
+      label: "Compare",
+      description: "Test two values. Outputs a bool, for a Switch.",
+      icon: "Equal",
+      runsOn: "portable",
+      inputs: {
+        a: { kind: "data", type: "float", default: 0 },
+        b: { kind: "data", type: "float", default: 0 }
+      },
+      outputs: { result: { kind: "data", type: "bool" } },
+      props: {
+        operation: {
+          type: "string",
+          default: "greater",
+          control: "select",
+          options: options(COMPARE),
+          label: "Test"
+        },
+        /**
+         * Scalars only, unlike the rest of this namespace.
+         *
+         * "Is this vector greater than that one" has no single right answer — all
+         * components, any component, or the length — and a node that picked one
+         * silently would be wrong for the other two readings. A comparison feeding
+         * a `Switch` wants one boolean, so the input is a `float` and the question
+         * does not arise.
+         */
+        tolerance: {
+          type: "float",
+          default: 0,
+          min: 0,
+          label: "Tolerance",
+          description: "Slack for Equal and Not Equal. Floating point rarely lands on exactly equal."
+        }
+      }
+    };
+    binaryRegistration = registration("Binary", binaryDefinition, executeBinary);
+    unaryRegistration = registration("Unary", unaryDefinition, executeUnary);
+    clampRegistration = registration("Clamp", clampDefinition, executeClamp);
+    mixRegistration = registration("Mix", mixDefinition, executeMix);
+    compareRegistration = registration("Compare", compareDefinition, executeCompare);
+    mathNodeRegistrations = Object.freeze([
+      binaryRegistration,
+      unaryRegistration,
+      clampRegistration,
+      mixRegistration,
+      compareRegistration
+    ]);
+    mathNodeDefinitions = Object.freeze([
+      ["cascade.math.Binary", binaryDefinition],
+      ["cascade.math.Unary", unaryDefinition],
+      ["cascade.math.Clamp", clampDefinition],
+      ["cascade.math.Mix", mixDefinition],
+      ["cascade.math.Compare", compareDefinition]
+    ]);
+  }
+});
+
+// packages/runtime/src/builtins/math/index.ts
+var init_math2 = __esm({
+  "packages/runtime/src/builtins/math/index.ts"() {
+    "use strict";
+    init_definitions2();
+  }
+});
+
 // packages/runtime/src/pop/state.ts
-function step(state, forces, options) {
-  const { timestep, maxSpeed = 0, wrap } = options;
+function step(state, forces, options2) {
+  const { timestep, maxSpeed = 0, wrap } = options2;
   const { count, size } = state;
   if (count === 0) return state;
   const acceleration = new Float32Array(count * size);
@@ -4856,8 +5139,8 @@ function drag(airresist) {
     }
   };
 }
-function noiseField(options) {
-  const { seed, frequency, amplitude, evolve = 0 } = options;
+function noiseField(options2) {
+  const { seed, frequency, amplitude, evolve = 0 } = options2;
   return {
     label: "noiseField",
     accelerate(state, size) {
@@ -4873,8 +5156,8 @@ function noiseField(options) {
     }
   };
 }
-function separation(options) {
-  const { radius, strength } = options;
+function separation(options2) {
+  const { radius, strength } = options2;
   return {
     label: "separation",
     accelerate(state, size) {
@@ -4945,8 +5228,8 @@ function hash(seed, x, y, z) {
   const n = Math.sin(seed * 12.9898 + x * 78.233 + y * 37.719 + z * 19.371) * 43758.5453;
   return n - Math.floor(n);
 }
-function attract(options) {
-  const { targets, targetSize, targetCount, amplitude, radius } = options;
+function attract(options2) {
+  const { targets, targetSize, targetCount, amplitude, radius } = options2;
   const cell = radius > 0 ? radius : 0;
   const buckets = /* @__PURE__ */ new Map();
   if (cell > 0) {
@@ -5008,7 +5291,7 @@ function attract(options) {
 function bucketKey(x, y, cell) {
   return `${Math.floor(x / cell)}:${Math.floor(y / cell)}`;
 }
-function flowField(options) {
+function flowField(options2) {
   const {
     positions,
     positionSize: positionSize2,
@@ -5020,7 +5303,7 @@ function flowField(options) {
     radius,
     level = 0,
     hold = 0
-  } = options;
+  } = options2;
   const cell = radius > 0 ? radius : 1;
   const buckets = /* @__PURE__ */ new Map();
   for (let sample = 0; sample < count; sample += 1) {
@@ -5135,8 +5418,8 @@ function trailFrame(geometry) {
     size: position.size
   };
 }
-function buildTrails(history, current, options = {}) {
-  const { result = "polylines", length = 12, increment = 1, velocityscale = 1 } = options;
+function buildTrails(history, current, options2 = {}) {
+  const { result = "polylines", length = 12, increment = 1, velocityscale = 1 } = options2;
   if (result === "preserve") return current;
   const frames = sampled(history, length, increment);
   const size = frames[0]?.size ?? 2;
@@ -5552,7 +5835,7 @@ function executeSimulate(context) {
   );
 }
 var sourceDefinition, solverDefinition, noiseForceDefinition, separateDefinition, fieldForceDefinition, trailDefinition, simulateDefinition, simulateRegistration, sourceRegistration, solverRegistration, noiseForceRegistration, separateRegistration, fieldForceRegistration, trailRegistration, popNodeRegistrations, popNodeDefinitions;
-var init_definitions2 = __esm({
+var init_definitions3 = __esm({
   "packages/runtime/src/builtins/pop/definitions.ts"() {
     "use strict";
     init_src();
@@ -5945,7 +6228,7 @@ var init_definitions2 = __esm({
 var init_pop2 = __esm({
   "packages/runtime/src/builtins/pop/index.ts"() {
     "use strict";
-    init_definitions2();
+    init_definitions3();
   }
 });
 
@@ -5991,12 +6274,12 @@ function executeScene(context) {
       return;
     }
     throw new Error(
-      `cascade.scene.Scene input ${index} is not geometry, a camera, a light or a scene (received ${describe(value)}). A scene can only hold those.`
+      `cascade.scene.Scene input ${index} is not geometry, a camera, a light or a scene (received ${describe2(value)}). A scene can only hold those.`
     );
   });
   context.outputs.scene.set({ geometry, camera, lights });
 }
-function describe(value) {
+function describe2(value) {
   if (Array.isArray(value)) return `an array of ${value.length}`;
   if (typeof value === "object" && value !== null) {
     const kind = value.kind;
@@ -6016,7 +6299,7 @@ function executeLight(context) {
   });
 }
 var SCENE_NAMESPACE, sceneDefinition, lightDefinition, sceneRegistration, lightRegistration, sceneNodeRegistrations, sceneNodeDefinitions;
-var init_definitions3 = __esm({
+var init_definitions4 = __esm({
   "packages/runtime/src/builtins/scene/definitions.ts"() {
     "use strict";
     init_src();
@@ -6124,7 +6407,7 @@ var init_definitions3 = __esm({
 var init_scene3 = __esm({
   "packages/runtime/src/builtins/scene/index.ts"() {
     "use strict";
-    init_definitions3();
+    init_definitions4();
   }
 });
 
@@ -6138,36 +6421,38 @@ var init_builtins = __esm({
     "use strict";
     init_core();
     init_geo();
+    init_math2();
     init_pop2();
     init_scene3();
     builtinNodeRegistrations = Object.freeze([
       ...coreNodeRegistrations,
       ...geoNodeRegistrations,
+      ...mathNodeRegistrations,
       ...popNodeRegistrations,
       ...sceneNodeRegistrations
     ]);
     registrationsById3 = new Map(
-      builtinNodeRegistrations.map((registration) => [
-        registration.moduleId,
-        registration
+      builtinNodeRegistrations.map((registration2) => [
+        registration2.moduleId,
+        registration2
       ])
     );
   }
 });
 
 // packages/runtime/src/runtime.ts
-function createRuntime(options) {
-  return new Runtime(options.host, [...builtinNodeRegistrations, ...options.nodes ?? []]);
+function createRuntime(options2) {
+  return new Runtime(options2.host, [...builtinNodeRegistrations, ...options2.nodes ?? []]);
 }
 function bindShellToRun(shell, runSignal) {
   if (!shell) return void 0;
-  const options = (value) => ({
+  const options2 = (value) => ({
     ...value,
     signal: combineAbortSignals(runSignal, value?.signal)
   });
   return Object.freeze({
-    run: (command, args, value) => shell.run(command, args, options(value)),
-    runJson: (command, args, value) => shell.runJson(command, args, options(value))
+    run: (command, args, value) => shell.run(command, args, options2(value)),
+    runJson: (command, args, value) => shell.runJson(command, args, options2(value))
   });
 }
 function combineAbortSignals(first, second) {
@@ -6180,7 +6465,7 @@ function combineAbortSignals(first, second) {
     get reason() {
       return first.aborted ? first.reason : second.reason;
     },
-    addEventListener(_type, listener, options) {
+    addEventListener(_type, listener, options2) {
       if (first.aborted || second.aborted) {
         listener();
         return;
@@ -6192,8 +6477,8 @@ function combineAbortSignals(first, second) {
         listener();
       };
       wrappers.set(listener, wrapped);
-      first.addEventListener("abort", wrapped, options);
-      second.addEventListener("abort", wrapped, options);
+      first.addEventListener("abort", wrapped, options2);
+      second.addEventListener("abort", wrapped, options2);
     },
     removeEventListener(_type, listener) {
       const wrapped = wrappers.get(listener);
@@ -6204,11 +6489,11 @@ function combineAbortSignals(first, second) {
     }
   };
 }
-function materialize(authored, registration) {
+function materialize(authored, registration2) {
   const inputs = {};
   const props = {};
   for (const [name, definition] of Object.entries(
-    registration.definition.inputs ?? {}
+    registration2.definition.inputs ?? {}
   ))
     if (definition.kind === "data" && "default" in definition)
       inputs[name] = runtimeValue(
@@ -6219,7 +6504,7 @@ function materialize(authored, registration) {
       );
   if (Array.isArray(authored.inputs))
     for (const saved of authored.inputs) {
-      const definition = registration.definition.inputs?.[saved.name];
+      const definition = registration2.definition.inputs?.[saved.name];
       if (definition?.kind === "data") {
         inputs[saved.name] = runtimeValue(
           "defaultValue" in saved ? saved.defaultValue : saved.value,
@@ -6231,7 +6516,7 @@ function materialize(authored, registration) {
     }
   else if (authored.inputs)
     for (const [name, saved] of Object.entries(authored.inputs)) {
-      const definition = registration.definition.inputs?.[name];
+      const definition = registration2.definition.inputs?.[name];
       if (definition?.kind === "data")
         inputs[name] = runtimeValue(
           saved,
@@ -6241,7 +6526,7 @@ function materialize(authored, registration) {
         );
     }
   for (const [name, definition] of Object.entries(
-    registration.definition.props ?? {}
+    registration2.definition.props ?? {}
   ))
     props[name] = runtimeValue(
       definition.default,
@@ -6257,7 +6542,7 @@ function materialize(authored, registration) {
   const bindings = {};
   const storedProps = authored.props ?? {};
   for (const [name, definition] of Object.entries(
-    registration.definition.props ?? {}
+    registration2.definition.props ?? {}
   )) {
     if (!definition.expression || name in storedProps) continue;
     bindings[name] = {
@@ -6266,7 +6551,7 @@ function materialize(authored, registration) {
     };
   }
   for (const [name, saved] of Object.entries(storedProps)) {
-    const definition = registration.definition.props?.[name];
+    const definition = registration2.definition.props?.[name];
     if (!definition) continue;
     const object = saved && typeof saved === "object" && "value" in saved ? saved : null;
     const value = runtimeValue(
@@ -6291,26 +6576,26 @@ function materialize(authored, registration) {
   }
   return {
     id: authored.id,
-    moduleId: registration.moduleId,
+    moduleId: registration2.moduleId,
     ...authored.parent ? { parent: authored.parent } : {},
-    registration,
-    definition: registration.definition,
+    registration: registration2,
+    definition: registration2.definition,
     inputs,
     props,
     bindings,
-    strayParams: strayParams(authored, registration),
-    unknownProps: unknownProps(authored, registration),
+    strayParams: strayParams(authored, registration2),
+    unknownProps: unknownProps(authored, registration2),
     outputs: /* @__PURE__ */ new Map()
   };
 }
-function unknownProps(authored, registration) {
+function unknownProps(authored, registration2) {
   const props = authored.props;
   if (!props || Array.isArray(props)) return [];
-  const declared = registration.definition.props ?? {};
+  const declared = registration2.definition.props ?? {};
   return Object.keys(props).filter((name) => !(name in declared));
 }
-function strayParams(authored, registration) {
-  const definition = registration.definition;
+function strayParams(authored, registration2) {
+  const definition = registration2.definition;
   const declared = /* @__PURE__ */ new Set([
     ...Object.keys(definition.props ?? {}),
     ...Object.keys(definition.inputs ?? {})
@@ -6320,14 +6605,14 @@ function strayParams(authored, registration) {
     (name) => typeof name === "string" && declared.has(name)
   );
 }
-function specializeCoreRegistration(registration, authored, nodes) {
-  if (registration.moduleId === "cascade.core.Input" || registration.moduleId === "cascade.core.Output") {
+function specializeCoreRegistration(registration2, authored, nodes) {
+  if (registration2.moduleId === "cascade.core.Input" || registration2.moduleId === "cascade.core.Output") {
     const type = savedDataType(authored.props?.dataType);
-    const inputName2 = registration.moduleId === "cascade.core.Input" ? "value" : "input";
+    const inputName2 = registration2.moduleId === "cascade.core.Input" ? "value" : "input";
     return Object.freeze({
-      ...registration,
+      ...registration2,
       definition: Object.freeze({
-        ...registration.definition,
+        ...registration2.definition,
         inputs: Object.freeze({
           [inputName2]: dataInputDefinition(type)
         }),
@@ -6337,14 +6622,14 @@ function specializeCoreRegistration(registration, authored, nodes) {
       })
     });
   }
-  if (registration.moduleId !== "cascade.core.Subnet") return registration;
+  if (registration2.moduleId !== "cascade.core.Subnet") return registration2;
   const children = nodes.filter((candidate) => candidate.parent === authored.id);
   const inputs = indexedBoundaryPorts(children, "cascade.core.Input", "inputIndex", "input");
   const outputs = indexedBoundaryPorts(children, "cascade.core.Output", "outputIndex", "output");
   return Object.freeze({
-    ...registration,
+    ...registration2,
     definition: Object.freeze({
-      ...registration.definition,
+      ...registration2.definition,
       ...Object.keys(inputs).length ? { inputs: Object.freeze(inputs) } : {},
       ...Object.keys(outputs).length ? { outputs: Object.freeze(outputs) } : {}
     })
@@ -6516,11 +6801,11 @@ function validateHierarchy(nodes, byId) {
     }
   }
 }
-function snapshotRegistration(registration) {
-  if (registration.kind === "legacy-dynamic")
-    return Object.freeze({ ...registration });
-  const definition = snapshot(registration.definition);
-  return Object.freeze({ ...registration, definition });
+function snapshotRegistration(registration2) {
+  if (registration2.kind === "legacy-dynamic")
+    return Object.freeze({ ...registration2 });
+  const definition = snapshot(registration2.definition);
+  return Object.freeze({ ...registration2, definition });
 }
 function isGated(node) {
   return Object.values(node.definition.inputs ?? {}).some(
@@ -6764,9 +7049,9 @@ var init_runtime = __esm({
         this.aborted = false;
         this.listeners = /* @__PURE__ */ new Set();
       }
-      addEventListener(_type, listener, options) {
+      addEventListener(_type, listener, options2) {
         if (this.aborted) this.call(listener);
-        else if (options?.once) {
+        else if (options2?.once) {
           const once = () => {
             this.listeners.delete(once);
             listener();
@@ -6803,22 +7088,22 @@ var init_runtime = __esm({
         this.graphs = /* @__PURE__ */ new Set();
         this.sealed = false;
         this.disposed = false;
-        for (const registration of registrations) this.registerNode(registration);
+        for (const registration2 of registrations) this.registerNode(registration2);
       }
-      registerNode(registration) {
+      registerNode(registration2) {
         if (this.sealed || this.disposed)
           misuse(
             "runtime/registry-sealed",
             "Node registrations are sealed after the first load"
           );
-        if (this.registrations.has(registration.moduleId))
+        if (this.registrations.has(registration2.moduleId))
           misuse(
             "runtime/duplicate-registration",
-            `Duplicate registration ${registration.moduleId}`
+            `Duplicate registration ${registration2.moduleId}`
           );
         this.registrations.set(
-          registration.moduleId,
-          snapshotRegistration(registration)
+          registration2.moduleId,
+          snapshotRegistration(registration2)
         );
       }
       async load(document2) {
@@ -6853,18 +7138,18 @@ var init_runtime = __esm({
               "runtime/legacy-adapter-required",
               `Legacy module ${moduleId2} requires the explicit legacy adapter`
             );
-          const registration = specializeCoreRegistration(
+          const registration2 = specializeCoreRegistration(
             snapshot2,
             authored,
             document2.nodes
           );
-          const diagnostics = validateNodeDefinition(registration.definition);
+          const diagnostics = validateNodeDefinition(registration2.definition);
           if (diagnostics.length)
             throw new CascadeRuntimeError(
               "runtime/definition-invalid",
               diagnostics
             );
-          nodes.push(materialize(authored, registration));
+          nodes.push(materialize(authored, registration2));
         }
         const byId = new Map(nodes.map((node) => [node.id, node]));
         validateHierarchy(nodes, byId);
@@ -7184,17 +7469,17 @@ var init_runtime = __esm({
       getFps() {
         return this.fps;
       }
-      run(options = {}) {
-        if (options.fps !== void 0) this.setFps(options.fps);
-        if (options.frame !== void 0) this.setFrame(options.frame);
+      run(options2 = {}) {
+        if (options2.fps !== void 0) this.setFps(options2.fps);
+        if (options2.frame !== void 0) this.setFrame(options2.frame);
         else this.animator.resolveAll();
         return this.trackRun(
-          options.target ?? { kind: "all" },
-          options.signal,
-          options.runId
+          options2.target ?? { kind: "all" },
+          options2.signal,
+          options2.runId
         );
       }
-      trigger(nodeId, inputName2, payload, options = {}) {
+      trigger(nodeId, inputName2, payload, options2 = {}) {
         const node = this.requireNode(nodeId);
         if (node.definition.inputs?.[inputName2]?.kind !== "trigger")
           return Promise.reject(
@@ -7205,8 +7490,8 @@ var init_runtime = __esm({
           );
         return this.trackRun(
           { kind: "node", nodeId },
-          options.signal,
-          options.runId,
+          options2.signal,
+          options2.runId,
           { nodeId, inputName: inputName2, payload }
         );
       }
@@ -7922,7 +8207,7 @@ var init_src2 = __esm({
 });
 
 // packages/runtime/src/node.ts
-function createNodeRuntimeHost(options) {
+function createNodeRuntimeHost(options2) {
   const {
     modules,
     legacyShell,
@@ -7930,7 +8215,7 @@ function createNodeRuntimeHost(options) {
     report = () => {
     },
     ...capabilities
-  } = options;
+  } = options2;
   return {
     environment: "server",
     modules,
@@ -8481,12 +8766,12 @@ function normalizeManifest(raw) {
     settings: Object.freeze(settingsRecord(raw.settings))
   });
 }
-function stringRecord(input, label) {
+function stringRecord(input, label2) {
   if (input === void 0) return {};
-  if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error(`${label} must be an object of strings`);
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error(`${label2} must be an object of strings`);
   const entries2 = Object.entries(input);
   if (entries2.some(([key2, value]) => !CREDENTIAL_NAME.test(key2) || typeof value !== "string" || value.includes("\0"))) {
-    throw new Error(`${label} must contain safe names and string values`);
+    throw new Error(`${label2} must contain safe names and string values`);
   }
   return Object.fromEntries(entries2);
 }
@@ -8630,7 +8915,7 @@ function within(root, candidate) {
 function emptyResult() {
   return { stdout: "", stderr: "", code: null, timedOut: false, cancelled: false, outputLimited: false };
 }
-function execute(executable, args, options) {
+function execute(executable, args, options2) {
   return new Promise((resolve2, reject) => {
     let terminal = null;
     let spawnError;
@@ -8640,8 +8925,8 @@ function execute(executable, args, options) {
     let stdoutBytes = 0;
     let stderrBytes = 0;
     const child = spawn(executable, args, {
-      cwd: options.cwd,
-      env: options.env,
+      cwd: options2.cwd,
+      env: options2.env,
       detached: process.platform !== "win32",
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
@@ -8651,9 +8936,9 @@ function execute(executable, args, options) {
       terminal = cause;
       if (cause === "timeout" || cause === "cancelled" || cause === "output-limit") termination = terminateTree(child);
     };
-    const timer = setTimeout(() => finishCause("timeout"), options.timeout);
+    const timer = setTimeout(() => finishCause("timeout"), options2.timeout);
     const abort = () => finishCause("cancelled");
-    options.signal?.addEventListener("abort", abort, { once: true });
+    options2.signal?.addEventListener("abort", abort, { once: true });
     child.stdout.on("data", (chunk) => {
       stdoutBytes += chunk.length;
       if (stdoutBytes <= MAX_BUFFER) stdout.push(chunk);
@@ -8671,7 +8956,7 @@ function execute(executable, args, options) {
     child.once("exit", (code, signal) => finishCause(code === null || signal ? "signal" : "exit"));
     child.once("close", async (code, signal) => {
       clearTimeout(timer);
-      options.signal?.removeEventListener("abort", abort);
+      options2.signal?.removeEventListener("abort", abort);
       await termination?.beforeSettle();
       const output = { stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") };
       if (terminal === "timeout" || terminal === "cancelled" || terminal === "output-limit") {
@@ -8684,9 +8969,9 @@ function execute(executable, args, options) {
         resolve2({ ...output, code, timedOut: false, cancelled: false, outputLimited: false });
       }
     });
-    if (options.stdin !== void 0) child.stdin.end(options.stdin);
+    if (options2.stdin !== void 0) child.stdin.end(options2.stdin);
     else child.stdin.end();
-    if (options.signal?.aborted) abort();
+    if (options2.signal?.aborted) abort();
   });
 }
 function terminateTree(child) {
@@ -8758,7 +9043,7 @@ var init_service = __esm({
       setAuditSink(sink) {
         this.auditSink = sink;
       }
-      async run(command, args = [], options = {}) {
+      async run(command, args = [], options2 = {}) {
         const started = Date.now();
         const id = randomUUID();
         let cwd = ".";
@@ -8767,14 +9052,14 @@ var init_service = __esm({
         try {
           this.reloadConfig();
           const executable = this.resolveCommand(command);
-          const validated = this.validate(args, options);
+          const validated = this.validate(args, options2);
           cwd = validated.relativeCwd;
           result = await execute(executable, validated.args, {
             cwd: validated.cwd,
             timeout: validated.timeout,
             stdin: validated.stdin,
             env: validated.env,
-            signal: options.signal
+            signal: options2.signal
           });
           return result;
         } catch (error) {
@@ -8810,8 +9095,8 @@ var init_service = __esm({
           this.executables.set(alias, resolveExecutable(this.project.root, target));
         }
       }
-      async runJson(command, args = [], options = {}) {
-        const result = await this.run(command, args, options);
+      async runJson(command, args = [], options2 = {}) {
+        const result = await this.run(command, args, options2);
         if (result.code !== 0) throw new ShellProcessError("nonzero", result, result.stderr || `Command exited with code ${result.code}`);
         const lines = result.stdout.split(/\r?\n/).filter((value) => value.trim());
         const line2 = lines[lines.length - 1] ?? "";
@@ -8833,15 +9118,15 @@ var init_service = __esm({
         if (!executable) throw new ShellRequestError("MISSING_EXECUTABLE", `Configured command "${command}" is not available`);
         return executable;
       }
-      validate(args, options) {
+      validate(args, options2) {
         if (!Array.isArray(args) || args.length > MAX_ARGS || args.some((arg) => typeof arg !== "string" || Buffer.byteLength(arg) > MAX_ARG_BYTES || arg.includes("\0"))) {
           throw new ShellRequestError("INVALID_REQUEST", "args must be an array of bounded strings");
         }
-        if (options.stdin !== void 0 && (typeof options.stdin !== "string" || Buffer.byteLength(options.stdin) > MAX_STDIN_BYTES || options.stdin.includes("\0"))) {
+        if (options2.stdin !== void 0 && (typeof options2.stdin !== "string" || Buffer.byteLength(options2.stdin) > MAX_STDIN_BYTES || options2.stdin.includes("\0"))) {
           throw new ShellRequestError("INVALID_REQUEST", "stdin exceeds the 16 MiB limit or is invalid");
         }
-        const { cwd, relativeCwd } = resolveCwd(this.project.root, options.cwd ?? ".");
-        const requestEnv = options.env ?? {};
+        const { cwd, relativeCwd } = resolveCwd(this.project.root, options2.cwd ?? ".");
+        const requestEnv = options2.env ?? {};
         const entries2 = Object.entries(requestEnv);
         if (entries2.length > MAX_ENV_KEYS || entries2.reduce((sum2, [key2, value]) => sum2 + Buffer.byteLength(key2) + Buffer.byteLength(String(value)), 0) > MAX_ENV_BYTES) {
           throw new ShellRequestError("INVALID_REQUEST", "request environment exceeds its limit");
@@ -8851,17 +9136,17 @@ var init_service = __esm({
             throw new ShellRequestError("INVALID_REQUEST", `request environment variable ${JSON.stringify(key2)} is not allowed`);
           }
         }
-        if (options.timeout !== void 0 && (typeof options.timeout !== "number" || !Number.isFinite(options.timeout))) {
+        if (options2.timeout !== void 0 && (typeof options2.timeout !== "number" || !Number.isFinite(options2.timeout))) {
           throw new ShellRequestError("INVALID_REQUEST", "timeout must be a finite number");
         }
-        const timeout = Math.min(6e5, Math.max(1, Math.trunc(options.timeout ?? this.config.shell.timeout)));
+        const timeout = Math.min(6e5, Math.max(1, Math.trunc(options2.timeout ?? this.config.shell.timeout)));
         const credentialEnv = new CredentialStore().environment(readProjectManifest(this.project.root).credentials);
         return {
           args: [...args],
           cwd,
           relativeCwd,
           timeout,
-          stdin: options.stdin,
+          stdin: options2.stdin,
           env: { ...process.env, ...this.config.shell.env, ...requestEnv, ...credentialEnv }
         };
       }
@@ -9543,7 +9828,7 @@ async function runDeterministicProjectGraph(file, document2, entryNode) {
     }
   }
 }
-async function renderDeterministicProjectFrames(file, document2, options) {
+async function renderDeterministicProjectFrames(file, document2, options2) {
   const prepared = await prepare(file, document2, true);
   reportUnresolved(prepared);
   if (!usesDeterministicHost(document2, prepared)) return null;
@@ -9554,7 +9839,7 @@ async function renderDeterministicProjectFrames(file, document2, options) {
     nodes: prepared.registrations
   });
   let graph;
-  const width = sequenceWidth(options.end);
+  const width = sequenceWidth(options2.end);
   const frames = [];
   const files = [];
   let aborted = false;
@@ -9563,24 +9848,24 @@ async function renderDeterministicProjectFrames(file, document2, options) {
   try {
     graph = await runtime.load(document2);
     reportPreflightWarnings(host, classifyPreflight(graph.preflight()).warnings);
-    const outDirectory = project.resolve(options.out);
+    const outDirectory = project.resolve(options2.out);
     await fs7.mkdir(outDirectory, { recursive: true });
-    for (const frame of frameRange(options.start, options.end, options.step ?? 1)) {
-      if (options.signal?.aborted) {
+    for (const frame of frameRange(options2.start, options2.end, options2.step ?? 1)) {
+      if (options2.signal?.aborted) {
         aborted = true;
         break;
       }
       const result = await graph.run({
         frame,
-        ...options.fps === void 0 ? {} : { fps: options.fps },
-        ...options.entryNode ? { target: { kind: "node", nodeId: options.entryNode } } : {}
+        ...options2.fps === void 0 ? {} : { fps: options2.fps },
+        ...options2.entryNode ? { target: { kind: "node", nodeId: options2.entryNode } } : {}
       });
       if (result.status !== "completed") {
         throw new Error(
           `frame ${frame} ${result.status} \u2014 ${result.diagnostics.map((item) => item.message).join("; ") || "no diagnostics"}`
         );
       }
-      const outputs = imageOutputs(graph, options.entryNode);
+      const outputs = imageOutputs(graph, options2.entryNode);
       if (!outputs.length) {
         throw new Error(
           "No image output to save: the graph has no unconsumed image port. Name the node to render with --entry-node."
@@ -9591,10 +9876,10 @@ async function renderDeterministicProjectFrames(file, document2, options) {
         if (!source) continue;
         const name = sequenceFileName(nodeId, frame, source, width);
         await fs7.copyFile(project.resolveMedia(source.replace(/^\.?\//, "")), path9.join(outDirectory, name));
-        files.push(path9.posix.join(options.out, name));
+        files.push(path9.posix.join(options2.out, name));
       }
       frames.push(frame);
-      if (options.verbose) console.log(`  frame ${frame}`);
+      if (options2.verbose) console.log(`  frame ${frame}`);
     }
     try {
       gpu = { renderer: "dawn", adapter: host.capabilities.gpu.adapterInfo };
@@ -9835,7 +10120,7 @@ function jsonValue(value) {
   }
 }
 function resolver(registrations) {
-  const modules = new Map(registrations.map((registration) => [registration.moduleId, registration]));
+  const modules = new Map(registrations.map((registration2) => [registration2.moduleId, registration2]));
   return { resolve: async (id) => modules.get(id) ?? null };
 }
 function formatDiagnostic(diagnostic2) {
@@ -10038,7 +10323,7 @@ function readStageConfig(project) {
   }
   return { python, entrypoint, ...worker ? { worker } : {} };
 }
-async function runProjectStage(project, stage, args, options = {}) {
+async function runProjectStage(project, stage, args, options2 = {}) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(stage)) {
     throw new Error("stage contains unsupported characters");
   }
@@ -10051,10 +10336,10 @@ async function runProjectStage(project, stage, args, options = {}) {
       [script, "--stage", stage, "--args", "-"],
       {
         cwd: project.root,
-        timeout: options.timeout ?? TIMEOUT_MS,
+        timeout: options2.timeout ?? TIMEOUT_MS,
         maxBuffer: MAX_BUFFER2,
-        env: options.env ?? process.env,
-        signal: options.signal
+        env: options2.env ?? process.env,
+        signal: options2.signal
       },
       (error, out, err) => {
         if (error) {
@@ -10088,7 +10373,7 @@ var init_stageRunner = __esm({
 });
 
 // packages/runtime/src/browser.ts
-function createBrowserRuntimeHost(options) {
+function createBrowserRuntimeHost(options2) {
   const {
     modules,
     legacyShell,
@@ -10096,7 +10381,7 @@ function createBrowserRuntimeHost(options) {
     report = () => {
     },
     ...capabilities
-  } = options;
+  } = options2;
   return {
     environment: "browser",
     modules,
@@ -10123,10 +10408,10 @@ import { builtinModules } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { build as build3 } from "esbuild";
 import ts3 from "typescript";
-async function buildPlayer(file, options) {
-  if (!options.out) throw new Error("cascade build requires --out <new-directory>");
+async function buildPlayer(file, options2) {
+  if (!options2.out) throw new Error("cascade build requires --out <new-directory>");
   const project = new ProjectRoot(path14.dirname(path14.resolve(file)));
-  const out = path14.resolve(project.root, options.out);
+  const out = path14.resolve(project.root, options2.out);
   if (await exists2(out)) throw new Error(`Player output already exists: ${out}. Choose a new directory.`);
   const canonicalOut = await canonicalFuturePath(out);
   for (const sourceDirectory of ["assets", "nodes"]) {
@@ -10169,7 +10454,7 @@ ${extracted.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")}`);
     assets: {},
     gpu: {}
   }), nodes: registrations });
-  const assets = new Set(options.assets ?? []);
+  const assets = new Set(options2.assets ?? []);
   try {
     const graph = await runtime.load(document2);
     const diagnostics = graph.preflight();
@@ -11124,12 +11409,12 @@ function isLoopbackHost(host) {
   const normalized = host.toLowerCase().replace(/^\[|\]$/g, "");
   return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1";
 }
-function allowsSensitiveCapabilities(options) {
-  return options.sensitiveCapabilities;
+function allowsSensitiveCapabilities(options2) {
+  return options2.sensitiveCapabilities;
 }
-function createProjectRequestBoundary(options) {
-  const origins = new Set(options.trustedOrigins.map((origin) => validateOrigin(origin, "Project")));
-  const authorities = allowedAuthorities(options, origins);
+function createProjectRequestBoundary(options2) {
+  const origins = new Set(options2.trustedOrigins.map((origin) => validateOrigin(origin, "Project")));
+  const authorities = allowedAuthorities(options2, origins);
   return {
     guard(req, res, next) {
       const host = req.get("Host");
@@ -11150,9 +11435,9 @@ function createProjectRequestBoundary(options) {
     }
   };
 }
-function createBrowserCapabilityBoundary(options, label, header) {
-  const origins = new Set(options.trustedOrigins.map((origin) => validateOrigin(origin, label)));
-  const authorities = allowedAuthorities(options, origins);
+function createBrowserCapabilityBoundary(options2, label2, header) {
+  const origins = new Set(options2.trustedOrigins.map((origin) => validateOrigin(origin, label2)));
+  const authorities = allowedAuthorities(options2, origins);
   const capability2 = randomBytes(32).toString("base64url");
   const expectedBytes = Buffer.from(capability2);
   return {
@@ -11160,7 +11445,7 @@ function createBrowserCapabilityBoundary(options, label, header) {
       const origin = req.get("Origin");
       const host = req.get("Host");
       if (!host || !authorities.has(host.toLowerCase()) || origin === "null" || origin && !origins.has(origin)) {
-        res.status(403).json({ ok: false, error: `${label} access denied` });
+        res.status(403).json({ ok: false, error: `${label2} access denied` });
         return;
       }
       if (origin) setCorsOrigin(res, origin);
@@ -11180,23 +11465,23 @@ function createBrowserCapabilityBoundary(options, label, header) {
       const supplied = req.get(header);
       const suppliedBytes = supplied ? Buffer.from(supplied) : Buffer.alloc(0);
       if (suppliedBytes.length !== expectedBytes.length || !timingSafeEqual(suppliedBytes, expectedBytes)) {
-        res.status(403).json({ ok: false, error: `${label} capability required` });
+        res.status(403).json({ ok: false, error: `${label2} capability required` });
         return;
       }
       next();
     }
   };
 }
-function allowedAuthorities(options, origins) {
+function allowedAuthorities(options2, origins) {
   const authorities = new Set([...origins].map((origin) => new URL(origin).host.toLowerCase()));
-  if (isLoopbackHost(options.host)) {
-    authorities.add(`127.0.0.1:${options.port}`);
-    authorities.add(`localhost:${options.port}`);
-  } else if (!isWildcardHost(options.host)) {
-    authorities.add(authority(options.host, options.port));
-  }
-  for (const host of options.trustedHosts) {
-    const value = trustedAuthority(host, options.port);
+  if (isLoopbackHost(options2.host)) {
+    authorities.add(`127.0.0.1:${options2.port}`);
+    authorities.add(`localhost:${options2.port}`);
+  } else if (!isWildcardHost(options2.host)) {
+    authorities.add(authority(options2.host, options2.port));
+  }
+  for (const host of options2.trustedHosts) {
+    const value = trustedAuthority(host, options2.port);
     authorities.add(value);
     const bare = value.replace(/:(?:80|443)$/, "");
     if (bare !== value) authorities.add(bare);
@@ -11232,10 +11517,10 @@ function setCorsOrigin(res, origin) {
   res.setHeader("Access-Control-Allow-Origin", origin);
   res.setHeader("Vary", "Origin");
 }
-function validateOrigin(value, label) {
+function validateOrigin(value, label2) {
   const url = new URL(value);
   if (!/^https?:$/.test(url.protocol) || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
-    throw new Error(`Invalid trusted ${label.toLowerCase()} origin: ${value}`);
+    throw new Error(`Invalid trusted ${label2.toLowerCase()} origin: ${value}`);
   }
   return url.origin;
 }
@@ -11367,10 +11652,10 @@ var init_exec = __esm({
 
 // server/src/routes/shell.ts
 import { Router as Router6, json as json2 } from "express";
-function createShellRouter(shell, options) {
+function createShellRouter(shell, options2) {
   const router = Router6();
-  if (!allowsSensitiveCapabilities(options)) return router.use((_req, res) => res.status(404).end());
-  const boundary = createBrowserCapabilityBoundary(options, "Shell", "X-Cascade-Shell-Capability");
+  if (!allowsSensitiveCapabilities(options2)) return router.use((_req, res) => res.status(404).end());
+  const boundary = createBrowserCapabilityBoundary(options2, "Shell", "X-Cascade-Shell-Capability");
   router.use(boundary.guardOrigin);
   router.options("{*path}", boundary.preflight);
   router.get("/capability", boundary.issueCapability);
@@ -13477,19 +13762,19 @@ var Node = class _Node {
     else if (!promoted && index >= 0) parent.promotions.splice(index, 1);
   }
   // ============ Port Creation ============
-  in(name, defaultValue, options = {}) {
+  in(name, defaultValue, options2 = {}) {
     const portType = name === "trigger" ? "trigger" : "param";
     const existingPort = this.inputs.find((p) => p.name === name);
     if (existingPort) {
       this.portsUsedDuringSetup.add(`input_${name}`);
-      if (options.type) existingPort.dataType = options.type;
+      if (options2.type) existingPort.dataType = options2.type;
       if (defaultValue !== void 0 && existingPort.defaultValue !== defaultValue) {
         existingPort.defaultValue = defaultValue;
         if (existingPort.value === void 0 || existingPort.value === existingPort.defaultValue) {
           existingPort.value = defaultValue;
         }
       }
-      existingPort.options = Object.assign(existingPort.options ?? {}, options);
+      existingPort.options = Object.assign(existingPort.options ?? {}, options2);
       return existingPort;
     }
     const portIndex = this.inputs.length;
@@ -13497,10 +13782,10 @@ var Node = class _Node {
       id: `${this.id}_in_${portIndex}`,
       name,
       portType,
-      dataType: options.type || "any",
+      dataType: options2.type || "any",
       value: defaultValue,
       defaultValue,
-      options,
+      options: options2,
       connections: []
     };
     this.inputs.push(port);
@@ -13514,13 +13799,13 @@ var Node = class _Node {
    * only ever sees `any` on one side, and the port draws in the neutral colour
    * whatever it actually carries.
    */
-  out(name, portType = "param", options = {}) {
+  out(name, portType = "param", options2 = {}) {
     const existingPort = this.outputs.find((p) => p.name === name);
     if (existingPort) {
       this.portsUsedDuringSetup.add(`output_${name}`);
       if (existingPort.portType !== portType) existingPort.portType = portType;
-      if (options.type) existingPort.dataType = options.type;
-      existingPort.options = { ...existingPort.options ?? {}, ...options };
+      if (options2.type) existingPort.dataType = options2.type;
+      existingPort.options = { ...existingPort.options ?? {}, ...options2 };
       return existingPort;
     }
     const portIndex = this.outputs.length;
@@ -13528,10 +13813,10 @@ var Node = class _Node {
       id: `${this.id}_out_${portIndex}`,
       name,
       portType,
-      dataType: options.type || "any",
+      dataType: options2.type || "any",
       value: void 0,
       connections: [],
-      options,
+      options: options2,
       setValue: (value) => this.setOutputValue(port, value),
       trigger: (props) => {
         port.connections.forEach((conn) => {
@@ -13877,26 +14162,26 @@ var Node = class _Node {
    * say. Promotion is per parameter and off by default: making every setting a
    * pin is how the two got conflated in the first place.
    */
-  param(name, defaultValue, options = {}) {
+  param(name, defaultValue, options2 = {}) {
     let parameter = this.parameters.find((p) => p.name === name);
     if (!parameter) {
       parameter = {
         name,
         value: defaultValue,
         defaultValue,
-        dataType: options.type || inferParamType(defaultValue),
+        dataType: options2.type || inferParamType(defaultValue),
         promoted: false,
-        options
+        options: options2
       };
       this.parameters.push(parameter);
     } else {
-      if (options.type) parameter.dataType = options.type;
+      if (options2.type) parameter.dataType = options2.type;
       parameter.defaultValue = defaultValue;
-      Object.assign(parameter.options, options);
+      Object.assign(parameter.options, options2);
     }
     this.parametersUsedDuringSetup.add(name);
-    this.reconcileParameter(parameter, defaultValue, options);
-    this.bindParameterProp(parameter, name, options);
+    this.reconcileParameter(parameter, defaultValue, options2);
+    this.bindParameterProp(parameter, name, options2);
     if (parameter.promoted) {
       const port = this.in(name, parameter.value, {
         ...parameter.options,
@@ -13920,7 +14205,7 @@ var Node = class _Node {
    * rather than replaced for the same reason the Inspector does not re-key a
    * row on commit — replacing it mid-drag destroys the control in use.
    */
-  bindParameterProp(parameter, name, options) {
+  bindParameterProp(parameter, name, options2) {
     const descriptor = Object.getOwnPropertyDescriptor(parameter, "value");
     const seeded = descriptor && !descriptor.get ? descriptor.value : void 0;
     let prop = this.props[name];
@@ -13929,10 +14214,10 @@ var Node = class _Node {
       this.props[name] = prop;
       this.props = { ...this.props };
     }
-    if (options.defaultExpression && !this.defaultExpressionsApplied.has(name)) {
+    if (options2.defaultExpression && !this.defaultExpressionsApplied.has(name)) {
       this.defaultExpressionsApplied.add(name);
       if (!this.plainPropOverrides.has(name) && !prop.expression) {
-        prop.expression = options.defaultExpression;
+        prop.expression = options2.defaultExpression;
         this.props = { ...this.props };
         this.updateTimeDependent();
       }
@@ -13942,9 +14227,9 @@ var Node = class _Node {
     const control = paramControlType(parameter.dataType);
     if (control) prop.type = control;
     const params = { ...prop.params ?? {} };
-    if (options.min !== void 0) params.min = options.min;
-    if (options.max !== void 0) params.max = options.max;
-    if (options.step !== void 0) params.step = options.step;
+    if (options2.min !== void 0) params.min = options2.min;
+    if (options2.max !== void 0) params.max = options2.max;
+    if (options2.step !== void 0) params.step = options2.step;
     if (normalizeType(parameter.dataType ?? "any") === "int") params.integer = true;
     prop.params = params;
     if (descriptor?.get) return;
@@ -14177,13 +14462,13 @@ var Node = class _Node {
     return carry.report;
   }
   /** Called from param() for every declaration the new definition makes. */
-  reconcileParameter(parameter, defaultValue, options) {
+  reconcileParameter(parameter, defaultValue, options2) {
     const carry = this.carryOver;
     if (!carry) return;
     const key2 = `parameter:${parameter.name}`;
     if (carry.resolved.has(key2)) return;
     carry.resolved.add(key2);
-    const declared = options.type ?? inferParamType(defaultValue);
+    const declared = options2.type ?? inferParamType(defaultValue);
     parameter.dataType = declared;
     const declaredType = carryType(declared);
     const crossKey = `prop:${parameter.name}`;
@@ -14244,10 +14529,10 @@ var Node = class _Node {
     }
   }
   // ============ Variadic Inputs ============
-  setVariadic(defaultValue = null, options = {}) {
+  setVariadic(defaultValue = null, options2 = {}) {
     this.variadic = true;
     this.variadicDefault = defaultValue;
-    this.variadicOptions = options;
+    this.variadicOptions = options2;
     this.syncVariadicPorts();
   }
   getVariadicInputs() {
@@ -15996,8 +16281,8 @@ function parameterOptions(definition) {
     promotable: false
   };
 }
-function attachDefinition(node, registration, capabilities) {
-  const definition = registration.definition;
+function attachDefinition(node, registration2, capabilities) {
+  const definition = registration2.definition;
   const pendingTriggers = /* @__PURE__ */ new Map();
   let triggerSequence = 0;
   const container = definition.container;
@@ -16060,10 +16345,10 @@ function attachDefinition(node, registration, capabilities) {
     if (hasTriggerInputs && pendingTriggers.size === 0) return;
     for (const name of definition.capabilities ?? []) {
       if (!capabilities[name]) {
-        throw new Error(`${registration.moduleId} requires the Studio ${name} capability`);
+        throw new Error(`${registration2.moduleId} requires the Studio ${name} capability`);
       }
     }
-    const execute2 = await (executePromise ??= registration.loadExecute("browser"));
+    const execute2 = await (executePromise ??= registration2.loadExecute("browser"));
     const inputValues = {};
     for (const [name, input] of Object.entries(definition.inputs ?? {})) {
       inputValues[name] = input.kind === "trigger" ? pendingTriggers.get(name) : input.variadic ? node.getVariadicInputs().map((port) => port.value ?? void 0) : node.inputs.find((port) => port.name === name)?.value;
@@ -16071,7 +16356,7 @@ function attachDefinition(node, registration, capabilities) {
     pendingTriggers.clear();
     const outputs = Object.fromEntries(Object.entries(definition.outputs ?? {}).map(([name, output]) => {
       const port = node.outputs.find((candidate) => candidate.name === name);
-      if (!port) throw new Error(`Missing output ${registration.moduleId}.${name}`);
+      if (!port) throw new Error(`Missing output ${registration2.moduleId}.${name}`);
       return [name, output.kind === "trigger" ? { trigger: (payload) => port.trigger(payload) } : { set: (value) => port.setValue(value) }];
     }));
     let nodeCapabilities = capabilities;
@@ -16171,8 +16456,8 @@ async function post(body, signal) {
   }
   return response;
 }
-function requestBody(command, args, options) {
-  const { signal: _signal, ...rest } = options ?? {};
+function requestBody(command, args, options2) {
+  const { signal: _signal, ...rest } = options2 ?? {};
   return {
     command,
     ...args ? { args } : {},
@@ -16192,14 +16477,14 @@ async function fail2(response) {
   throw new Error(message2);
 }
 var browserShellCapability = {
-  async run(command, args, options) {
-    const response = await post(requestBody(command, args, options), options?.signal);
+  async run(command, args, options2) {
+    const response = await post(requestBody(command, args, options2), options2?.signal);
     if (!response.ok) await fail2(response);
     const { ok: _ok, ...result } = await response.json();
     return result;
   },
-  async runJson(command, args, options) {
-    const result = await this.run(command, args, options);
+  async runJson(command, args, options2) {
+    const result = await this.run(command, args, options2);
     try {
       return JSON.parse(result.stdout);
     } catch {
@@ -16312,13 +16597,13 @@ function adaptModule(node, moduleId2, module, capabilities = studioCapabilities)
   const invalid = definitionAdapterError(module.definition);
   if (invalid) throw new Error(`${moduleId2} exports an invalid definition-v1 literal:
 ${invalid}`);
-  const registration = {
+  const registration2 = {
     kind: "definition-v1",
     moduleId: moduleId2,
     definition: module.definition,
     loadExecute: async () => module.execute
   };
-  return attachDefinition(node, registration, capabilities);
+  return attachDefinition(node, registration2, capabilities);
 }
 
 // src/nodes/CookScheduler.ts
@@ -16466,8 +16751,20 @@ var CookScheduler = class {
         elapsed: 0
       });
       const blocked = /* @__PURE__ */ new Set();
+      const notReady = this.graph.pendingConnectionTargets();
       let superseded = false;
       for (const node of ordered) {
+        if (notReady.has(node.id)) {
+          node.setCookState("stale");
+          blocked.add(node.id);
+          this.setStatus({
+            ...this._status,
+            completed: this._status.completed + 1,
+            currentNode: null,
+            elapsed: performance.now() - startedAt
+          });
+          continue;
+        }
         const upstreamBlocked = node.inputs.some((input) => input.connections.some(
           (connection) => staleIds.has(connection.from.nodeId) && (blocked.has(connection.from.nodeId) || this.graph.getNode(connection.from.nodeId)?.cookState === "error")
         ));
@@ -16538,9 +16835,9 @@ var CookScheduler = class {
    * interactive queue, not to weaken the preemption; the preemption is the
    * only thing making the lane honest.
    */
-  async runBackground(task, options = {}) {
+  async runBackground(task, options2 = {}) {
     this.preemptBackground("superseded by a newer background task");
-    await this.whenSettled(options.settleMs ?? this.debounceMs * 4);
+    await this.whenSettled(options2.settleMs ?? this.debounceMs * 4);
     const abort = new AbortController();
     this.backgroundAbort = abort;
     try {
@@ -16654,6 +16951,16 @@ var Graph = class _Graph {
     this.executionState = "idle";
     // Cached topological order (invalidated when graph structure changes)
     this.cachedTopologicalOrder = null;
+    /**
+     * Whether the load-time connection restore has stopped making progress.
+     *
+     * Set by whoever drives the warm-up passes — Studio's `cookGraph`, the CLI's
+     * runner — when the pending list stops shrinking. The pending list itself is
+     * kept, so a connection can still bind later if a bypass is lifted or a
+     * module finally compiles; what ends is treating it as a reason to hold a
+     * node back.
+     */
+    this.connectionsSettled = false;
     this.assetManager = assetManager || new AssetManager();
     this.packageManager = packageManager || new PackageManager();
     this.moduleResolver = moduleResolver || createModuleResolver();
@@ -16945,13 +17252,13 @@ var Graph = class _Graph {
    * them the result is `deferred: true` — a module's parameters are only known
    * once its code declares them, which happens on the next cook.
    */
-  retargetDefinition(nodeId, modulePath, source, code, options = {}) {
+  retargetDefinition(nodeId, modulePath, source, code, options2 = {}) {
     const blank = () => ({ kept: [], defaulted: [], dropped: [], retyped: [] });
     const node = this.getNode(nodeId);
     if (!node) {
       return { ok: false, deferred: false, ...blank(), error: `no node with id ${nodeId}` };
     }
-    const preserve = options.preserveParameters !== false;
+    const preserve = options2.preserveParameters !== false;
     if (preserve) node.beginParameterCarryOver();
     node.modulePath = modulePath;
     node.sourceType = source;
@@ -16963,8 +17270,8 @@ var Graph = class _Graph {
       console.warn("Failed to compile " + modulePath + ":", error);
     });
     node.markDirty();
-    if (preserve && options.parameters) {
-      const report = node.applyParameterDeclarations(options.parameters) ?? blank();
+    if (preserve && options2.parameters) {
+      const report = node.applyParameterDeclarations(options2.parameters) ?? blank();
       return { ok: true, deferred: false, ...report };
     }
     return { ok: true, deferred: preserve, ...blank() };
@@ -18019,12 +18326,47 @@ var Graph = class _Graph {
    * still unresolved stays pending, so calling this again after another cook
    * finishes the job.
    */
+  /**
+   * Node ids that a loaded file wires an input to, and whose connection has
+   * not bound yet.
+   *
+   * The reason this is public: **an input that is about to be connected is not
+   * an input that is missing**, and until now nothing could tell the two
+   * apart. On load a node's ports only exist once its code has run, so the
+   * first cook passes reach a node whose upstream edge has no port to attach
+   * to — the node runs with `undefined` on that input, throws whatever its
+   * author wrote for the unwired case, and a later pass then succeeds.
+   *
+   * The graph ends up correct and the log does not: those warm-up throws are
+   * real errors from the node's point of view, they are recorded, and they
+   * never clear. A user reported `volume-field` as broken on exactly this,
+   * having verified from the cache files that the output was in fact right.
+   *
+   * So the scheduler asks this before cooking, and treats a node with a
+   * pending inbound edge as *not ready* rather than as failed.
+   */
+  pendingConnectionTargets() {
+    const pending = this._connectionsToRestore;
+    const targets = /* @__PURE__ */ new Set();
+    if (this.connectionsSettled) return targets;
+    if (!Array.isArray(pending)) return targets;
+    for (const connection of pending) {
+      const target = Array.isArray(connection?.[1]) ? connection[1][0] : void 0;
+      if (typeof target === "string") targets.add(target);
+    }
+    return targets;
+  }
+  /** Called when the warm-up passes stop making progress. */
+  markConnectionsSettled() {
+    this.connectionsSettled = true;
+  }
   restoreConnections() {
     const connectionsToRestore = this._connectionsToRestore || [];
     if (connectionsToRestore.length === 0) return;
     const stillPending = connectionsToRestore.filter(
       (connData) => !this.tryRestoreConnection(connData, true)
     );
+    if (stillPending.length < connectionsToRestore.length) this.connectionsSettled = false;
     if (stillPending.length > 0) {
       this._connectionsToRestore = stillPending;
     } else {
@@ -18100,10 +18442,10 @@ async function installHeadlessCanvas() {
   const canvas = await loadCanvasModule();
   const globals2 = globalThis;
   class HeadlessOffscreenCanvas extends canvas.Canvas {
-    async convertToBlob(options = {}) {
-      const type = options.type ?? "image/png";
+    async convertToBlob(options2 = {}) {
+      const type = options2.type ?? "image/png";
       const format2 = type.replace(/^image\//, "");
-      const quality = options.quality === void 0 ? void 0 : Math.round(options.quality * 100);
+      const quality = options2.quality === void 0 ? void 0 : Math.round(options2.quality * 100);
       return new Blob([await this.encode(format2, quality)], { type });
     }
   }
@@ -18399,8 +18741,8 @@ var cascade = new CascadeContext();
 
 // src/engine/animation/frameRange.ts
 init_animation2();
-async function evaluateFrameRange(options) {
-  const { fps, context = cascade, ...rest } = options;
+async function evaluateFrameRange(options2) {
+  const { fps, context = cascade, ...rest } = options2;
   const previousFps = context.fps();
   if (fps !== void 0) context.setFps(fps);
   try {
@@ -18440,8 +18782,8 @@ function outputPorts(graph, entryNode) {
 function outputSnapshot(graph) {
   return JSON.stringify(graph.nodes.map((node) => [node.id, node.outputs.map((port) => port.value ?? null)]));
 }
-async function cookUntilSettled(graph, entryNode, options = {}) {
-  const { fixpoint = false, passes = 8 } = options;
+async function cookUntilSettled(graph, entryNode, options2 = {}) {
+  const { fixpoint = false, passes = 8 } = options2;
   const dirtyAll = () => {
     for (const node of graph.nodes) node.markDirty?.();
   };
@@ -18463,8 +18805,8 @@ async function cookUntilSettled(graph, entryNode, options = {}) {
   }
   throw new Error(`graph did not settle after ${passes} cook passes`);
 }
-async function renderFrameRange(options) {
-  const { graph, project, out, start, end, step: step2, fps, entryNode, verbose, signal } = options;
+async function renderFrameRange(options2) {
+  const { graph, project, out, start, end, step: step2, fps, entryNode, verbose, signal } = options2;
   cascade.setGraph(graph);
   const outDirectory = project.resolve(out);
   await fs10.mkdir(outDirectory, { recursive: true });
@@ -21572,8 +21914,8 @@ function reportMissingCanvas(messages, canvasError) {
   if (canvasError && messages.some(looksLikeCanvasFailure)) console.error(`
 ${MISSING_CANVAS_MESSAGE}`);
 }
-async function runGraph(options) {
-  const { file, entryNode, validateOnly, checkOnly, inspectOnly, verbose, frames, fps, out } = options;
+async function runGraph(options2) {
+  const { file, entryNode, validateOnly, checkOnly, inspectOnly, verbose, frames, fps, out } = options2;
   if (verbose) {
     console.log(`Loading graph from: ${file}`);
   }
@@ -21653,11 +21995,11 @@ async function runGraph(options) {
       });
       if (rendered) {
         releaseHost();
-        if (options.json) process.stdout.write(JSON.stringify({ status: "completed", graph: path13.resolve(file), ...rendered }) + "\n");
+        if (options2.json) process.stdout.write(JSON.stringify({ status: "completed", graph: path13.resolve(file), ...rendered }) + "\n");
         else console.log(`Rendered ${rendered.frames.length} frames, ${rendered.files.length} files -> ${out ?? "renders"}/`);
         return;
       }
-      if (options.json) throw new Error("--json rendering requires a fully definition-v1 graph");
+      if (options2.json) throw new Error("--json rendering requires a fully definition-v1 graph");
     } else if (await runDeterministicProjectGraph(file, graphData, entryNode)) {
       if (verbose) console.log("Graph execution completed");
       releaseHost();
@@ -21698,6 +22040,7 @@ async function runGraph(options) {
       }
     }
     graph.restoreConnections();
+    graph.markConnectionsSettled();
     const validation = graph.validate();
     if (validation.errors.length > 0) {
       console.error("Graph validation failed:");
@@ -21942,7 +22285,7 @@ image output nothing downstream consumes, or per output of --entry-node.
     console.error(`Error: File not found: ${fileArg}`);
     process.exit(1);
   }
-  const options = {
+  const options2 = {
     file: fileArg,
     validateOnly: command === "validate",
     checkOnly: command === "check",
@@ -21950,11 +22293,11 @@ image output nothing downstream consumes, or per output of --entry-node.
   };
   const verboseIndex = args.indexOf("--verbose") !== -1 ? args.indexOf("--verbose") : args.indexOf("-v");
   if (verboseIndex !== -1) {
-    options.verbose = true;
+    options2.verbose = true;
   }
   const entryNodeIndex = args.indexOf("--entry-node");
   if (entryNodeIndex !== -1 && args[entryNodeIndex + 1]) {
-    options.entryNode = args[entryNodeIndex + 1];
+    options2.entryNode = args[entryNodeIndex + 1];
   }
   const valueOf = (flag) => {
     const index = args.indexOf(flag);
@@ -21967,7 +22310,7 @@ image output nothing downstream consumes, or per output of --entry-node.
     return value;
   };
   const frames = valueOf("--frames");
-  if (frames) options.frames = frames;
+  if (frames) options2.frames = frames;
   const fps = valueOf("--fps");
   if (fps !== void 0) {
     const rate = Number(fps);
@@ -21975,13 +22318,13 @@ image output nothing downstream consumes, or per output of --entry-node.
       console.error(`Error: --fps must be a positive number (got "${fps}")`);
       process.exit(1);
     }
-    options.fps = rate;
+    options2.fps = rate;
   }
   const out = valueOf("--out");
-  if (out) options.out = out;
+  if (out) options2.out = out;
   if (args.includes("--json")) {
-    if (command !== "run" || !options.frames) throw new Error("--json requires run --frames (use --frames 1 for a still)");
-    options.json = true;
+    if (command !== "run" || !options2.frames) throw new Error("--json requires run --frames (use --frames 1 for a still)");
+    options2.json = true;
   }
   const timeout = valueOf("--timeout");
   if (timeout !== void 0) {
@@ -21996,11 +22339,11 @@ image output nothing downstream consumes, or per output of --entry-node.
     return;
   }
   try {
-    if (options.json) console.log = console.error;
-    await runGraph(options);
+    if (options2.json) console.log = console.error;
+    await runGraph(options2);
   } catch (error) {
     console.error(`Error: ${error.message}`);
-    if (options.verbose && error.stack) {
+    if (options2.verbose && error.stack) {
       console.error(error.stack);
     }
     process.exit(1);