@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-OWWBYLHC.js

@@ -0,0 +1,136 @@
+// packages/contracts/src/documentFormat.ts
+function formatCompactJSON(jsonString, indent = 2) {
+  let result = jsonString;
+  let previousResult = "";
+  while (result !== previousResult) {
+    previousResult = result;
+    result = formatCompactJSONPass(result, indent);
+  }
+  return result;
+}
+function formatCompactJSONPass(jsonString, indent = 2) {
+  const lines = jsonString.split("\n");
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed.endsWith("[") && (trimmed.includes(":") || trimmed === "[")) {
+      let arrayLines = [line];
+      let bracketDepth = 1;
+      let j = i + 1;
+      while (j < lines.length && bracketDepth > 0) {
+        const currentLine = lines[j];
+        arrayLines.push(currentLine);
+        for (const char of currentLine) {
+          if (char === "[") bracketDepth++;
+          if (char === "]") bracketDepth--;
+        }
+        j++;
+      }
+      const arrayContent = [];
+      let k = 1;
+      while (k < arrayLines.length - 1) {
+        const currentLine = arrayLines[k].trim();
+        if (currentLine.endsWith("[") || currentLine.startsWith("[") && !currentLine.endsWith("]")) {
+          let nestedArrayLines = [arrayLines[k]];
+          let nestedDepth = 1;
+          let m = k + 1;
+          while (m < arrayLines.length - 1 && nestedDepth > 0) {
+            nestedArrayLines.push(arrayLines[m]);
+            for (const char of arrayLines[m]) {
+              if (char === "[") nestedDepth++;
+              if (char === "]") nestedDepth--;
+            }
+            m++;
+          }
+          const nestedContent = [];
+          for (let n = 1; n < nestedArrayLines.length - 1; n++) {
+            const nestedLine = nestedArrayLines[n].trim().replace(/,$/, "").trim();
+            if (nestedLine) {
+              nestedContent.push(nestedLine);
+            }
+          }
+          const nestedArray = "[" + nestedContent.map((c) => c.trim()).join(", ") + "]";
+          arrayContent.push(nestedArray);
+          k = m;
+        } else {
+          const content = currentLine.replace(/,$/, "").trim();
+          if (content) {
+            arrayContent.push(content);
+          }
+          k++;
+        }
+      }
+      const isSmallNumericArray = arrayContent.length >= 2 && arrayContent.length <= 4 && arrayContent.every((item) => {
+        const trimmed2 = item.trim();
+        return /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(trimmed2);
+      });
+      let isArrayOfSmallArrays = false;
+      if (arrayContent.length >= 2 && arrayContent.length <= 20) {
+        const allAreArrays = arrayContent.every((item) => {
+          const trimmed2 = item.trim();
+          if (trimmed2.startsWith("[") && trimmed2.endsWith("]")) {
+            const inner = trimmed2.slice(1, -1).trim();
+            const parts = inner.split(",").map((p) => p.trim()).filter((p) => p);
+            return parts.length >= 2 && parts.length <= 4;
+          }
+          if (trimmed2.endsWith("[")) {
+            return true;
+          }
+          return false;
+        });
+        if (allAreArrays) {
+          let allSmall = true;
+          for (const item of arrayContent) {
+            const trimmed2 = item.trim();
+            if (trimmed2.startsWith("[") && trimmed2.endsWith("]")) {
+              const inner = trimmed2.slice(1, -1).trim();
+              const parts = inner.split(",").map((p) => p.trim()).filter((p) => p);
+              if (parts.length < 2 || parts.length > 4) {
+                allSmall = false;
+                break;
+              }
+            } else if (trimmed2.endsWith("[")) {
+            } else {
+              allSmall = false;
+              break;
+            }
+          }
+          isArrayOfSmallArrays = allSmall;
+        }
+      }
+      if (isSmallNumericArray || isArrayOfSmallArrays) {
+        const indentLevel = (line.match(/^(\s*)/)?.[1] || "").length;
+        const keyMatch = trimmed.match(/^(.+?)\s*\[\s*$/);
+        const keyPart = keyMatch ? keyMatch[1] : "";
+        const closingLine = arrayLines[arrayLines.length - 1];
+        const hasComma = closingLine.trim().endsWith(",");
+        let formattedContent;
+        if (isArrayOfSmallArrays) {
+          formattedContent = arrayContent.map((c) => {
+            const trimmed2 = c.trim();
+            if (trimmed2.startsWith("[") && trimmed2.endsWith("]")) {
+              return trimmed2;
+            }
+            return trimmed2;
+          }).join(", ");
+        } else {
+          formattedContent = arrayContent.map((c) => c.trim()).join(", ");
+        }
+        const compactArray = keyPart + " [" + formattedContent + "]" + (hasComma ? "," : "");
+        result.push(" ".repeat(indentLevel) + compactArray);
+        i = j;
+        continue;
+      }
+    }
+    result.push(line);
+    i++;
+  }
+  return result.join("\n");
+}
+
+export {
+  formatCompactJSON
+};
+//# sourceMappingURL=chunk-OWWBYLHC.js.map

package/dist/cli/chunk-QQPA2ZHH.js

@@ -0,0 +1,273 @@
+// 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;
+}
+var 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)
+};
+var DEG = Math.PI / 180;
+var 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 * DEG,
+  degrees: (a) => a / DEG,
+  /** 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)
+};
+var 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
+};
+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(" ");
+}
+var 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"
+    }
+  }
+};
+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));
+}
+var 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"
+    }
+  }
+};
+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));
+}
+var 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: {}
+};
+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));
+}
+var 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: {}
+};
+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)
+  );
+}
+var 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."
+    }
+  }
+};
+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, execute) {
+  return {
+    kind: "definition-v1",
+    moduleId: `cascade.math.${name}`,
+    definition,
+    loadExecute: async () => execute
+  };
+}
+var binaryRegistration = registration("Binary", binaryDefinition, executeBinary);
+var unaryRegistration = registration("Unary", unaryDefinition, executeUnary);
+var clampRegistration = registration("Clamp", clampDefinition, executeClamp);
+var mixRegistration = registration("Mix", mixDefinition, executeMix);
+var compareRegistration = registration("Compare", compareDefinition, executeCompare);
+var mathNodeRegistrations = Object.freeze([
+  binaryRegistration,
+  unaryRegistration,
+  clampRegistration,
+  mixRegistration,
+  compareRegistration
+]);
+var mathNodeDefinitions = Object.freeze([
+  ["cascade.math.Binary", binaryDefinition],
+  ["cascade.math.Unary", unaryDefinition],
+  ["cascade.math.Clamp", clampDefinition],
+  ["cascade.math.Mix", mixDefinition],
+  ["cascade.math.Compare", compareDefinition]
+]);
+
+export {
+  mathNodeRegistrations
+};
+//# sourceMappingURL=chunk-QQPA2ZHH.js.map

package/dist/cli/chunk-RUU3YWXU.js

@@ -0,0 +1,99 @@
+import {
+  ExpressionEvaluator,
+  parseBundleFieldPath
+} from "./chunk-CO22XHNG.js";
+
+// src/engine/expressions/ExpressionEngine.ts
+var ExpressionEngine = class extends ExpressionEvaluator {
+  constructor() {
+    super();
+    this.graph = null;
+    const scope = {
+      resolveParam: (from, path) => this.resolveNodePath(from, path),
+      nodeExists: (from, path) => from.node(path) !== null,
+      inputNode: (from, index) => this.resolveInput(from, index)
+    };
+    this.setScope(scope);
+  }
+  /**
+   * Set the graph reference for node lookups
+   */
+  setGraph(graph) {
+    this.graph = graph;
+  }
+  /**
+   * Resolve a path to get the parameter value
+   */
+  resolveNodePath(fromNode, path) {
+    const lastSlash = path.lastIndexOf("/");
+    if (lastSlash === -1 || path.startsWith("./")) {
+      const paramName2 = path.replace("./", "");
+      const prop2 = fromNode.props[paramName2];
+      if (prop2) return { value: prop2.value };
+      return this.resolveBundleField(fromNode, paramName2);
+    }
+    const nodePath = path.substring(0, lastSlash) || ".";
+    const paramName = path.substring(lastSlash + 1);
+    const targetNode = fromNode.node(nodePath);
+    if (!targetNode) return null;
+    const prop = targetNode.props[paramName];
+    return prop ? { value: prop.value } : null;
+  }
+  /**
+   * `format.dpi`: field `dpi` of the bundle wired into this node's `format`
+   * input. Read off the input port, so it is whatever the producer committed
+   * on its last cook, which the wire guarantees came first.
+   */
+  resolveBundleField(node, name) {
+    const reference = parseBundleFieldPath(name);
+    if (!reference) return null;
+    const port = node.inputs.find((input) => input.name === reference.port);
+    if (!port || port.dataType !== "bundle") return null;
+    const bundle = port.value;
+    if (bundle === null || typeof bundle !== "object") return null;
+    if (!Object.prototype.hasOwnProperty.call(bundle, reference.field)) return null;
+    return { value: bundle[reference.field] };
+  }
+  /**
+   * Get input node by index
+   */
+  resolveInput(node, index) {
+    if (!this.graph) return null;
+    const inputPort = node.inputs[index];
+    if (!inputPort || inputPort.connections.length === 0) return null;
+    const conn = inputPort.connections[0];
+    return this.graph.getNode(conn.from.nodeId);
+  }
+  /**
+   * Validate all expression paths in the graph
+   * Returns list of broken paths with their locations
+   */
+  validateAllPaths() {
+    if (!this.graph) return [];
+    const warnings = [];
+    for (const node of this.graph.nodes) {
+      for (const [propKey, prop] of Object.entries(node.props)) {
+        if (!prop.expression) continue;
+        const paths = this.extractDependencies(prop.expression);
+        for (const path of paths) {
+          if (!this.validatePath(node, path)) {
+            warnings.push({
+              nodeId: node.id,
+              nodePath: node.path(),
+              propName: propKey,
+              expression: prop.expression,
+              brokenPath: path
+            });
+          }
+        }
+      }
+    }
+    return warnings;
+  }
+};
+var expressionEngine = new ExpressionEngine();
+
+export {
+  expressionEngine
+};
+//# sourceMappingURL=chunk-RUU3YWXU.js.map

package/dist/cli/chunk-RXDIMXN5.js

@@ -0,0 +1,98 @@
+// packages/runtime/src/builtins/core/random.ts
+var randomDefinition = {
+  apiVersion: 1,
+  label: "Random",
+  description: "Generate a deterministic unit value from an explicit seed.",
+  icon: "Dice5",
+  runsOn: "portable",
+  inputs: {
+    seed: {
+      kind: "data",
+      type: "int",
+      default: 0,
+      description: "Integer seed. Equal seeds always produce equal values."
+    },
+    sample: {
+      kind: "data",
+      type: "int",
+      default: 0,
+      description: "Stable sample index within the seeded sequence."
+    }
+  },
+  outputs: {
+    value: {
+      kind: "data",
+      type: "float",
+      description: "Deterministic value in the half-open range [0, 1)."
+    }
+  }
+};
+function randomFromSeed(seed, sample = 0) {
+  const streamSeed = (Math.trunc(seed) ^ Math.imul(Math.trunc(sample), 2654435761)) >>> 0;
+  let value = streamSeed + 1831565813 >>> 0;
+  value = Math.imul(value ^ value >>> 15, value | 1);
+  value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+  return ((value ^ value >>> 14) >>> 0) / 4294967296;
+}
+function executeRandom(context) {
+  context.outputs.value.set(randomFromSeed(context.inputs.seed, context.inputs.sample));
+}
+var randomRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Random",
+  definition: randomDefinition,
+  loadExecute: async () => executeRandom
+};
+
+// packages/runtime/src/builtins/core/remap.ts
+var remapDefinition = {
+  apiVersion: 1,
+  label: "Remap",
+  description: "Map a number from one range into another.",
+  icon: "ArrowRightLeft",
+  runsOn: "portable",
+  inputs: {
+    value: { kind: "data", type: "float", default: 0 },
+    inMin: { kind: "data", type: "float", default: 0 },
+    inMax: { kind: "data", type: "float", default: 1 },
+    outMin: { kind: "data", type: "float", default: 0 },
+    outMax: { kind: "data", type: "float", default: 1 }
+  },
+  outputs: {
+    result: { kind: "data", type: "float" }
+  },
+  props: {
+    clamp: {
+      type: "bool",
+      default: false,
+      label: "Clamp",
+      description: "Keep the normalized input between zero and one."
+    }
+  }
+};
+function remap(value, inMin, inMax, outMin, outMax, clamp) {
+  if (inMin === inMax) return outMin;
+  const normalized = (value - inMin) / (inMax - inMin);
+  const amount = clamp ? Math.min(1, Math.max(0, normalized)) : normalized;
+  return outMin + amount * (outMax - outMin);
+}
+function executeRemap(context) {
+  const { value, inMin, inMax, outMin, outMax } = context.inputs;
+  context.outputs.result.set(
+    remap(value, inMin, inMax, outMin, outMax, context.props.clamp)
+  );
+}
+var remapRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Remap",
+  definition: remapDefinition,
+  loadExecute: async () => executeRemap
+};
+
+export {
+  randomFromSeed,
+  randomRegistration,
+  remap,
+  remapRegistration
+};
+//# sourceMappingURL=chunk-RXDIMXN5.js.map