@vizij/node-graph-authoring 0.0.2 → 0.0.5

package/dist/cli/reportIr.cjs

@@ -0,0 +1,4046 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli/reportIr.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/graphBuilder.ts
+var import_utils2 = require("@vizij/utils");
+var import_utils3 = require("@vizij/utils");
+
+// src/state.ts
+var import_utils = require("@vizij/utils");
+var VECTOR_ANIMATABLE_TYPES = /* @__PURE__ */ new Set(["vector2", "vector3", "euler", "rgb"]);
+function deriveComponentValueType(component) {
+  if (component.component) {
+    return "scalar";
+  }
+  return VECTOR_ANIMATABLE_TYPES.has(component.animatableType) ? "vector" : "scalar";
+}
+function isBindingValueType(value) {
+  return value === "scalar" || value === "vector";
+}
+function getTargetValueType(target) {
+  return isBindingValueType(target.valueType) ? target.valueType : "scalar";
+}
+function sanitizeSlotValueType(value, targetType) {
+  return isBindingValueType(value) ? value : targetType;
+}
+function bindingTargetFromComponent(component) {
+  return {
+    id: component.id,
+    defaultValue: component.defaultValue,
+    range: {
+      min: component.range.min,
+      max: component.range.max
+    },
+    valueType: deriveComponentValueType(component)
+  };
+}
+function bindingTargetFromInput(input) {
+  return {
+    id: input.id,
+    defaultValue: input.defaultValue,
+    range: {
+      min: input.range.min,
+      max: input.range.max
+    },
+    valueType: "scalar"
+  };
+}
+var DEFAULT_INPUT_RANGE = { min: -1, max: 1 };
+var DEFAULT_INPUT_ANCHOR = 0;
+var LEGACY_SLOT_PATTERN = /^slot_(\d+)$/i;
+var PRIMARY_SLOT_ID = "s1";
+var PRIMARY_SLOT_ALIAS = "s1";
+function defaultSlotId(index) {
+  return `s${index + 1}`;
+}
+function normalizeSlotId(value, index) {
+  if (value && value.length > 0) {
+    const match = value.match(LEGACY_SLOT_PATTERN);
+    if (match) {
+      const suffix = match[1] ?? String(index + 1);
+      return `s${suffix}`;
+    }
+    return value;
+  }
+  return defaultSlotId(index);
+}
+function normalizeSlotAlias(value, fallback, index) {
+  if (value && value.length > 0) {
+    const match = value.match(LEGACY_SLOT_PATTERN);
+    if (match) {
+      const suffix = match[1] ?? String(index + 1);
+      return { alias: `s${suffix}`, replaced: value };
+    }
+    return { alias: value, replaced: null };
+  }
+  if (fallback && fallback.length > 0) {
+    return { alias: fallback, replaced: null };
+  }
+  return { alias: defaultSlotId(index), replaced: null };
+}
+function rewriteLegacyExpression(expression, replacements) {
+  if (expression.trim().length === 0) {
+    return expression;
+  }
+  return expression.replace(/\bslot_(\d+)\b/gi, (match, digits) => {
+    const replacement = replacements.get(match);
+    if (replacement) {
+      return replacement;
+    }
+    return `s${digits}`;
+  });
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function deriveOutputDefaults(target) {
+  const { min, max } = target.range;
+  const anchor = clamp(target.defaultValue, min, max);
+  return {
+    outLow: min,
+    outAnchor: anchor,
+    outHigh: max
+  };
+}
+function deriveInputDefaults() {
+  return {
+    inLow: DEFAULT_INPUT_RANGE.min,
+    inAnchor: DEFAULT_INPUT_ANCHOR,
+    inHigh: DEFAULT_INPUT_RANGE.max
+  };
+}
+function migrateLegacyRemap(legacy, target) {
+  const inputDefaults = deriveInputDefaults();
+  const outputDefaults = deriveOutputDefaults(target);
+  const defaults = {
+    inLow: inputDefaults.inLow,
+    inAnchor: inputDefaults.inAnchor,
+    inHigh: inputDefaults.inHigh,
+    outLow: outputDefaults.outLow,
+    outAnchor: outputDefaults.outAnchor,
+    outHigh: outputDefaults.outHigh
+  };
+  if ("inLow" in legacy && "inHigh" in legacy && "outLow" in legacy && "outHigh" in legacy) {
+    const inLow2 = isFiniteNumber(legacy.inLow) ? legacy.inLow : defaults.inLow;
+    const inAnchor2 = isFiniteNumber(legacy.inAnchor) ? legacy.inAnchor : defaults.inAnchor;
+    const inHigh2 = isFiniteNumber(legacy.inHigh) ? legacy.inHigh : defaults.inHigh;
+    let outLow = isFiniteNumber(legacy.outLow) ? legacy.outLow : defaults.outLow;
+    let outHigh = isFiniteNumber(legacy.outHigh) ? legacy.outHigh : defaults.outHigh;
+    if (outLow > outHigh) {
+      const low = outHigh;
+      const high = outLow;
+      outLow = low;
+      outHigh = high;
+    }
+    const outAnchor2 = clamp(
+      isFiniteNumber(legacy.outAnchor) ? legacy.outAnchor : defaults.outAnchor,
+      outLow,
+      outHigh
+    );
+    return {
+      inLow: inLow2,
+      inAnchor: inAnchor2,
+      inHigh: inHigh2,
+      outLow,
+      outAnchor: outAnchor2,
+      outHigh
+    };
+  }
+  const legacyTyped = legacy;
+  const inLow = isFiniteNumber(legacyTyped.inMin) ? legacyTyped.inMin : defaults.inLow;
+  const inHigh = isFiniteNumber(legacyTyped.inMax) ? legacyTyped.inMax : defaults.inHigh;
+  const inAnchor = (inLow + inHigh) / 2;
+  const legacyOutMid = isFiniteNumber(legacyTyped.outMin) && isFiniteNumber(legacyTyped.outMax) ? (legacyTyped.outMin + legacyTyped.outMax) / 2 : defaults.outAnchor;
+  const outAnchor = clamp(legacyOutMid, defaults.outLow, defaults.outHigh);
+  return {
+    inLow,
+    inAnchor,
+    inHigh,
+    outLow: defaults.outLow,
+    outAnchor,
+    outHigh: defaults.outHigh
+  };
+}
+function normalizeRemap(remap, target) {
+  if (!remap) {
+    return createDefaultRemap(target);
+  }
+  return migrateLegacyRemap(remap, target);
+}
+function cloneRemap(remap) {
+  return (0, import_utils.cloneRemapSettings)(remap);
+}
+function sanitizeRemap(remap, target) {
+  const normalized = normalizeRemap(remap, target);
+  const outputDefaults = deriveOutputDefaults(target);
+  if (!Number.isFinite(normalized.outLow)) {
+    normalized.outLow = outputDefaults.outLow;
+  }
+  if (!Number.isFinite(normalized.outHigh)) {
+    normalized.outHigh = outputDefaults.outHigh;
+  }
+  if (!Number.isFinite(normalized.outAnchor)) {
+    normalized.outAnchor = outputDefaults.outAnchor;
+  }
+  if (normalized.outLow > normalized.outHigh) {
+    const low = normalized.outHigh;
+    const high = normalized.outLow;
+    normalized.outLow = low;
+    normalized.outHigh = high;
+  }
+  normalized.outAnchor = clamp(
+    normalized.outAnchor,
+    normalized.outLow,
+    normalized.outHigh
+  );
+  return normalized;
+}
+function createDefaultRemap(target) {
+  const inputDefaults = deriveInputDefaults();
+  const outputDefaults = deriveOutputDefaults(target);
+  return {
+    inLow: inputDefaults.inLow,
+    inAnchor: inputDefaults.inAnchor,
+    inHigh: inputDefaults.inHigh,
+    outLow: outputDefaults.outLow,
+    outAnchor: outputDefaults.outAnchor,
+    outHigh: outputDefaults.outHigh
+  };
+}
+function ensurePrimarySlot(binding, target) {
+  const normalizedBindingRemap = sanitizeRemap(binding.remap, target);
+  const targetValueType = getTargetValueType(target);
+  const aliasReplacements = /* @__PURE__ */ new Map();
+  const sourceSlots = Array.isArray(binding.slots) && binding.slots.length > 0 ? binding.slots : [
+    {
+      id: PRIMARY_SLOT_ID,
+      alias: PRIMARY_SLOT_ALIAS,
+      inputId: binding.inputId ?? null,
+      remap: cloneRemap(normalizedBindingRemap),
+      valueType: targetValueType
+    }
+  ];
+  const normalizedSlots = sourceSlots.map(
+    (slot, index) => {
+      const normalizedId = normalizeSlotId(slot.id, index);
+      const { alias: normalizedAlias, replaced } = normalizeSlotAlias(
+        slot.alias,
+        normalizedId,
+        index
+      );
+      if (replaced && replaced !== normalizedAlias) {
+        aliasReplacements.set(replaced, normalizedAlias);
+      }
+      const slotRemapSource = slot.remap ?? (index === 0 ? normalizedBindingRemap : createDefaultRemap(target));
+      const normalizedSlotRemap = sanitizeRemap(slotRemapSource, target);
+      const inputId = slot.inputId !== void 0 && slot.inputId !== null ? slot.inputId : index === 0 ? binding.inputId ?? null : null;
+      const slotValueType = sanitizeSlotValueType(
+        slot.valueType,
+        targetValueType
+      );
+      return {
+        id: normalizedId,
+        alias: normalizedAlias,
+        inputId,
+        remap: cloneRemap(normalizedSlotRemap),
+        valueType: slotValueType
+      };
+    }
+  );
+  const primary = normalizedSlots[0];
+  const primaryRemap = sanitizeRemap(primary.remap, target);
+  const primaryInputId = primary.inputId === import_utils.SELF_BINDING_ID ? import_utils.SELF_BINDING_ID : primary.inputId ?? binding.inputId ?? null;
+  const primaryAlias = primaryInputId === import_utils.SELF_BINDING_ID ? "self" : primary.alias || PRIMARY_SLOT_ALIAS;
+  normalizedSlots[0] = {
+    ...primary,
+    id: primary.id || PRIMARY_SLOT_ID,
+    alias: primaryAlias,
+    inputId: primaryInputId,
+    remap: cloneRemap(primaryRemap),
+    valueType: sanitizeSlotValueType(primary.valueType, targetValueType)
+  };
+  normalizedSlots.slice(1).forEach((slot, index) => {
+    const slotRemap = sanitizeRemap(slot.remap, target);
+    normalizedSlots[index + 1] = {
+      ...slot,
+      id: slot.id || defaultSlotId(index + 1),
+      alias: slot.alias || defaultSlotId(index + 1),
+      remap: cloneRemap(slotRemap),
+      valueType: sanitizeSlotValueType(slot.valueType, targetValueType)
+    };
+  });
+  const rawExpression = typeof binding.expression === "string" ? binding.expression.trim() : "";
+  const canonicalExpression = buildCanonicalExpressionFromSlots(normalizedSlots);
+  let expression;
+  if (expressionMatchesAliasOnly(rawExpression, normalizedSlots)) {
+    expression = canonicalExpression;
+  } else {
+    expression = rewriteLegacyExpression(rawExpression, aliasReplacements);
+  }
+  const normalizedBinding = {
+    ...binding,
+    inputId: normalizedSlots[0].inputId ?? null,
+    remap: cloneRemap(primaryRemap),
+    slots: normalizedSlots,
+    expression
+  };
+  return normalizedBinding;
+}
+function ensureBindingStructure(binding, target) {
+  return ensurePrimarySlot(binding, target);
+}
+function sanitizeLiteral(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (Object.is(value, -0)) {
+    return 0;
+  }
+  return value;
+}
+function formatVectorLiteral(values) {
+  return `vec(${values.map((value) => sanitizeLiteral(value)).join(", ")})`;
+}
+function buildPiecewiseRemapExpression(alias, remap) {
+  const sanitizedAlias = alias && alias.trim().length > 0 ? alias.trim() : PRIMARY_SLOT_ALIAS;
+  const inputBreakpoints = [remap.inLow, remap.inAnchor, remap.inHigh];
+  const outputBreakpoints = [remap.outLow, remap.outAnchor, remap.outHigh];
+  return `piecewise_remap(${sanitizedAlias}, ${formatVectorLiteral(
+    inputBreakpoints
+  )}, ${formatVectorLiteral(outputBreakpoints)})`;
+}
+function isSelfAlias(alias) {
+  return alias.trim().toLowerCase() === "self";
+}
+function buildDefaultSlotExpression(alias, inputId, remap) {
+  const sanitizedAlias = alias && alias.trim().length > 0 ? alias.trim() : PRIMARY_SLOT_ALIAS;
+  if (inputId === import_utils.SELF_BINDING_ID || isSelfAlias(sanitizedAlias)) {
+    return sanitizedAlias;
+  }
+  return buildPiecewiseRemapExpression(sanitizedAlias, remap);
+}
+function normalizeSlotAliasForExpression(slot, index) {
+  if (slot.alias && slot.alias.trim().length > 0) {
+    return slot.alias.trim();
+  }
+  if (slot.id && slot.id.trim().length > 0) {
+    return slot.id.trim();
+  }
+  return defaultSlotId(index);
+}
+function buildAliasOnlyExpression(slots) {
+  if (!slots.length) {
+    return PRIMARY_SLOT_ALIAS;
+  }
+  return slots.map((slot, index) => normalizeSlotAliasForExpression(slot, index)).join(" + ");
+}
+function buildCanonicalExpressionFromSlots(slots) {
+  if (!slots.length) {
+    return PRIMARY_SLOT_ALIAS;
+  }
+  return slots.map(
+    (slot, index) => buildDefaultSlotExpression(
+      normalizeSlotAliasForExpression(slot, index),
+      slot.inputId ?? null,
+      slot.remap
+    )
+  ).join(" + ");
+}
+function expressionsEquivalent(left, right) {
+  return left.trim() === right.trim();
+}
+function expressionMatchesAliasOnly(expression, slots) {
+  if (expression.trim().length === 0) {
+    return true;
+  }
+  const aliasOnly = buildAliasOnlyExpression(slots);
+  return expressionsEquivalent(expression, aliasOnly);
+}
+
+// src/expression.ts
+var STANDARD_WHITESPACE = /\s/;
+var EXTRA_WHITESPACE_CHARS = /* @__PURE__ */ new Set(["\0", "\u200B", "\uFEFF"]);
+function isWhitespaceCharacter(char) {
+  if (!char) {
+    return false;
+  }
+  return STANDARD_WHITESPACE.test(char) || EXTRA_WHITESPACE_CHARS.has(char);
+}
+var IDENT_START = /[A-Za-z_]/;
+var IDENT_PART = /[A-Za-z0-9_]/;
+var DIGIT = /[0-9]/;
+var ControlExpressionParser = class {
+  constructor(input) {
+    this.input = input;
+    this.index = 0;
+    this.errors = [];
+  }
+  parse() {
+    this.skipWhitespace();
+    const node = this.parseExpression();
+    this.skipWhitespace();
+    if (!node) {
+      if (this.errors.length === 0) {
+        this.errors.push({
+          index: this.index,
+          message: "Empty expression."
+        });
+      }
+      return { node: null, errors: this.errors };
+    }
+    if (!this.isAtEnd()) {
+      this.errors.push({
+        index: this.index,
+        message: `Unexpected token "${this.peek()}"`
+      });
+      return { node: null, errors: this.errors };
+    }
+    return { node, errors: this.errors };
+  }
+  parseExpression() {
+    return this.parseLogicalOr();
+  }
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    if (!left) {
+      return null;
+    }
+    while (true) {
+      this.skipWhitespace();
+      const operator = this.matchAny(["||"]);
+      if (!operator) {
+        break;
+      }
+      const right = this.parseLogicalAnd();
+      if (!right) {
+        this.errors.push({
+          index: this.index,
+          message: "Expected expression after operator."
+        });
+        return null;
+      }
+      left = {
+        type: "Binary",
+        operator,
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseLogicalAnd() {
+    let left = this.parseComparison();
+    if (!left) {
+      return null;
+    }
+    while (true) {
+      this.skipWhitespace();
+      const operator = this.matchAny(["&&"]);
+      if (!operator) {
+        break;
+      }
+      const right = this.parseComparison();
+      if (!right) {
+        this.errors.push({
+          index: this.index,
+          message: "Expected expression after operator."
+        });
+        return null;
+      }
+      left = {
+        type: "Binary",
+        operator,
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseComparison() {
+    let left = this.parseAdditive();
+    if (!left) {
+      return null;
+    }
+    while (true) {
+      this.skipWhitespace();
+      if (this.input.startsWith(">=", this.index) || this.input.startsWith("<=", this.index)) {
+        const op = this.input.slice(this.index, this.index + 2);
+        this.index += 2;
+        this.errors.push({
+          index: this.index - 2,
+          message: `Operator "${op}" is not supported.`
+        });
+        return null;
+      }
+      const operator = this.matchAny(["==", "!=", ">", "<"]);
+      if (!operator) {
+        break;
+      }
+      const right = this.parseAdditive();
+      if (!right) {
+        this.errors.push({
+          index: this.index,
+          message: "Expected expression after operator."
+        });
+        return null;
+      }
+      left = {
+        type: "Binary",
+        operator,
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    if (!left) {
+      return null;
+    }
+    while (true) {
+      this.skipWhitespace();
+      const operator = this.peek();
+      if (operator !== "+" && operator !== "-") {
+        break;
+      }
+      this.index += 1;
+      const right = this.parseMultiplicative();
+      if (!right) {
+        this.errors.push({
+          index: this.index,
+          message: "Expected expression after operator."
+        });
+        return null;
+      }
+      left = {
+        type: "Binary",
+        operator,
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    if (!left) {
+      return null;
+    }
+    while (true) {
+      this.skipWhitespace();
+      const operator = this.peek();
+      if (operator !== "*" && operator !== "/") {
+        break;
+      }
+      this.index += 1;
+      const right = this.parseUnary();
+      if (!right) {
+        this.errors.push({
+          index: this.index,
+          message: "Expected expression after operator."
+        });
+        return null;
+      }
+      left = {
+        type: "Binary",
+        operator,
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseUnary() {
+    this.skipWhitespace();
+    const char = this.peek();
+    if (!char) {
+      this.errors.push({
+        index: this.index,
+        message: "Unexpected end of expression."
+      });
+      return null;
+    }
+    if (char === "+" || char === "-" || char === "!") {
+      this.index += 1;
+      const operand = this.parseUnary();
+      if (!operand) {
+        this.errors.push({
+          index: this.index,
+          message: `Expected operand after unary "${char}".`
+        });
+        return null;
+      }
+      return {
+        type: "Unary",
+        operator: char,
+        operand
+      };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    this.skipWhitespace();
+    const char = this.peek();
+    if (!char) {
+      this.errors.push({
+        index: this.index,
+        message: "Unexpected end of expression."
+      });
+      return null;
+    }
+    if (char === "(") {
+      this.index += 1;
+      const expression = this.parseExpression();
+      this.skipWhitespace();
+      if (this.peek() === ")") {
+        this.index += 1;
+        return expression;
+      }
+      this.errors.push({
+        index: this.index,
+        message: "Unmatched parenthesis."
+      });
+      return null;
+    }
+    if (char === "[") {
+      this.index += 1;
+      return this.parseVectorLiteral("]", "vector literal");
+    }
+    if (IDENT_START.test(char)) {
+      return this.parseIdentifierOrFunction();
+    }
+    if (DIGIT.test(char) || char === ".") {
+      return this.parseNumber();
+    }
+    this.errors.push({
+      index: this.index,
+      message: `Unexpected character "${char}".`
+    });
+    return null;
+  }
+  parseIdentifierOrFunction() {
+    const start = this.index;
+    while (!this.isAtEnd() && IDENT_PART.test(this.peek())) {
+      this.index += 1;
+    }
+    const name = this.input.slice(start, this.index);
+    if (!name) {
+      this.errors.push({
+        index: start,
+        message: "Invalid identifier."
+      });
+      return null;
+    }
+    this.skipWhitespace();
+    if (this.peek() === "(") {
+      this.index += 1;
+      if (name.toLowerCase() === "vec") {
+        return this.parseVectorLiteral(")", `"${name}" literal`);
+      }
+      const args = [];
+      this.skipWhitespace();
+      if (this.peek() === ")") {
+        this.index += 1;
+        return {
+          type: "Function",
+          name,
+          args
+        };
+      }
+      while (true) {
+        const argument = this.parseExpression();
+        if (!argument) {
+          this.errors.push({
+            index: this.index,
+            message: `Expected expression for argument ${args.length + 1} of "${name}".`
+          });
+          return null;
+        }
+        args.push(argument);
+        this.skipWhitespace();
+        const next = this.peek();
+        if (next === ",") {
+          this.index += 1;
+          this.skipWhitespace();
+          if (this.peek() === ")") {
+            this.errors.push({
+              index: this.index,
+              message: `Expected expression after "," in call to "${name}".`
+            });
+            return null;
+          }
+          continue;
+        }
+        if (next === ")") {
+          this.index += 1;
+          break;
+        }
+        if (next === null) {
+          this.errors.push({
+            index: this.index,
+            message: `Unterminated call to "${name}".`
+          });
+        } else {
+          this.errors.push({
+            index: this.index,
+            message: `Expected "," or ")" in call to "${name}".`
+          });
+        }
+        return null;
+      }
+      return {
+        type: "Function",
+        name,
+        args
+      };
+    }
+    return {
+      type: "Reference",
+      name
+    };
+  }
+  parseVectorLiteral(terminator, context) {
+    const values = this.parseVectorLiteralValues(terminator, context);
+    if (!values) {
+      return null;
+    }
+    return {
+      type: "VectorLiteral",
+      values
+    };
+  }
+  parseVectorLiteralValues(terminator, context) {
+    const values = [];
+    this.skipWhitespace();
+    if (this.peek() === terminator) {
+      this.errors.push({
+        index: this.index,
+        message: `Expected at least one value in ${context}.`
+      });
+      return null;
+    }
+    while (true) {
+      this.skipWhitespace();
+      const literalValue = this.parseNumericLiteralValue();
+      if (literalValue === null) {
+        this.errors.push({
+          index: this.index,
+          message: `Expected numeric literal in ${context}.`
+        });
+        return null;
+      }
+      values.push(literalValue);
+      this.skipWhitespace();
+      const next = this.peek();
+      if (next === ",") {
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.peek() === terminator) {
+          this.errors.push({
+            index: this.index,
+            message: `Expected value after "," in ${context}.`
+          });
+          return null;
+        }
+        continue;
+      }
+      if (next === terminator) {
+        this.index += 1;
+        break;
+      }
+      if (next === null) {
+        this.errors.push({
+          index: this.index,
+          message: `Unterminated ${context}.`
+        });
+      } else {
+        this.errors.push({
+          index: this.index,
+          message: `Expected "," or "${terminator}" in ${context}.`
+        });
+      }
+      return null;
+    }
+    if (values.length === 0) {
+      this.errors.push({
+        index: this.index,
+        message: `Expected at least one value in ${context}.`
+      });
+      return null;
+    }
+    return values;
+  }
+  parseNumericLiteralValue(allowLeadingSign = true) {
+    const start = this.index;
+    if (allowLeadingSign && (this.peek() === "+" || this.peek() === "-")) {
+      this.index += 1;
+    }
+    let hasDigits = false;
+    let seenDecimal = false;
+    let seenExponent = false;
+    let exponentDigits = false;
+    let inExponent = false;
+    while (!this.isAtEnd()) {
+      const char = this.peek();
+      if (DIGIT.test(char)) {
+        hasDigits = true;
+        if (inExponent) {
+          exponentDigits = true;
+        }
+        this.index += 1;
+        continue;
+      }
+      if (char === "." && !seenDecimal && !seenExponent) {
+        seenDecimal = true;
+        this.index += 1;
+        continue;
+      }
+      if ((char === "e" || char === "E") && !seenExponent && hasDigits) {
+        seenExponent = true;
+        inExponent = true;
+        exponentDigits = false;
+        this.index += 1;
+        const sign = this.peek();
+        if (sign === "+" || sign === "-") {
+          this.index += 1;
+        }
+        continue;
+      }
+      break;
+    }
+    if (!hasDigits || seenExponent && !exponentDigits) {
+      this.index = start;
+      return null;
+    }
+    const raw = this.input.slice(start, this.index);
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+      this.index = start;
+      return null;
+    }
+    return value;
+  }
+  parseNumber() {
+    const start = this.index;
+    const value = this.parseNumericLiteralValue(false);
+    if (value === null) {
+      this.errors.push({
+        index: start,
+        message: "Invalid numeric literal."
+      });
+      return null;
+    }
+    return {
+      type: "Literal",
+      value
+    };
+  }
+  matchAny(operators) {
+    for (const operator of operators) {
+      if (this.input.startsWith(operator, this.index)) {
+        this.index += operator.length;
+        return operator;
+      }
+    }
+    return null;
+  }
+  skipWhitespace() {
+    while (!this.isAtEnd()) {
+      const char = this.peek();
+      if (!isWhitespaceCharacter(char)) {
+        break;
+      }
+      this.index += 1;
+    }
+  }
+  peek() {
+    if (this.index >= this.input.length) {
+      return null;
+    }
+    return this.input[this.index] ?? null;
+  }
+  isAtEnd() {
+    return this.index >= this.input.length;
+  }
+};
+function parseControlExpression(expression) {
+  const parser = new ControlExpressionParser(expression);
+  return parser.parse();
+}
+function collectExpressionReferences(node, target = /* @__PURE__ */ new Set()) {
+  if (!node) {
+    return target;
+  }
+  switch (node.type) {
+    case "Reference":
+      target.add(node.name);
+      break;
+    case "Unary":
+      collectExpressionReferences(node.operand, target);
+      break;
+    case "Binary":
+      collectExpressionReferences(node.left, target);
+      collectExpressionReferences(node.right, target);
+      break;
+    case "Function":
+      node.args.forEach((arg) => collectExpressionReferences(arg, target));
+      break;
+    default:
+      break;
+  }
+  return target;
+}
+
+// src/expressionFunctions.ts
+var import_metadata = require("@vizij/node-graph-wasm/metadata");
+var FUNCTION_OVERRIDES = {
+  case: {
+    replaceInputs: [
+      { id: "selector", optional: false, valueType: "any" },
+      { id: "default", optional: false, valueType: "any" }
+    ],
+    variadic: { id: "operand", min: 1, max: null, valueType: "any" },
+    minArgs: 3,
+    maxArgs: null,
+    params: []
+  },
+  slew: {
+    dropTrailingInputs: 1,
+    params: [
+      {
+        id: "max_rate",
+        label: "max_rate",
+        optional: false,
+        valueType: "scalar"
+      }
+    ],
+    minArgs: 2,
+    maxArgs: 2
+  }
+};
+var FUNCTION_CONFIGS = [
+  {
+    typeId: "sin",
+    names: ["sin"],
+    category: "math",
+    description: "Sine of the input value (radians)."
+  },
+  {
+    typeId: "cos",
+    names: ["cos"],
+    category: "math",
+    description: "Cosine of the input value (radians)."
+  },
+  {
+    typeId: "tan",
+    names: ["tan"],
+    category: "math",
+    description: "Tangent of the input value (radians)."
+  },
+  {
+    typeId: "power",
+    names: ["power", "pow"],
+    category: "math",
+    description: "Raise a base value to an exponent."
+  },
+  {
+    typeId: "log",
+    names: ["log"],
+    category: "math",
+    description: "Logarithm of the input value."
+  },
+  {
+    typeId: "clamp",
+    names: ["clamp"],
+    category: "utility",
+    description: "Clamp an input between min/max."
+  },
+  {
+    typeId: "remap",
+    names: ["remap"],
+    category: "utility",
+    description: "Linearly map a value from the input range to the output range."
+  },
+  {
+    typeId: "centered_remap",
+    names: ["centeredremap", "centered_remap"],
+    category: "utility",
+    description: "Remap a value using in/out ranges that include explicit anchors."
+  },
+  {
+    typeId: "piecewise_remap",
+    names: ["piecewiseremap", "piecewise_remap"],
+    category: "utility",
+    description: "Map a value through piecewise-linear breakpoints."
+  },
+  {
+    typeId: "abs",
+    names: ["abs"],
+    category: "math",
+    description: "Absolute value of the input."
+  },
+  {
+    typeId: "add",
+    names: ["add"],
+    category: "math",
+    description: "Sum all operands together."
+  },
+  {
+    typeId: "multiply",
+    names: ["multiply"],
+    category: "math",
+    description: "Multiply operands together."
+  },
+  {
+    typeId: "subtract",
+    names: ["subtract"],
+    category: "math",
+    description: "Subtract rhs from lhs."
+  },
+  {
+    typeId: "divide",
+    names: ["divide"],
+    category: "math",
+    description: "Divide lhs by rhs."
+  },
+  {
+    typeId: "min",
+    names: ["min"],
+    category: "math",
+    description: "Minimum of all operands."
+  },
+  {
+    typeId: "max",
+    names: ["max"],
+    category: "math",
+    description: "Maximum of all operands."
+  },
+  {
+    typeId: "modulo",
+    names: ["modulo", "mod"],
+    category: "math",
+    description: "Modulo of lhs by rhs."
+  },
+  {
+    typeId: "greaterthan",
+    names: ["greaterthan", "gt"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Return true when lhs > rhs."
+  },
+  {
+    typeId: "lessthan",
+    names: ["lessthan", "lt"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Return true when lhs < rhs."
+  },
+  {
+    typeId: "equal",
+    names: ["equal", "eq"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Return true when operands are equal."
+  },
+  {
+    typeId: "notequal",
+    names: ["notequal", "neq", "ne"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Return true when operands differ."
+  },
+  {
+    typeId: "and",
+    names: ["and"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Logical AND."
+  },
+  {
+    typeId: "or",
+    names: ["or"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Logical OR."
+  },
+  {
+    typeId: "xor",
+    names: ["xor"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "logic",
+    description: "Logical XOR."
+  },
+  {
+    typeId: "not",
+    names: ["not"],
+    minArgs: 1,
+    maxArgs: 1,
+    category: "logic",
+    description: "Logical NOT of input."
+  },
+  {
+    typeId: "if",
+    names: ["if"],
+    minArgs: 2,
+    maxArgs: 3,
+    category: "logic",
+    description: "Conditional branch with optional fallback."
+  },
+  {
+    typeId: "round",
+    names: ["round"],
+    category: "math",
+    description: "Round input using the configured mode (floor/ceil/trunc)."
+  },
+  {
+    typeId: "case",
+    names: ["case"],
+    minArgs: 3,
+    category: "logic",
+    description: "Route the selector value to matching labeled branches."
+  },
+  {
+    typeId: "time",
+    names: ["time"],
+    minArgs: 0,
+    maxArgs: 0,
+    category: "time",
+    description: "Graph time in seconds."
+  },
+  {
+    typeId: "oscillator",
+    names: ["oscillator"],
+    minArgs: 2,
+    maxArgs: 2,
+    category: "time",
+    description: "Sine/cosine oscillator driven by time."
+  },
+  {
+    typeId: "spring",
+    names: ["spring"],
+    category: "time",
+    description: "Spring toward the target with configurable stiffness and damping."
+  },
+  {
+    typeId: "damp",
+    names: ["damp"],
+    category: "time",
+    description: "Damp input values toward zero at the specified rate."
+  },
+  {
+    typeId: "slew",
+    names: ["slew"],
+    category: "time",
+    description: "Limit the rate of change between inputs over time."
+  },
+  {
+    typeId: "default-blend",
+    names: ["defaultblend", "blend"],
+    category: "utility",
+    description: "Blend operand values using optional baseline/offset and weight inputs."
+  },
+  {
+    typeId: "blendweightedaverage",
+    names: ["blendweightedaverage"],
+    category: "utility",
+    description: "Compute weighted average blends using aggregate sums."
+  },
+  {
+    typeId: "blendadditive",
+    names: ["blendadditive"],
+    category: "utility",
+    description: "Additive blending helper."
+  },
+  {
+    typeId: "blendmultiply",
+    names: ["blendmultiply"],
+    category: "utility",
+    description: "Multiplicative blending helper."
+  },
+  {
+    typeId: "blendweightedoverlay",
+    names: ["blendweightedoverlay"],
+    category: "utility",
+    description: "Overlay blending helper driven by weighted sums."
+  },
+  {
+    typeId: "blendweightedaverageoverlay",
+    names: ["blendweightedaverageoverlay"],
+    category: "utility",
+    description: "Overlay helper that adds averaged deltas to the base value."
+  },
+  {
+    typeId: "blendmax",
+    names: ["blendmax"],
+    category: "utility",
+    description: "Select the operand whose effective weight is largest."
+  },
+  {
+    typeId: "vec3cross",
+    names: ["vec3cross", "cross"],
+    category: "vector",
+    description: "Cross product of vectors A \xD7 B."
+  },
+  {
+    typeId: "vectoradd",
+    names: ["vectoradd", "vadd"],
+    category: "vector",
+    description: "Element-wise sum of vectors."
+  },
+  {
+    typeId: "vectorsubtract",
+    names: ["vectorsubtract", "vsub"],
+    category: "vector",
+    description: "Element-wise subtraction of vectors."
+  },
+  {
+    typeId: "vectormultiply",
+    names: ["vectormultiply", "vmul"],
+    category: "vector",
+    description: "Element-wise multiplication of vectors."
+  },
+  {
+    typeId: "vectorscale",
+    names: ["vectorscale", "vscale"],
+    category: "vector",
+    description: "Scale a vector by a scalar value."
+  },
+  {
+    typeId: "vectornormalize",
+    names: ["vectornormalize", "vnormalize"],
+    category: "vector",
+    description: "Normalize a vector to unit length."
+  },
+  {
+    typeId: "vectordot",
+    names: ["vectordot", "vdot"],
+    category: "vector",
+    description: "Dot product of vectors A \xB7 B."
+  },
+  {
+    typeId: "vectorlength",
+    names: ["vectorlength", "vlength"],
+    category: "vector",
+    description: "Euclidean length of a vector."
+  },
+  {
+    typeId: "vectorindex",
+    names: ["vectorindex", "vindex"],
+    category: "vector",
+    description: "Extract a component from a vector."
+  },
+  {
+    typeId: "vectorconstant",
+    names: ["vectorconstant", "vconst"],
+    category: "vector",
+    description: "Constant vector value."
+  },
+  {
+    typeId: "join",
+    names: ["join"],
+    category: "vector",
+    description: "Join scalar inputs into a vector."
+  },
+  {
+    typeId: "split",
+    names: ["split"],
+    category: "vector",
+    description: "Split a vector into scalar outputs."
+  },
+  {
+    typeId: "vectormin",
+    names: ["vectormin"],
+    category: "vector",
+    description: "Minimum component in a vector."
+  },
+  {
+    typeId: "vectormax",
+    names: ["vectormax"],
+    category: "vector",
+    description: "Maximum component in a vector."
+  },
+  {
+    typeId: "vectormean",
+    names: ["vectormean"],
+    category: "vector",
+    description: "Mean of the provided vector values."
+  },
+  {
+    typeId: "vectormedian",
+    names: ["vectormedian"],
+    category: "vector",
+    description: "Median of the provided vector values."
+  },
+  {
+    typeId: "vectormode",
+    names: ["vectormode"],
+    category: "vector",
+    description: "Mode of the provided vector values."
+  },
+  {
+    typeId: "weightedsumvector",
+    names: ["weightedsumvector", "vectorsum"],
+    category: "vector",
+    description: "Weighted sum across vectors with optional masks."
+  }
+];
+var SCALAR_FUNCTIONS = /* @__PURE__ */ new Map();
+var SCALAR_FUNCTION_VOCABULARY = [];
+for (const config of FUNCTION_CONFIGS) {
+  const signature = (0, import_metadata.requireNodeSignature)(config.typeId);
+  const signatureInputs = signature.inputs;
+  let inputs = signatureInputs.map((input) => ({
+    id: input.id,
+    optional: Boolean(input.optional),
+    valueType: inferExpressionValueType(input.ty)
+  }));
+  let variadic = signature.variadic_inputs ? {
+    id: signature.variadic_inputs.id,
+    min: signature.variadic_inputs.min,
+    max: typeof signature.variadic_inputs.max === "number" ? signature.variadic_inputs.max : null,
+    valueType: inferExpressionValueType(signature.variadic_inputs.ty)
+  } : null;
+  const baseRequiredInputs = inputs.filter((input) => !input.optional).length;
+  const variadicMin = variadic?.min ?? 0;
+  const derivedMin = baseRequiredInputs + variadicMin;
+  let derivedMax;
+  if (variadic) {
+    derivedMax = variadic.max === null ? null : inputs.length + (variadic.max ?? 0);
+  } else {
+    derivedMax = inputs.length;
+  }
+  let params = buildParamArgumentSpecs(signature);
+  const override = FUNCTION_OVERRIDES[config.typeId];
+  if (override) {
+    if (override.replaceInputs) {
+      inputs = override.replaceInputs.map((input) => ({ ...input }));
+    } else if (override.dropTrailingInputs) {
+      const dropCount = Math.min(override.dropTrailingInputs, inputs.length);
+      inputs = inputs.slice(0, inputs.length - dropCount);
+    }
+    if ("variadic" in override) {
+      variadic = override.variadic ?? null;
+    }
+    if (override.params) {
+      params = override.params.map((param) => ({ ...param }));
+    }
+  }
+  const requiredParamCount = params.filter((param) => !param.optional).length;
+  const minArgs = override?.minArgs !== void 0 ? override.minArgs : config.minArgs !== void 0 ? config.minArgs : derivedMin + requiredParamCount;
+  const maxArgs = override?.maxArgs !== void 0 ? override.maxArgs : config.maxArgs !== void 0 ? config.maxArgs : derivedMax === null ? null : derivedMax + params.length;
+  const definition = {
+    nodeType: config.typeId,
+    inputs,
+    variadic,
+    params,
+    minArgs,
+    maxArgs,
+    resultValueType: inferExpressionValueType(
+      signature.outputs?.[0]?.ty ?? null
+    )
+  };
+  if (config.typeId === "if" || config.typeId === "case") {
+    const adjustedInputs = definition.inputs.map(
+      (input, index) => {
+        if (config.typeId === "if" && index === 0) {
+          return input;
+        }
+        return {
+          ...input,
+          valueType: "any"
+        };
+      }
+    );
+    definition.inputs = adjustedInputs;
+    if (definition.variadic) {
+      definition.variadic = {
+        ...definition.variadic,
+        valueType: "any"
+      };
+    }
+    definition.resultValueType = "any";
+  }
+  const names = new Set(
+    [config.typeId, ...config.names].map((name) => name.toLowerCase())
+  );
+  names.forEach((name) => {
+    SCALAR_FUNCTIONS.set(name, definition);
+  });
+  const orderedNames = Array.from(names);
+  const displayName = orderedNames[0] ?? config.typeId;
+  SCALAR_FUNCTION_VOCABULARY.push({
+    name: displayName,
+    aliases: orderedNames.slice(1),
+    nodeType: config.typeId,
+    category: config.category ?? "math",
+    description: config.description
+  });
+}
+function buildParamArgumentSpecs(signature) {
+  if (!signature || !Array.isArray(signature.params)) {
+    return [];
+  }
+  const params = signature.params;
+  return params.map((param) => ({
+    id: param.id,
+    label: param.label ?? param.id,
+    doc: param.doc ?? void 0,
+    optional: param.default_json !== void 0,
+    valueType: inferExpressionValueType(param.ty),
+    min: typeof param.min === "number" ? param.min : void 0,
+    max: typeof param.max === "number" ? param.max : void 0
+  }));
+}
+function inferExpressionValueType(ty) {
+  if (!ty) {
+    return "scalar";
+  }
+  const normalized = ty.toLowerCase();
+  if (normalized === "any") {
+    return "any";
+  }
+  if (normalized === "vector" || normalized === "vec2" || normalized === "vec3" || normalized === "vec4" || normalized === "quat" || normalized === "colorrgba" || normalized === "transform" || normalized === "array" || normalized === "list" || normalized === "record") {
+    return "vector";
+  }
+  if (normalized === "bool" || normalized === "boolean") {
+    return "boolean";
+  }
+  return "scalar";
+}
+
+// src/expressionVariables.ts
+var DefaultExpressionVariableTable = class {
+  constructor() {
+    this.variables = /* @__PURE__ */ new Map();
+    this.order = [];
+  }
+  registerSlotVariable(options) {
+    this.upsert({
+      name: options.name,
+      kind: "slot",
+      nodeId: options.nodeId,
+      metadata: {
+        slotId: options.slotId,
+        slotAlias: options.slotAlias,
+        inputId: options.inputId,
+        targetId: options.targetId,
+        animatableId: options.animatableId,
+        component: options.component,
+        valueType: options.valueType,
+        remap: options.remap,
+        autoRemap: options.autoRemap
+      }
+    });
+  }
+  registerReservedVariable(options) {
+    this.upsert({
+      name: options.name,
+      kind: "reserved",
+      nodeId: options.nodeId,
+      description: options.description,
+      metadata: {
+        targetId: options.targetId,
+        animatableId: options.animatableId,
+        component: options.component
+      }
+    });
+  }
+  resolve(name) {
+    return this.variables.get(name) ?? null;
+  }
+  resolveNodeId(name) {
+    return this.variables.get(name)?.nodeId ?? null;
+  }
+  entries() {
+    return this.order.map((name) => this.variables.get(name)).filter((entry) => Boolean(entry));
+  }
+  firstNodeId() {
+    for (const name of this.order) {
+      const nodeId = this.variables.get(name)?.nodeId;
+      if (nodeId) {
+        return nodeId;
+      }
+    }
+    return null;
+  }
+  missing(names) {
+    const missing = [];
+    for (const name of names) {
+      const entry = this.variables.get(name);
+      if (!entry) {
+        missing.push({ name, reason: "unknown" });
+        continue;
+      }
+      if (!entry.nodeId) {
+        missing.push({
+          name,
+          reason: "unresolved",
+          entry
+        });
+      }
+    }
+    return missing;
+  }
+  upsert(entry) {
+    if (!this.variables.has(entry.name)) {
+      this.order.push(entry.name);
+    }
+    this.variables.set(entry.name, entry);
+  }
+};
+function createExpressionVariableTable() {
+  return new DefaultExpressionVariableTable();
+}
+
+// src/expressionVocabulary.ts
+var RESERVED_EXPRESSION_VARIABLES = [
+  {
+    name: "self",
+    description: "Output of the current binding.",
+    scope: "binding",
+    defaultValueType: "scalar",
+    available: true
+  },
+  {
+    name: "time",
+    description: "Elapsed time in seconds since the rig started.",
+    scope: "graph",
+    defaultValueType: "scalar",
+    available: true
+  },
+  {
+    name: "deltaTime",
+    description: "Seconds elapsed since the previous frame update.",
+    scope: "graph",
+    defaultValueType: "scalar",
+    available: true
+  },
+  {
+    name: "frame",
+    description: "Current frame counter.",
+    scope: "graph",
+    defaultValueType: "scalar",
+    available: true
+  }
+];
+
+// src/graphBuilder.ts
+var import_metadata2 = require("@vizij/node-graph-wasm/metadata");
+
+// src/ir/builder.ts
+var graphSequence = 0;
+function generateGraphId(faceId) {
+  graphSequence += 1;
+  return `ir_${faceId}_${graphSequence}`;
+}
+var DefaultIrGraphBuilder = class {
+  constructor(options) {
+    this.nodes = [];
+    this.edges = [];
+    this.constants = [];
+    this.issues = [];
+    this.faceId = options.faceId;
+    this.summary = {
+      faceId: options.faceId,
+      inputs: [],
+      outputs: [],
+      bindings: []
+    };
+    this.metadata = {
+      source: options.source ?? "ir-builder",
+      registryVersion: options.registryVersion,
+      generatedAt: options.generatedAt,
+      annotations: options.annotations
+    };
+  }
+  addNode(node) {
+    this.nodes.push(node);
+    return node;
+  }
+  addEdge(edge) {
+    this.edges.push(edge);
+    return edge;
+  }
+  addConstant(constant) {
+    this.constants.push(constant);
+    return constant;
+  }
+  addIssue(issue) {
+    this.issues.push(issue);
+    return issue;
+  }
+  setSummary(summary) {
+    this.summary = summary;
+  }
+  updateMetadata(metadata) {
+    this.metadata = {
+      ...this.metadata,
+      ...metadata
+    };
+  }
+  build() {
+    return {
+      id: generateGraphId(this.faceId),
+      faceId: this.faceId,
+      nodes: [...this.nodes],
+      edges: [...this.edges],
+      constants: [...this.constants],
+      issues: [...this.issues],
+      summary: { ...this.summary },
+      metadata: { ...this.metadata }
+    };
+  }
+};
+function createIrGraphBuilder(options) {
+  return new DefaultIrGraphBuilder(options);
+}
+function toIrBindingSummary(summaries) {
+  return summaries.map((summary) => ({
+    ...summary,
+    remap: { ...summary.remap },
+    issues: summary.issues ? [...summary.issues] : void 0
+  }));
+}
+
+// src/ir/compiler.ts
+function compileIrGraph(graph, options = {}) {
+  const preferLegacy = options.preferLegacySpec === true;
+  const legacySpec = graph.legacy?.spec;
+  if (preferLegacy && legacySpec) {
+    return {
+      spec: legacySpec,
+      issues: [...graph.issues]
+    };
+  }
+  const convertedNodes = graph.nodes.map(convertIrNodeToNodeSpec);
+  const existingNodeIds = new Set(convertedNodes.map((node) => node.id));
+  graph.constants.forEach((constant) => {
+    if (existingNodeIds.has(constant.id)) {
+      return;
+    }
+    convertedNodes.push(convertIrConstantToNodeSpec(constant));
+  });
+  const convertedEdges = graph.edges.map(convertIrEdgeToGraphEdge);
+  const spec = {
+    nodes: convertedNodes,
+    edges: convertedEdges.length > 0 ? convertedEdges : void 0
+  };
+  inlineSingleUseConstants(spec);
+  const metadata = extractGraphSpecMetadata(graph);
+  if (metadata !== void 0) {
+    spec.metadata = metadata;
+  }
+  return {
+    spec,
+    issues: [...graph.issues]
+  };
+}
+function convertIrNodeToNodeSpec(node) {
+  const spec = {
+    id: node.id,
+    type: node.type
+  };
+  if (node.params) {
+    spec.params = cloneJsonLike(node.params);
+  }
+  if (node.inputDefaults) {
+    spec.input_defaults = cloneJsonLike(node.inputDefaults);
+  }
+  if (node.metadata) {
+    spec.metadata = cloneJsonLike(node.metadata);
+  }
+  return spec;
+}
+function convertIrConstantToNodeSpec(constant) {
+  const spec = {
+    id: constant.id,
+    type: "constant",
+    params: {
+      value: constant.value
+    }
+  };
+  if (constant.metadata) {
+    spec.metadata = cloneJsonLike(constant.metadata);
+  }
+  return spec;
+}
+function convertIrEdgeToGraphEdge(edge) {
+  return {
+    from: {
+      node_id: edge.from.nodeId,
+      output: edge.from.portId
+    },
+    to: {
+      node_id: edge.to.nodeId,
+      input: edge.to.portId
+    }
+  };
+}
+function extractGraphSpecMetadata(graph) {
+  const annotations = graph.metadata.annotations;
+  if (!annotations?.graphSpecMetadata) {
+    return void 0;
+  }
+  return cloneJsonLike(annotations.graphSpecMetadata);
+}
+function cloneJsonLike(value) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function inlineSingleUseConstants(spec) {
+  const nodes = spec.nodes ?? [];
+  const edges = spec.edges ? [...spec.edges] : [];
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const constantUsage = /* @__PURE__ */ new Map();
+  edges.forEach((edge) => {
+    const source = nodeById.get(edge.from.node_id);
+    if (source?.type === "constant") {
+      constantUsage.set(source.id, (constantUsage.get(source.id) ?? 0) + 1);
+    }
+  });
+  const updatedEdges = [];
+  const constantsToRemove = /* @__PURE__ */ new Set();
+  edges.forEach((edge) => {
+    const source = nodeById.get(edge.from.node_id);
+    if (source?.type === "constant" && constantUsage.get(source.id) === 1 && source.params && Object.prototype.hasOwnProperty.call(source.params, "value")) {
+      const target = nodeById.get(edge.to.node_id);
+      if (target) {
+        const value = source.params.value;
+        if (value !== void 0) {
+          target.input_defaults = {
+            ...target.input_defaults ?? {},
+            [edge.to.input ?? "in"]: value
+          };
+          nodeById.set(target.id, target);
+          constantsToRemove.add(source.id);
+          return;
+        }
+      }
+    }
+    updatedEdges.push(edge);
+  });
+  spec.nodes = nodes.filter((node) => !constantsToRemove.has(node.id));
+  spec.edges = updatedEdges.length > 0 ? updatedEdges : void 0;
+}
+
+// src/bindingMetadata.ts
+function cloneOperand(entry) {
+  return JSON.parse(JSON.stringify(entry));
+}
+function describeSlot(entry) {
+  const metadata = entry.metadata;
+  return {
+    kind: "slot",
+    ref: entry.name,
+    alias: metadata?.slotAlias ?? entry.name,
+    slotId: metadata?.slotId,
+    inputId: metadata?.inputId ?? null,
+    valueType: metadata?.valueType
+  };
+}
+function describeReserved(entry) {
+  return {
+    kind: "reserved",
+    ref: entry.name,
+    description: entry.description
+  };
+}
+function describeReference(node, variables) {
+  const entry = variables.resolve(node.name);
+  if (!entry) {
+    return {
+      kind: "unknown",
+      ref: node.name
+    };
+  }
+  if (entry.kind === "slot") {
+    return describeSlot(entry);
+  }
+  if (entry.kind === "reserved") {
+    return describeReserved(entry);
+  }
+  return {
+    kind: "unknown",
+    ref: entry.name
+  };
+}
+function stringifyExpression(node) {
+  switch (node.type) {
+    case "Literal":
+      return Number.isFinite(node.value) ? `${node.value}` : "0";
+    case "VectorLiteral":
+      return `vec(${node.values.join(", ")})`;
+    case "Reference":
+      return node.name;
+    case "Unary":
+      return `${node.operator}${stringifyExpression(node.operand)}`;
+    case "Binary":
+      return `${stringifyExpression(node.left)} ${node.operator} ${stringifyExpression(node.right)}`;
+    case "Function":
+      return `${node.name}(${node.args.map(stringifyExpression).join(", ")})`;
+    default:
+      return "";
+  }
+}
+function describeOperand(node, variables) {
+  switch (node.type) {
+    case "Literal":
+      return {
+        kind: "literal",
+        literalValue: node.value
+      };
+    case "Reference":
+      return describeReference(node, variables);
+    case "Unary":
+    case "Binary":
+    case "Function":
+    case "VectorLiteral":
+      return {
+        kind: "expression",
+        expression: stringifyExpression(node)
+      };
+    default:
+      return { kind: "unknown" };
+  }
+}
+function describeCaseExpression(node, variables) {
+  if (node.type !== "Function") {
+    return null;
+  }
+  if (node.name.toLowerCase() !== "case") {
+    return null;
+  }
+  if ((node.args?.length ?? 0) < 3) {
+    return null;
+  }
+  const [selector, defaultBranch, ...branches] = node.args;
+  return {
+    kind: "case",
+    selector: describeOperand(selector, variables),
+    defaultBranch: describeOperand(defaultBranch, variables),
+    branches: branches.map((branch) => describeOperand(branch, variables))
+  };
+}
+function buildBindingMetadataFromExpression(node, variables) {
+  if (!node) {
+    return void 0;
+  }
+  const caseMetadata = describeCaseExpression(node, variables);
+  if (!caseMetadata) {
+    return void 0;
+  }
+  return {
+    expression: {
+      case: {
+        kind: "case",
+        selector: caseMetadata.selector ? cloneOperand(caseMetadata.selector) : void 0,
+        defaultBranch: caseMetadata.defaultBranch ? cloneOperand(caseMetadata.defaultBranch) : void 0,
+        branches: caseMetadata.branches.map(cloneOperand)
+      }
+    }
+  };
+}
+
+// src/graphBuilder.ts
+function evaluateBinding({
+  binding,
+  target,
+  targetId,
+  animatableId,
+  component,
+  safeId,
+  context,
+  selfNodeId
+}) {
+  const { nodes, edges, ensureInputNode, bindingIssues, summaryBindings } = context;
+  const exprContext = {
+    componentSafeId: safeId,
+    nodes,
+    edges,
+    constants: /* @__PURE__ */ new Map(),
+    counter: 0,
+    reservedNodes: /* @__PURE__ */ new Map(),
+    nodeValueTypes: /* @__PURE__ */ new Map(),
+    slotRemapNodes: /* @__PURE__ */ new Map(),
+    graphReservedNodes: context.graphReservedNodes,
+    generateReservedNodeId: context.generateReservedNodeId
+  };
+  const targetValueType = target.valueType === "vector" ? "vector" : "scalar";
+  const variableTable = createExpressionVariableTable();
+  const slotSummaries = [];
+  const expressionIssues = [];
+  const rawExpression = typeof binding.expression === "string" ? binding.expression : "";
+  const trimmedExpression = rawExpression.trim();
+  let hasActiveSlot = false;
+  binding.slots.forEach((slot, index) => {
+    const aliasBase = slot.alias?.trim() ?? "";
+    const fallbackAlias = `s${index + 1}`;
+    const alias = aliasBase.length > 0 ? aliasBase : fallbackAlias;
+    const slotId = slot.id && slot.id.length > 0 ? slot.id : alias;
+    const slotValueType = slot.valueType === "vector" ? "vector" : "scalar";
+    let slotOutputId;
+    if (slot.inputId === import_utils3.SELF_BINDING_ID) {
+      if (selfNodeId) {
+        slotOutputId = selfNodeId;
+        hasActiveSlot = true;
+        setNodeValueType(
+          exprContext,
+          slotOutputId,
+          slotValueType === "vector" ? "vector" : "scalar"
+        );
+      } else {
+        expressionIssues.push("Self reference unavailable for this input.");
+        slotOutputId = getConstantNodeId(exprContext, target.defaultValue);
+      }
+    } else if (slot.inputId) {
+      const inputNode = ensureInputNode(slot.inputId);
+      if (inputNode) {
+        slotOutputId = inputNode.nodeId;
+        hasActiveSlot = true;
+        setNodeValueType(
+          exprContext,
+          slotOutputId,
+          slotValueType === "vector" ? "vector" : "scalar"
+        );
+      } else {
+        expressionIssues.push(`Missing standard input "${slot.inputId}".`);
+        slotOutputId = getConstantNodeId(exprContext, 0);
+      }
+    } else {
+      slotOutputId = getConstantNodeId(exprContext, 0);
+    }
+    variableTable.registerSlotVariable({
+      name: alias,
+      nodeId: slotOutputId,
+      slotId,
+      slotAlias: alias,
+      inputId: slot.inputId ?? null,
+      targetId,
+      animatableId,
+      component,
+      valueType: slotValueType,
+      remap: { ...slot.remap },
+      autoRemap: slot.inputId !== import_utils3.SELF_BINDING_ID && slotValueType === "scalar"
+    });
+    setNodeValueType(
+      exprContext,
+      slotOutputId,
+      slotValueType === "vector" ? "vector" : "scalar"
+    );
+    slotSummaries.push({
+      targetId,
+      animatableId,
+      component,
+      slotId,
+      slotAlias: alias,
+      inputId: slot.inputId ?? null,
+      remap: { ...slot.remap },
+      expression: trimmedExpression,
+      valueType: slotValueType,
+      nodeId: slotOutputId,
+      expressionNodeId: slotOutputId
+    });
+  });
+  if (slotSummaries.length === 0) {
+    const alias = PRIMARY_SLOT_ALIAS;
+    const constantId = getConstantNodeId(exprContext, 0);
+    variableTable.registerSlotVariable({
+      name: alias,
+      nodeId: constantId,
+      slotId: PRIMARY_SLOT_ID,
+      slotAlias: alias,
+      inputId: null,
+      targetId,
+      animatableId,
+      component,
+      valueType: targetValueType,
+      remap: createDefaultRemap(target),
+      autoRemap: false
+    });
+    setNodeValueType(
+      exprContext,
+      constantId,
+      targetValueType === "vector" ? "vector" : "scalar"
+    );
+    slotSummaries.push({
+      targetId,
+      animatableId,
+      component,
+      slotId: PRIMARY_SLOT_ID,
+      slotAlias: alias,
+      inputId: null,
+      remap: createDefaultRemap(target),
+      expression: trimmedExpression,
+      valueType: targetValueType,
+      nodeId: constantId,
+      expressionNodeId: constantId
+    });
+  }
+  RESERVED_EXPRESSION_VARIABLES.forEach((reserved) => {
+    if (reserved.available === false) {
+      return;
+    }
+    let nodeId = null;
+    if (reserved.name === "self") {
+      nodeId = selfNodeId ?? null;
+    } else {
+      nodeId = ensureReservedVariableNode(reserved.name, exprContext);
+    }
+    variableTable.registerReservedVariable({
+      name: reserved.name,
+      nodeId,
+      description: reserved.description,
+      targetId: reserved.scope === "binding" ? targetId : void 0,
+      animatableId: reserved.scope === "binding" ? animatableId : void 0,
+      component: reserved.scope === "binding" ? component : void 0
+    });
+  });
+  const defaultAlias = slotSummaries[0]?.slotAlias ?? PRIMARY_SLOT_ALIAS;
+  const expressionText = trimmedExpression.length > 0 ? trimmedExpression : defaultAlias;
+  const parseResult = parseControlExpression(expressionText);
+  let expressionAst = null;
+  if (parseResult.node && parseResult.errors.length === 0) {
+    const references = Array.from(
+      collectExpressionReferences(parseResult.node)
+    );
+    const missing = variableTable.missing(references);
+    if (missing.length === 0) {
+      expressionAst = parseResult.node;
+    } else {
+      validateLiteralParamArguments(parseResult.node, expressionIssues);
+      missing.forEach((missingVar) => {
+        if (missingVar.reason === "unresolved" && missingVar.entry?.kind === "reserved") {
+          expressionIssues.push(
+            `Reserved variable "${missingVar.name}" is unavailable for this binding.`
+          );
+        } else {
+          expressionIssues.push(`Unknown control "${missingVar.name}".`);
+        }
+      });
+    }
+  } else {
+    parseResult.errors.forEach((error) => {
+      expressionIssues.push(error.message);
+    });
+  }
+  const expressionMetadata = buildBindingMetadataFromExpression(
+    expressionAst,
+    variableTable
+  );
+  let valueNodeId = null;
+  if (expressionAst) {
+    valueNodeId = materializeExpression(
+      expressionAst,
+      exprContext,
+      variableTable,
+      expressionIssues
+    );
+  }
+  if (!valueNodeId) {
+    const fallbackNodeId = variableTable.resolveNodeId(defaultAlias) ?? variableTable.firstNodeId();
+    valueNodeId = fallbackNodeId ?? getConstantNodeId(exprContext, 0);
+  }
+  const issuesCopy = expressionIssues.length ? [...new Set(expressionIssues)] : void 0;
+  slotSummaries.forEach((summary) => {
+    summary.expression = expressionText;
+    summary.expressionNodeId = valueNodeId;
+    if (expressionMetadata) {
+      summary.metadata = expressionMetadata;
+    }
+    if (issuesCopy && issuesCopy.length > 0) {
+      summary.issues = issuesCopy;
+      const issueSet = bindingIssues.get(summary.targetId) ?? /* @__PURE__ */ new Set();
+      issuesCopy.forEach((issue) => issueSet.add(issue));
+      bindingIssues.set(summary.targetId, issueSet);
+    }
+  });
+  summaryBindings.push(...slotSummaries);
+  return {
+    valueNodeId,
+    hasActiveSlot
+  };
+}
+function sanitizeNodeId(value) {
+  return value.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function buildRigInputPath(faceId, inputPath) {
+  let trimmed = inputPath.startsWith("/") ? inputPath.slice(1) : inputPath;
+  if (!trimmed) {
+    return `rig/${faceId}`;
+  }
+  while (trimmed.startsWith("rig/")) {
+    const segments = trimmed.split("/");
+    if (segments.length >= 3) {
+      const existingFaceId = segments[1];
+      const remainder = segments.slice(2).join("/");
+      if (existingFaceId === faceId) {
+        return trimmed;
+      }
+      trimmed = remainder || "";
+    } else {
+      trimmed = segments.slice(1).join("/");
+    }
+  }
+  const suffix = trimmed ? `/${trimmed}` : "";
+  return `rig/${faceId}${suffix}`;
+}
+function getComponentOrder(animatable) {
+  switch (animatable.type) {
+    case "vector2":
+      return ["x", "y"];
+    case "vector3":
+    case "euler":
+      return ["x", "y", "z"];
+    case "rgb":
+      return ["r", "g", "b"];
+    default:
+      return null;
+  }
+}
+function isComponentRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function componentIndex(component) {
+  switch (component) {
+    case "x":
+    case "r":
+      return 0;
+    case "y":
+    case "g":
+      return 1;
+    default:
+      return 2;
+  }
+}
+function extractComponentDefault(value, component) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const candidate = value[componentIndex(component)];
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return candidate;
+    }
+    return 0;
+  }
+  if (value && typeof value === "object") {
+    if (!isComponentRecord(value)) {
+      return 0;
+    }
+    const direct = value[component];
+    if (typeof direct === "number" && Number.isFinite(direct)) {
+      return direct;
+    }
+    const alt = component === "x" ? value.r : component === "y" ? value.g : value.b;
+    if (typeof alt === "number" && Number.isFinite(alt)) {
+      return alt;
+    }
+  }
+  return 0;
+}
+function setNodeValueType(context, nodeId, valueType) {
+  context.nodeValueTypes.set(nodeId, valueType);
+}
+function getNodeValueType(context, nodeId) {
+  return context.nodeValueTypes.get(nodeId) ?? "any";
+}
+function matchesValueType(actual, expected) {
+  if (expected === "any" || actual === "any") {
+    return true;
+  }
+  if (expected === "scalar") {
+    return actual === "scalar" || actual === "boolean";
+  }
+  return actual === expected;
+}
+function ensureOperandValueType(context, operandId, expected, functionName, inputId, issues) {
+  if (expected === "any") {
+    return;
+  }
+  const actual = getNodeValueType(context, operandId);
+  if (matchesValueType(actual, expected)) {
+    return;
+  }
+  const expectation = expected === "vector" ? "a vector" : expected === "boolean" ? "a boolean" : "a scalar";
+  issues.push(
+    `Function "${functionName}" expects ${expectation} input for "${inputId}", but the expression produced ${actual}.`
+  );
+}
+function resolveSlotReferenceNode(entry, fallbackNodeId, context) {
+  if (entry.kind !== "slot") {
+    return fallbackNodeId;
+  }
+  const metadata = entry.metadata;
+  if (!metadata || metadata.autoRemap === false || !metadata.remap) {
+    return fallbackNodeId;
+  }
+  if (metadata.valueType !== "scalar") {
+    return fallbackNodeId;
+  }
+  if (isIdentityRemap(metadata.remap)) {
+    return fallbackNodeId;
+  }
+  const cacheKey = metadata.slotId ?? entry.name;
+  const existing = context.slotRemapNodes.get(cacheKey);
+  if (existing) {
+    return existing;
+  }
+  const remapNodeId = createSlotRemapNode(
+    context,
+    fallbackNodeId,
+    metadata.remap,
+    metadata.slotAlias ?? cacheKey
+  );
+  context.slotRemapNodes.set(cacheKey, remapNodeId);
+  return remapNodeId;
+}
+function createSlotRemapNode(context, sourceNodeId, remap, slotKey) {
+  const safeSlotKey = sanitizeNodeId(slotKey || "slot");
+  const nodeId = `slot_remap_${safeSlotKey}_${context.counter++}`;
+  context.nodes.push({
+    id: nodeId,
+    type: "centered_remap",
+    inputDefaults: {
+      in_low: remap.inLow,
+      in_anchor: remap.inAnchor,
+      in_high: remap.inHigh,
+      out_low: remap.outLow,
+      out_anchor: remap.outAnchor,
+      out_high: remap.outHigh
+    }
+  });
+  context.edges.push({
+    from: { nodeId: sourceNodeId },
+    to: { nodeId, portId: "in" }
+  });
+  setNodeValueType(context, nodeId, "scalar");
+  return nodeId;
+}
+function isIdentityRemap(remap) {
+  return nearlyEqual(remap.inLow, remap.outLow) && nearlyEqual(remap.inAnchor, remap.outAnchor) && nearlyEqual(remap.inHigh, remap.outHigh);
+}
+function nearlyEqual(a, b, epsilon = 1e-4) {
+  return Math.abs(a - b) <= epsilon;
+}
+var REMAP_FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
+  "piecewise_remap",
+  "centered_remap",
+  "remap"
+]);
+function shouldSkipAutoRemapForArgument(nodeType, index) {
+  if (!REMAP_FUNCTION_NODE_TYPES.has(nodeType)) {
+    return false;
+  }
+  return index === 0;
+}
+function getConstantNodeId(context, value) {
+  const key = Number.isFinite(value) ? value.toString() : "NaN";
+  const existing = context.constants.get(key);
+  if (existing) {
+    return existing;
+  }
+  const nodeId = `const_${context.componentSafeId}_${context.constants.size + 1}`;
+  context.nodes.push({
+    id: nodeId,
+    type: "constant",
+    params: {
+      value: Number.isFinite(value) ? value : 0
+    }
+  });
+  context.constants.set(key, nodeId);
+  setNodeValueType(context, nodeId, "scalar");
+  return nodeId;
+}
+function getVectorConstantNodeId(context, values) {
+  const normalized = values.map(
+    (value) => Number.isFinite(value) ? value : 0
+  );
+  const key = `vector:${normalized.join(",")}`;
+  const existing = context.constants.get(key);
+  if (existing) {
+    return existing;
+  }
+  const nodeId = `const_${context.componentSafeId}_${context.constants.size + 1}`;
+  context.nodes.push({
+    id: nodeId,
+    type: "constant",
+    params: {
+      value: {
+        vector: normalized
+      }
+    }
+  });
+  context.constants.set(key, nodeId);
+  setNodeValueType(context, nodeId, "vector");
+  return nodeId;
+}
+function createBinaryOperationNode(context, operator, leftId, rightId) {
+  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
+  context.nodes.push({
+    id: nodeId,
+    type: operator
+  });
+  setNodeValueType(context, nodeId, "scalar");
+  const leftInput = operator === "subtract" || operator === "divide" ? "lhs" : "operand_1";
+  const rightInput = operator === "subtract" || operator === "divide" ? "rhs" : "operand_2";
+  context.edges.push({
+    from: { nodeId: leftId },
+    to: { nodeId, portId: leftInput }
+  });
+  context.edges.push({
+    from: { nodeId: rightId },
+    to: { nodeId, portId: rightInput }
+  });
+  return nodeId;
+}
+function createVariadicOperationNode(context, operator, operandIds) {
+  if (operandIds.length === 0) {
+    return getConstantNodeId(context, operator === "add" ? 0 : 1);
+  }
+  if (operandIds.length === 1) {
+    return operandIds[0];
+  }
+  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
+  context.nodes.push({
+    id: nodeId,
+    type: operator
+  });
+  setNodeValueType(context, nodeId, "scalar");
+  operandIds.forEach((operandId, index) => {
+    context.edges.push({
+      from: { nodeId: operandId },
+      to: { nodeId, portId: `operand_${index + 1}` }
+    });
+  });
+  return nodeId;
+}
+function createNamedOperationNode(context, operator, inputNames, operandIds, resultType = "scalar", params) {
+  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
+  const node = {
+    id: nodeId,
+    type: operator
+  };
+  if (params && Object.keys(params).length > 0) {
+    node.params = params;
+  }
+  context.nodes.push(node);
+  setNodeValueType(context, nodeId, resultType);
+  inputNames.forEach((inputName, index) => {
+    const operandId = operandIds[index];
+    context.edges.push({
+      from: { nodeId: operandId },
+      to: { nodeId, portId: inputName }
+    });
+  });
+  return nodeId;
+}
+function ensureReservedVariableNode(name, context) {
+  const existing = context.reservedNodes.get(name);
+  if (existing) {
+    return existing;
+  }
+  if (name === "time" || name === "deltaTime" || name === "frame") {
+    const nodeId = ensureGraphTimeNode(context);
+    context.reservedNodes.set(name, nodeId);
+    return nodeId;
+  }
+  return null;
+}
+function ensureGraphTimeNode(context) {
+  const existing = context.graphReservedNodes.get("time");
+  if (existing) {
+    return existing;
+  }
+  const nodeId = context.generateReservedNodeId("time");
+  context.nodes.push({
+    id: nodeId,
+    type: "time",
+    metadata: {
+      reservedVariable: "time"
+    }
+  });
+  setNodeValueType(context, nodeId, "scalar");
+  context.graphReservedNodes.set("time", nodeId);
+  return nodeId;
+}
+function emitScalarFunctionNode(definition, operands, argNodes, totalArgCount, context, variables, issues, paramArgOverride) {
+  if (definition.nodeType === "case") {
+    return emitCaseFunctionNode(
+      definition,
+      operands,
+      argNodes,
+      context,
+      variables,
+      issues
+    );
+  }
+  const orderedOperands = operands.slice(0, definition.inputs.length);
+  definition.inputs.forEach((input, index) => {
+    const operandId = orderedOperands[index];
+    if (!operandId) {
+      return;
+    }
+    ensureOperandValueType(
+      context,
+      operandId,
+      input.valueType,
+      definition.nodeType,
+      input.id,
+      issues
+    );
+  });
+  const availableAfterInputs = Math.max(
+    0,
+    totalArgCount - definition.inputs.length
+  );
+  const paramArgCount = definition.params.length > 0 ? Math.min(definition.params.length, availableAfterInputs) : 0;
+  const variadicArgCount = definition.variadic ? Math.max(0, availableAfterInputs - paramArgCount) : 0;
+  const variadicOperands = definition.variadic ? operands.slice(
+    definition.inputs.length,
+    definition.inputs.length + variadicArgCount
+  ) : [];
+  if (definition.variadic) {
+    variadicOperands.forEach((operandId, _variadicIndex) => {
+      ensureOperandValueType(
+        context,
+        operandId,
+        definition.variadic.valueType,
+        definition.nodeType,
+        definition.variadic.id,
+        issues
+      );
+    });
+  }
+  const paramArgStart = definition.inputs.length + variadicArgCount;
+  const paramArgNodes = paramArgCount > 0 ? paramArgOverride ?? argNodes.slice(paramArgStart, paramArgStart + paramArgCount) : [];
+  const isSlewDebugEnabled = typeof process !== "undefined" && process?.env && process.env.DEBUG_SLEW === "1";
+  if (isSlewDebugEnabled && definition.nodeType === "slew") {
+    console.log("slew-debug", {
+      totalArgs: totalArgCount,
+      inputs: definition.inputs.length,
+      paramCount: definition.params.length,
+      paramArgCount,
+      paramArgNodesTypes: paramArgNodes.map((node) => node?.type ?? null)
+    });
+  }
+  const nodeParams = buildParamAssignments(definition, paramArgNodes, issues);
+  if (definition.variadic && definition.inputs.length === 0) {
+    const nodeId2 = `expr_${context.componentSafeId}_${context.counter++}`;
+    const node = {
+      id: nodeId2,
+      type: definition.nodeType
+    };
+    if (nodeParams) {
+      node.params = nodeParams;
+    }
+    context.nodes.push(node);
+    variadicOperands.forEach((operandId, index) => {
+      context.edges.push({
+        from: { nodeId: operandId },
+        to: {
+          nodeId: nodeId2,
+          portId: `${definition.variadic.id}_${index + 1}`
+        }
+      });
+    });
+    setNodeValueType(context, nodeId2, definition.resultValueType);
+    return nodeId2;
+  }
+  const providedNames = [];
+  const providedOperands = [];
+  definition.inputs.forEach((input, index) => {
+    const operandId = orderedOperands[index];
+    if (!operandId) {
+      return;
+    }
+    providedNames.push(input.id);
+    providedOperands.push(operandId);
+  });
+  const nodeId = createNamedOperationNode(
+    context,
+    definition.nodeType,
+    providedNames,
+    providedOperands,
+    definition.resultValueType,
+    nodeParams ?? void 0
+  );
+  if (definition.variadic) {
+    variadicOperands.forEach((operandId, index) => {
+      context.edges.push({
+        from: { nodeId: operandId },
+        to: {
+          nodeId,
+          portId: `${definition.variadic.id}_${index + 1}`
+        }
+      });
+    });
+  }
+  return nodeId;
+}
+function emitCaseFunctionNode(definition, operands, argNodes, context, variables, issues) {
+  const selectorId = operands[0];
+  const defaultId = operands[1];
+  const branchOperands = operands.slice(2);
+  const branchArgs = argNodes.slice(2);
+  if (!selectorId || branchOperands.length === 0) {
+    issues.push(
+      'Function "case" requires a selector, default, and at least one branch.'
+    );
+    return getConstantNodeId(context, 0);
+  }
+  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
+  const caseLabels = branchOperands.map((_, index) => {
+    const extracted = extractCaseLabel(branchArgs[index], variables);
+    if (extracted) {
+      return extracted;
+    }
+    const fallback = `case_${index + 1}`;
+    issues.push(
+      `Case branch ${index + 1} is missing an alias; generated fallback label ${fallback}.`
+    );
+    return fallback;
+  });
+  context.nodes.push({
+    id: nodeId,
+    type: definition.nodeType,
+    params: caseLabels.length > 0 ? { case_labels: caseLabels } : void 0
+  });
+  ensureOperandValueType(
+    context,
+    selectorId,
+    definition.inputs[0]?.valueType ?? "any",
+    definition.nodeType,
+    definition.inputs[0]?.id ?? "selector",
+    issues
+  );
+  context.edges.push({
+    from: { nodeId: selectorId },
+    to: { nodeId, portId: definition.inputs[0]?.id ?? "selector" }
+  });
+  if (defaultId) {
+    ensureOperandValueType(
+      context,
+      defaultId,
+      definition.inputs[1]?.valueType ?? "any",
+      definition.nodeType,
+      "default",
+      issues
+    );
+    context.edges.push({
+      from: { nodeId: defaultId },
+      to: { nodeId, portId: "default" }
+    });
+  }
+  branchOperands.forEach((operandId, index) => {
+    const portId = `${definition.variadic?.id ?? "operand"}_${index + 1}`;
+    ensureOperandValueType(
+      context,
+      operandId,
+      definition.variadic?.valueType ?? "any",
+      definition.nodeType,
+      portId,
+      issues
+    );
+    context.edges.push({
+      from: { nodeId: operandId },
+      to: { nodeId, portId }
+    });
+  });
+  setNodeValueType(context, nodeId, "any");
+  return nodeId;
+}
+function buildParamAssignments(definition, paramArgNodes, issues) {
+  if (!definition.params.length || paramArgNodes.length === 0) {
+    return null;
+  }
+  const assignments = {};
+  paramArgNodes.forEach((node, index) => {
+    const spec = definition.params[index];
+    if (!spec) {
+      return;
+    }
+    const literal = extractParamLiteral(
+      node,
+      spec,
+      definition.nodeType,
+      issues
+    );
+    if (literal !== null) {
+      assignments[spec.id] = literal;
+    }
+  });
+  return Object.keys(assignments).length > 0 ? assignments : null;
+}
+function extractParamLiteral(node, spec, functionName, issues) {
+  if (spec.valueType === "vector") {
+    if (node.type !== "VectorLiteral") {
+      issues.push(
+        `Function "${functionName}" requires a literal vector for "${spec.id}".`
+      );
+      return null;
+    }
+    if (!Array.isArray(node.values) || node.values.length === 0) {
+      issues.push(
+        `Function "${functionName}" requires at least one value for "${spec.id}".`
+      );
+      return null;
+    }
+    return node.values.map((value) => clampScalarParamValue(value, spec));
+  }
+  if (node.type !== "Literal") {
+    issues.push(
+      `Function "${functionName}" requires a literal ${describeParamExpectation(spec.valueType)} for "${spec.id}".`
+    );
+    return null;
+  }
+  const numeric = Number(node.value);
+  if (!Number.isFinite(numeric)) {
+    issues.push(
+      `Function "${functionName}" requires a finite ${describeParamExpectation(spec.valueType)} for "${spec.id}".`
+    );
+    return null;
+  }
+  const clamped = clampScalarParamValue(numeric, spec);
+  if (spec.valueType === "boolean") {
+    return clamped !== 0;
+  }
+  return clamped;
+}
+function clampScalarParamValue(value, spec) {
+  let next = Number.isFinite(value) ? value : 0;
+  if (typeof spec.min === "number" && next < spec.min) {
+    next = spec.min;
+  }
+  if (typeof spec.max === "number" && next > spec.max) {
+    next = spec.max;
+  }
+  return next;
+}
+function describeParamExpectation(valueType) {
+  switch (valueType) {
+    case "vector":
+      return "vector";
+    case "boolean":
+      return "boolean";
+    default:
+      return "scalar";
+  }
+}
+function extractCaseLabel(node, variables) {
+  if (!node || node.type !== "Reference") {
+    return null;
+  }
+  const entry = variables.resolve(node.name);
+  if (entry && entry.metadata && "slotAlias" in entry.metadata) {
+    const alias = entry.metadata.slotAlias?.trim();
+    if (alias && alias.length > 0) {
+      return alias;
+    }
+  }
+  return node.name;
+}
+function collectOperands(node, operator, target) {
+  if (node.type === "Binary" && node.operator === operator) {
+    collectOperands(node.left, operator, target);
+    collectOperands(node.right, operator, target);
+    return;
+  }
+  target.push(node);
+}
+function validateLiteralParamArguments(node, issues) {
+  if (node.type === "Function") {
+    const definition = SCALAR_FUNCTIONS.get(node.name.toLowerCase());
+    if (definition && definition.params.length > 0) {
+      const totalArgCount = node.args.length;
+      const availableAfterInputs = Math.max(
+        0,
+        totalArgCount - definition.inputs.length
+      );
+      const paramArgCount = Math.min(
+        definition.params.length,
+        availableAfterInputs
+      );
+      const variadicArgCount = definition.variadic ? Math.max(0, availableAfterInputs - paramArgCount) : 0;
+      const paramArgStart = definition.inputs.length + variadicArgCount;
+      for (let index = 0; index < paramArgCount; index++) {
+        const spec = definition.params[index];
+        const paramNode = node.args[paramArgStart + index];
+        if (!spec || !paramNode) {
+          continue;
+        }
+        extractParamLiteral(paramNode, spec, node.name, issues);
+      }
+    }
+    node.args.forEach((child) => validateLiteralParamArguments(child, issues));
+    return;
+  }
+  if (node.type === "Unary") {
+    validateLiteralParamArguments(node.operand, issues);
+    return;
+  }
+  if (node.type === "Binary") {
+    validateLiteralParamArguments(node.left, issues);
+    validateLiteralParamArguments(node.right, issues);
+  }
+}
+var BINARY_FUNCTION_OPERATOR_MAP = {
+  ">": "greaterthan",
+  "<": "lessthan",
+  "==": "equal",
+  "!=": "notequal",
+  "&&": "and",
+  "||": "or"
+};
+function materializeExpression(node, context, variables, issues, options) {
+  const autoRemap = options?.autoRemap !== false;
+  switch (node.type) {
+    case "Literal": {
+      return getConstantNodeId(context, node.value);
+    }
+    case "VectorLiteral": {
+      return getVectorConstantNodeId(context, node.values);
+    }
+    case "Reference": {
+      const entry = variables.resolve(node.name);
+      if (!entry) {
+        issues.push(`Unknown control "${node.name}".`);
+        return getConstantNodeId(context, 0);
+      }
+      const mappedId = entry.nodeId ?? getConstantNodeId(context, 0);
+      if (!autoRemap || entry.kind !== "slot") {
+        return mappedId;
+      }
+      return resolveSlotReferenceNode(entry, mappedId, context);
+    }
+    case "Unary": {
+      const operandId = materializeExpression(
+        node.operand,
+        context,
+        variables,
+        issues
+      );
+      switch (node.operator) {
+        case "+":
+          return operandId;
+        case "-": {
+          const negativeOne = getConstantNodeId(context, -1);
+          return createVariadicOperationNode(context, "multiply", [
+            negativeOne,
+            operandId
+          ]);
+        }
+        case "!": {
+          const definition = SCALAR_FUNCTIONS.get("not");
+          if (!definition) {
+            issues.push('Function "not" is not available in metadata.');
+            return getConstantNodeId(context, 0);
+          }
+          return emitScalarFunctionNode(
+            definition,
+            [operandId],
+            [node.operand],
+            1,
+            context,
+            variables,
+            issues
+          );
+        }
+        default:
+          issues.push("Unsupported unary operator.");
+          return operandId;
+      }
+    }
+    case "Binary": {
+      const operator = node.operator;
+      if (operator === "+") {
+        const children = [];
+        collectOperands(node, "+", children);
+        const operandIds = children.map(
+          (child) => materializeExpression(child, context, variables, issues)
+        );
+        return createVariadicOperationNode(context, "add", operandIds);
+      }
+      if (operator === "*") {
+        const children = [];
+        collectOperands(node, "*", children);
+        const operandIds = children.map(
+          (child) => materializeExpression(child, context, variables, issues)
+        );
+        return createVariadicOperationNode(context, "multiply", operandIds);
+      }
+      const leftId = materializeExpression(
+        node.left,
+        context,
+        variables,
+        issues
+      );
+      const rightId = materializeExpression(
+        node.right,
+        context,
+        variables,
+        issues
+      );
+      if (operator === "-") {
+        return createBinaryOperationNode(context, "subtract", leftId, rightId);
+      }
+      if (operator === "/") {
+        return createBinaryOperationNode(context, "divide", leftId, rightId);
+      }
+      const mappedFunction = BINARY_FUNCTION_OPERATOR_MAP[operator];
+      if (mappedFunction) {
+        const definition = SCALAR_FUNCTIONS.get(mappedFunction);
+        if (!definition) {
+          issues.push(`Function "${mappedFunction}" is not available.`);
+          return getConstantNodeId(context, 0);
+        }
+        return emitScalarFunctionNode(
+          definition,
+          [leftId, rightId],
+          [node.left, node.right],
+          2,
+          context,
+          variables,
+          issues
+        );
+      }
+      issues.push(`Unsupported operator "${operator}".`);
+      return getConstantNodeId(context, 0);
+    }
+    case "Function": {
+      const name = node.name;
+      const normalized = name.toLowerCase();
+      const definition = SCALAR_FUNCTIONS.get(normalized);
+      if (!definition) {
+        issues.push(`Unknown function "${name}".`);
+        return getConstantNodeId(context, 0);
+      }
+      const argNodes = node.args;
+      const argCount = argNodes.length;
+      if (argCount < definition.minArgs) {
+        issues.push(
+          `Function "${name}" expects at least ${definition.minArgs} arguments, received ${argCount}.`
+        );
+        return getConstantNodeId(context, 0);
+      }
+      if (definition.maxArgs !== null && argCount > definition.maxArgs) {
+        issues.push(
+          `Function "${name}" expects at most ${definition.maxArgs} arguments, received ${argCount}.`
+        );
+        return getConstantNodeId(context, 0);
+      }
+      if (name === "slew") {
+        const maxRateArg = argNodes[1];
+        if (!maxRateArg || maxRateArg.type !== "Literal") {
+          issues.push(
+            'Function "slew" requires a literal scalar for "max_rate".'
+          );
+        }
+      }
+      const availableAfterInputs = Math.max(
+        0,
+        argCount - definition.inputs.length
+      );
+      const paramArgCount = definition.params.length > 0 ? Math.min(definition.params.length, availableAfterInputs) : 0;
+      const variadicArgCount = definition.variadic ? Math.max(0, availableAfterInputs - paramArgCount) : 0;
+      const operandLimit = Math.min(
+        argCount,
+        definition.inputs.length + variadicArgCount
+      );
+      const operandNodes = argNodes.slice(0, operandLimit);
+      const operands = operandNodes.map(
+        (arg, index) => materializeExpression(
+          arg,
+          context,
+          variables,
+          issues,
+          shouldSkipAutoRemapForArgument(definition.nodeType, index) ? { autoRemap: false } : void 0
+        )
+      );
+      const paramArgStart = operandLimit;
+      const paramArgNodes = paramArgCount > 0 ? argNodes.slice(paramArgStart, paramArgStart + paramArgCount) : [];
+      const paramOverride = definition.nodeType === "case" ? void 0 : paramArgNodes;
+      return emitScalarFunctionNode(
+        definition,
+        operands,
+        argNodes,
+        argCount,
+        context,
+        variables,
+        issues,
+        paramOverride
+      );
+    }
+    default: {
+      issues.push("Unsupported expression node.");
+      return getConstantNodeId(context, 0);
+    }
+  }
+}
+function buildRigGraphSpec({
+  faceId,
+  animatables,
+  components,
+  bindings,
+  inputsById,
+  inputBindings,
+  inputMetadata
+}) {
+  const metadataByInputId = inputMetadata ?? /* @__PURE__ */ new Map();
+  const irBuilder = createIrGraphBuilder({
+    faceId,
+    registryVersion: import_metadata2.nodeRegistryVersion,
+    source: "graphBuilder",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const nodes = [];
+  const edges = [];
+  const graphReservedNodes = /* @__PURE__ */ new Map();
+  const reservedNodeCounters = /* @__PURE__ */ new Map();
+  const generateReservedNodeId = (kind) => {
+    const nextValue = (reservedNodeCounters.get(kind) ?? 0) + 1;
+    reservedNodeCounters.set(kind, nextValue);
+    return `reserved_${kind}_${nextValue}`;
+  };
+  const inputNodes = /* @__PURE__ */ new Map();
+  const buildingDerived = /* @__PURE__ */ new Set();
+  const computedInputs = /* @__PURE__ */ new Set();
+  const summaryBindings = [];
+  const bindingIssues = /* @__PURE__ */ new Map();
+  const animatableEntries = /* @__PURE__ */ new Map();
+  const outputs = /* @__PURE__ */ new Set();
+  const ensureInputNode = (inputId) => {
+    const existing = inputNodes.get(inputId);
+    if (existing) {
+      return existing;
+    }
+    const input = inputsById.get(inputId);
+    if (!input) {
+      return null;
+    }
+    const defaultValue = Number.isFinite(input.defaultValue) ? input.defaultValue : 0;
+    const inputBindingRaw = inputBindings[inputId];
+    if (inputBindingRaw) {
+      if (buildingDerived.has(inputId)) {
+        const issueSet = bindingIssues.get(inputId) ?? /* @__PURE__ */ new Set();
+        issueSet.add("Derived input cycle detected.");
+        bindingIssues.set(inputId, issueSet);
+        return null;
+      }
+      buildingDerived.add(inputId);
+      try {
+        const target = bindingTargetFromInput(input);
+        const binding = ensureBindingStructure(inputBindingRaw, target);
+        const requiresSelf = binding.inputId === import_utils3.SELF_BINDING_ID || binding.slots.some((slot) => slot.inputId === import_utils3.SELF_BINDING_ID);
+        let selfNodeId;
+        if (requiresSelf) {
+          const sliderNodeId = `input_raw_${sanitizeNodeId(inputId)}`;
+          nodes.push({
+            id: sliderNodeId,
+            type: "input",
+            params: {
+              path: buildRigInputPath(faceId, input.path),
+              value: { float: defaultValue }
+            }
+          });
+          selfNodeId = sliderNodeId;
+        }
+        const { valueNodeId, hasActiveSlot } = evaluateBinding({
+          binding,
+          target,
+          targetId: inputId,
+          animatableId: inputId,
+          component: void 0,
+          safeId: sanitizeNodeId(inputId),
+          context: {
+            nodes,
+            edges,
+            ensureInputNode,
+            bindingIssues,
+            summaryBindings,
+            graphReservedNodes,
+            generateReservedNodeId
+          },
+          selfNodeId
+        });
+        if (!valueNodeId || !hasActiveSlot) {
+          const constNodeId = `derived_default_${sanitizeNodeId(inputId)}`;
+          nodes.push({
+            id: constNodeId,
+            type: "constant",
+            params: {
+              value: input.defaultValue
+            }
+          });
+          const record3 = { nodeId: constNodeId, input };
+          inputNodes.set(inputId, record3);
+          return record3;
+        }
+        computedInputs.add(inputId);
+        const record2 = { nodeId: valueNodeId, input };
+        inputNodes.set(inputId, record2);
+        return record2;
+      } finally {
+        buildingDerived.delete(inputId);
+      }
+    }
+    const nodeId = `input_${sanitizeNodeId(inputId)}`;
+    nodes.push({
+      id: nodeId,
+      type: "input",
+      params: {
+        path: buildRigInputPath(faceId, input.path),
+        value: { float: defaultValue }
+      }
+    });
+    const record = { nodeId, input };
+    inputNodes.set(inputId, record);
+    return record;
+  };
+  const ensureAnimatableEntry = (animatableId) => {
+    const existing = animatableEntries.get(animatableId);
+    if (existing) {
+      return existing;
+    }
+    const animatable = animatables[animatableId];
+    if (!animatable) {
+      return null;
+    }
+    const entry = {
+      animatable,
+      values: /* @__PURE__ */ new Map(),
+      defaults: /* @__PURE__ */ new Map(),
+      isDriven: false
+    };
+    animatableEntries.set(animatableId, entry);
+    return entry;
+  };
+  components.forEach((component) => {
+    const bindingRaw = bindings[component.id];
+    const target = bindingTargetFromComponent(component);
+    const binding = bindingRaw ? ensureBindingStructure(bindingRaw, target) : null;
+    const entry = ensureAnimatableEntry(component.animatableId);
+    if (!entry) {
+      return;
+    }
+    const key = component.component ?? "scalar";
+    let valueNodeId = null;
+    let hasActiveSlot = false;
+    if (binding) {
+      const { valueNodeId: producedNodeId, hasActiveSlot: active } = evaluateBinding({
+        binding,
+        target,
+        targetId: component.id,
+        animatableId: component.animatableId,
+        component: component.component,
+        safeId: component.safeId,
+        context: {
+          nodes,
+          edges,
+          ensureInputNode,
+          bindingIssues,
+          summaryBindings,
+          graphReservedNodes,
+          generateReservedNodeId
+        }
+      });
+      valueNodeId = producedNodeId;
+      hasActiveSlot = active;
+      if (active) {
+        entry.isDriven = true;
+      }
+    } else {
+      summaryBindings.push({
+        targetId: component.id,
+        animatableId: component.animatableId,
+        component: component.component,
+        slotId: PRIMARY_SLOT_ID,
+        slotAlias: PRIMARY_SLOT_ALIAS,
+        inputId: null,
+        remap: createDefaultRemap(target),
+        expression: PRIMARY_SLOT_ALIAS,
+        valueType: target.valueType === "vector" ? "vector" : "scalar",
+        issues: ["Binding not found."],
+        nodeId: PRIMARY_SLOT_ID,
+        expressionNodeId: PRIMARY_SLOT_ID
+      });
+      const fallbackIssues = bindingIssues.get(component.id) ?? /* @__PURE__ */ new Set();
+      fallbackIssues.add("Binding not found.");
+      bindingIssues.set(component.id, fallbackIssues);
+    }
+    if (!valueNodeId || !hasActiveSlot) {
+      entry.defaults.set(key, component.defaultValue);
+      return;
+    }
+    entry.values.set(key, valueNodeId);
+  });
+  inputsById.forEach((_input, inputId) => {
+    ensureInputNode(inputId);
+  });
+  animatableEntries.forEach((entry, animatableId) => {
+    if (!entry.isDriven) {
+      return;
+    }
+    outputs.add(animatableId);
+    const safeId = sanitizeNodeId(animatableId);
+    const order = getComponentOrder(entry.animatable);
+    if (!order) {
+      const valueNodeId = entry.values.get("scalar");
+      if (!valueNodeId) {
+        return;
+      }
+      const outputNodeId2 = `out_${safeId}`;
+      nodes.push({
+        id: outputNodeId2,
+        type: "output",
+        params: {
+          path: animatableId
+        }
+      });
+      edges.push({
+        from: { nodeId: valueNodeId },
+        to: { nodeId: outputNodeId2, portId: "in" }
+      });
+      return;
+    }
+    const joinNodeId = `join_${safeId}`;
+    nodes.push({
+      id: joinNodeId,
+      type: "join"
+    });
+    order.forEach((componentKey, index) => {
+      let sourceId = entry.values.get(componentKey);
+      if (!sourceId) {
+        const componentDefault = entry.defaults.get(componentKey) ?? extractComponentDefault(
+          (0, import_utils2.buildAnimatableValue)(entry.animatable, void 0),
+          componentKey
+        );
+        const constNodeId = `const_${safeId}_${componentKey}`;
+        nodes.push({
+          id: constNodeId,
+          type: "constant",
+          params: {
+            value: componentDefault
+          }
+        });
+        sourceId = constNodeId;
+      }
+      edges.push({
+        from: { nodeId: sourceId },
+        to: { nodeId: joinNodeId, portId: `operand_${index + 1}` }
+      });
+    });
+    const outputNodeId = `out_${safeId}`;
+    nodes.push({
+      id: outputNodeId,
+      type: "output",
+      params: {
+        path: animatableId
+      }
+    });
+    edges.push({
+      from: { nodeId: joinNodeId },
+      to: { nodeId: outputNodeId, portId: "in" }
+    });
+  });
+  const nodeById = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => {
+    nodeById.set(node.id, node);
+  });
+  const constantUsage = /* @__PURE__ */ new Map();
+  edges.forEach((edge) => {
+    const source = nodeById.get(edge.from.nodeId);
+    if (source?.type === "constant") {
+      constantUsage.set(source.id, (constantUsage.get(source.id) ?? 0) + 1);
+    }
+  });
+  const updatedEdges = [];
+  const constantsToRemove = /* @__PURE__ */ new Set();
+  edges.forEach((edge) => {
+    const source = nodeById.get(edge.from.nodeId);
+    if (source?.type === "constant" && constantUsage.get(source.id) === 1 && source.params && Object.prototype.hasOwnProperty.call(source.params, "value")) {
+      const target = nodeById.get(edge.to.nodeId);
+      if (target) {
+        const value = source.params.value;
+        if (value !== void 0) {
+          const targetPort = edge.to.portId ?? "in";
+          target.inputDefaults = {
+            ...target.inputDefaults ?? {},
+            [targetPort]: value
+          };
+          nodeById.set(target.id, target);
+          constantsToRemove.add(source.id);
+          return;
+        }
+      }
+    }
+    updatedEdges.push(edge);
+  });
+  const filteredNodes = nodes.filter((node) => !constantsToRemove.has(node.id)).map((node) => nodeById.get(node.id) ?? node);
+  const remapDefaultIssues = validateRemapDefaults(filteredNodes);
+  const dynamicOutputs = Array.from(outputs);
+  const computedInputList = Array.from(computedInputs);
+  const filteredSummaryBindings = summaryBindings.filter(
+    (binding) => outputs.has(binding.animatableId) || computedInputs.has(binding.animatableId)
+  );
+  const vizijMetadata = {
+    vizij: {
+      faceId,
+      inputs: Array.from(inputsById.values()).map((input) => {
+        const meta = metadataByInputId.get(input.id);
+        const derivedRoot = meta?.root ?? input.group;
+        let derivedSource = meta?.source;
+        if (!derivedSource && input.path.startsWith("/standard/")) {
+          derivedSource = "preset";
+        }
+        const entry = {
+          id: input.id,
+          path: input.path,
+          sourceId: input.sourceId,
+          label: input.label,
+          group: input.group,
+          defaultValue: input.defaultValue,
+          range: {
+            min: input.range.min,
+            max: input.range.max
+          }
+        };
+        if (derivedSource) {
+          entry.source = derivedSource;
+        }
+        if (derivedRoot) {
+          entry.root = derivedRoot;
+        }
+        return entry;
+      }),
+      bindings: filteredSummaryBindings.map((binding) => ({
+        ...binding,
+        remap: { ...binding.remap },
+        expression: binding.expression,
+        valueType: binding.valueType,
+        issues: binding.issues ? [...binding.issues] : void 0,
+        metadata: binding.metadata ? cloneJsonLike2(binding.metadata) : void 0
+      }))
+    }
+  };
+  const issuesByTarget = {};
+  bindingIssues.forEach((issues, targetId) => {
+    if (issues.size === 0) {
+      return;
+    }
+    issuesByTarget[targetId] = Array.from(issues);
+  });
+  const fatalIssues = /* @__PURE__ */ new Set();
+  Object.values(issuesByTarget).forEach((issues) => {
+    issues.forEach((issue) => fatalIssues.add(issue));
+  });
+  remapDefaultIssues.forEach((issue) => fatalIssues.add(issue));
+  const summaryPayload = {
+    faceId,
+    inputs: Array.from(inputNodes.values()).map(
+      ({ input }) => buildRigInputPath(faceId, input.path)
+    ),
+    outputs: [...dynamicOutputs, ...computedInputList],
+    bindings: filteredSummaryBindings
+  };
+  const irSummary = {
+    faceId: summaryPayload.faceId,
+    inputs: [...summaryPayload.inputs],
+    outputs: [...summaryPayload.outputs],
+    bindings: toIrBindingSummary(
+      filteredSummaryBindings.map((binding) => ({
+        ...binding,
+        remap: { ...binding.remap },
+        issues: binding.issues ? [...binding.issues] : void 0
+      }))
+    )
+  };
+  const fatalIssueList = Array.from(fatalIssues);
+  const irIssues = createIrIssuesFromLegacy(issuesByTarget, fatalIssueList);
+  filteredNodes.forEach((node) => {
+    irBuilder.addNode(cloneIrNode(node));
+    const constant = extractIrConstantFromNode(node);
+    if (constant) {
+      irBuilder.addConstant(constant);
+    }
+  });
+  updatedEdges.forEach((edge) => {
+    irBuilder.addEdge(cloneIrEdge(edge));
+  });
+  irBuilder.setSummary(irSummary);
+  irIssues.forEach((issue) => irBuilder.addIssue(issue));
+  irBuilder.updateMetadata({
+    annotations: {
+      graphSpecMetadata: cloneJsonLike2(vizijMetadata)
+    }
+  });
+  const irGraph = irBuilder.build();
+  const compiled = compileIrGraph(irGraph, { preferLegacySpec: false });
+  return {
+    spec: compiled.spec,
+    summary: summaryPayload,
+    issues: {
+      byTarget: issuesByTarget,
+      fatal: fatalIssueList
+    },
+    ir: {
+      graph: irGraph,
+      compile: (options) => compileIrGraph(irGraph, options)
+    }
+  };
+}
+function createIrIssuesFromLegacy(issuesByTarget, fatalIssues) {
+  const fatalSet = new Set(fatalIssues);
+  const collected = [];
+  let counter = 0;
+  Object.entries(issuesByTarget).forEach(([targetId, messages]) => {
+    messages.forEach((message) => {
+      counter += 1;
+      collected.push({
+        id: `issue_${counter}`,
+        severity: fatalSet.has(message) ? "error" : "warning",
+        message,
+        targetId,
+        tags: fatalSet.has(message) ? ["fatal"] : void 0
+      });
+    });
+  });
+  fatalSet.forEach((message) => {
+    const alreadyCaptured = collected.some(
+      (issue) => issue.message === message
+    );
+    if (alreadyCaptured) {
+      return;
+    }
+    counter += 1;
+    collected.push({
+      id: `issue_${counter}`,
+      severity: "error",
+      message,
+      tags: ["fatal"]
+    });
+  });
+  return collected;
+}
+function cloneIrNode(node) {
+  return {
+    id: node.id,
+    type: node.type,
+    category: node.category,
+    label: node.label,
+    description: node.description,
+    params: cloneJsonLike2(node.params),
+    inputDefaults: cloneJsonLike2(node.inputDefaults),
+    metadata: cloneJsonLike2(node.metadata)
+  };
+}
+function cloneIrEdge(edge) {
+  return {
+    id: edge.id,
+    from: {
+      nodeId: edge.from.nodeId,
+      portId: edge.from.portId,
+      component: edge.from.component
+    },
+    to: {
+      nodeId: edge.to.nodeId,
+      portId: edge.to.portId,
+      component: edge.to.component
+    },
+    metadata: cloneJsonLike2(edge.metadata)
+  };
+}
+function extractIrConstantFromNode(node) {
+  if (node.type !== "constant") {
+    return null;
+  }
+  const value = node.params?.value;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  return {
+    id: node.id,
+    value,
+    valueType: "scalar",
+    metadata: cloneJsonLike2(node.metadata)
+  };
+}
+function cloneJsonLike2(value) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function validateRemapDefaults(nodes) {
+  const issues = [];
+  nodes.forEach((node) => {
+    if (node.type !== "centered_remap") {
+      return;
+    }
+    const defaults = node.inputDefaults ?? {};
+    [
+      "in_low",
+      "in_anchor",
+      "in_high",
+      "out_low",
+      "out_anchor",
+      "out_high"
+    ].forEach((key) => {
+      const value = defaults[key];
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        issues.push(`Remap node ${node.id} missing ${key} default.`);
+      }
+    });
+  });
+  return issues;
+}
+
+// src/ir/inspection.ts
+var import_metadata3 = require("@vizij/node-graph-wasm/metadata");
+var MACHINE_REPORT_VERSION = 1;
+var REMAP_KEYS = [
+  "inLow",
+  "inAnchor",
+  "inHigh",
+  "outLow",
+  "outAnchor",
+  "outHigh"
+];
+var DEFAULT_DIFF_LIMIT = 50;
+function buildMachineReport(result) {
+  return {
+    reportVersion: MACHINE_REPORT_VERSION,
+    faceId: result.summary.faceId,
+    summary: normalizeSummary(result.summary),
+    issues: normalizeIssues(result.issues),
+    irGraph: result.ir?.graph ? normalizeIrGraph(result.ir.graph) : void 0
+  };
+}
+function diffMachineReports(actual, expected, options) {
+  const limit = normalizeDiffLimit(options?.limit);
+  const ctx = {
+    differences: [],
+    limit,
+    limitReached: false
+  };
+  diffValues(actual, expected, "$", ctx);
+  return {
+    equal: ctx.differences.length === 0,
+    differences: ctx.differences,
+    limitReached: ctx.limitReached
+  };
+}
+function normalizeSummary(summary) {
+  return {
+    faceId: summary.faceId,
+    inputs: [...summary.inputs].sort(),
+    outputs: [...summary.outputs].sort(),
+    bindings: normalizeGraphBindingSummaries(summary.bindings)
+  };
+}
+function normalizeGraphBindingSummaries(bindings) {
+  const normalized = bindings.map((binding) => ({
+    targetId: binding.targetId,
+    animatableId: binding.animatableId,
+    component: binding.component ?? void 0,
+    slotId: binding.slotId,
+    slotAlias: binding.slotAlias,
+    inputId: binding.inputId ?? null,
+    remap: normalizeRemap2(binding.remap),
+    expression: binding.expression,
+    valueType: binding.valueType,
+    nodeId: binding.nodeId,
+    expressionNodeId: binding.expressionNodeId,
+    issues: normalizeStringArray(binding.issues),
+    metadata: cloneBindingMetadata(binding.metadata)
+  }));
+  normalized.sort((a, b) => bindingSortKey(a).localeCompare(bindingSortKey(b)));
+  return normalized;
+}
+function cloneBindingMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  return JSON.parse(JSON.stringify(metadata));
+}
+function normalizeIssues(issues) {
+  const byTargetEntries = Object.entries(issues.byTarget ?? {}).map(
+    ([targetId, messages]) => [targetId, [...messages].sort()]
+  );
+  byTargetEntries.sort(([a], [b]) => a.localeCompare(b));
+  const byTarget = {};
+  byTargetEntries.forEach(([targetId, messages]) => {
+    byTarget[targetId] = messages;
+  });
+  return {
+    fatal: [...issues.fatal].sort(),
+    byTarget
+  };
+}
+function normalizeIrGraph(graph) {
+  return {
+    id: graph.id,
+    faceId: graph.faceId,
+    nodes: normalizeIrNodes(graph.nodes),
+    edges: normalizeIrEdges(graph.edges),
+    constants: normalizeIrConstants(graph.constants),
+    issues: normalizeIrIssues(graph.issues),
+    summary: normalizeIrGraphSummary(graph.summary),
+    metadata: normalizeIrMetadata(graph.metadata)
+  };
+}
+function normalizeIrNodes(nodes) {
+  return [...nodes].map((node) => ({
+    ...node,
+    inputDefaults: node.inputDefaults ? sortPlainObject(node.inputDefaults) : void 0,
+    params: node.params ? sortPlainObject(node.params) : void 0,
+    metadata: node.metadata ? sortPlainObject(node.metadata) : void 0,
+    annotations: buildNodeAnnotations(node)
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}
+function normalizeIrEdges(edges) {
+  return [...edges].map((edge) => ({
+    ...edge,
+    from: normalizePortRef(edge.from),
+    to: normalizePortRef(edge.to),
+    metadata: edge.metadata ? sortPlainObject(edge.metadata) : void 0
+  })).sort((a, b) => edgeSortKey(a).localeCompare(edgeSortKey(b)));
+}
+function normalizePortRef(edgeRef) {
+  return {
+    nodeId: edgeRef.nodeId,
+    portId: edgeRef.portId ?? void 0,
+    component: edgeRef.component ?? void 0
+  };
+}
+function edgeSortKey(edge) {
+  if (edge.id) {
+    return edge.id;
+  }
+  const fromPort = edge.from.portId ?? "";
+  const toPort = edge.to.portId ?? "";
+  return `${edge.from.nodeId}:${fromPort}->${edge.to.nodeId}:${toPort}`;
+}
+function normalizeIrConstants(constants) {
+  return [...constants].map((constant) => ({
+    ...constant,
+    metadata: constant.metadata ? sortPlainObject(constant.metadata) : void 0
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}
+function normalizeIrIssues(issues) {
+  return [...issues].map((issue) => ({
+    ...issue,
+    tags: normalizeStringArray(issue.tags),
+    details: issue.details ? sortPlainObject(issue.details) : void 0
+  })).sort((a, b) => a.id.localeCompare(b.id));
+}
+function normalizeIrGraphSummary(summary) {
+  return {
+    faceId: summary.faceId,
+    inputs: [...summary.inputs].sort(),
+    outputs: [...summary.outputs].sort(),
+    bindings: normalizeIrBindingSummaries(summary.bindings)
+  };
+}
+function normalizeIrBindingSummaries(bindings) {
+  const normalized = bindings.map((binding) => ({
+    ...binding,
+    remap: sortPlainObject(binding.remap),
+    issues: normalizeStringArray(binding.issues)
+  }));
+  normalized.sort((a, b) => bindingSortKey(a).localeCompare(bindingSortKey(b)));
+  return normalized;
+}
+function normalizeIrMetadata(metadata) {
+  const normalized = {
+    source: metadata.source ?? "unknown"
+  };
+  if (metadata.registryVersion) {
+    normalized.registryVersion = metadata.registryVersion;
+  }
+  if (metadata.annotations) {
+    const sorted = sortPlainObject(metadata.annotations);
+    if (Object.keys(sorted).length > 0) {
+      normalized.annotations = sorted;
+    }
+  }
+  return normalized;
+}
+function buildNodeAnnotations(node) {
+  const signature = findRegistrySignature(node.type);
+  if (!signature) {
+    return void 0;
+  }
+  return {
+    registry: normalizeRegistrySignature(signature)
+  };
+}
+function findRegistrySignature(typeId) {
+  try {
+    const signature = (0, import_metadata3.findNodeSignature)(typeId);
+    if (!signature) {
+      return void 0;
+    }
+    return signature;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeRegistrySignature(signature) {
+  return {
+    typeId: signature.type_id,
+    name: signature.name,
+    category: signature.category,
+    doc: signature.doc,
+    inputs: signature.inputs.map(normalizeRegistryPortSpec),
+    variadicInputs: signature.variadic_inputs ? normalizeRegistryVariadicSpec(signature.variadic_inputs) : void 0,
+    outputs: signature.outputs.map(normalizeRegistryPortSpec),
+    variadicOutputs: signature.variadic_outputs ? normalizeRegistryVariadicSpec(signature.variadic_outputs) : void 0,
+    params: signature.params.map(normalizeRegistryParamSpec)
+  };
+}
+function normalizeRegistryPortSpec(port) {
+  const normalized = {
+    id: port.id,
+    label: port.label,
+    type: port.ty ?? "unknown"
+  };
+  if (port.doc) {
+    normalized.doc = port.doc;
+  }
+  if (port.optional) {
+    normalized.optional = true;
+  }
+  return normalized;
+}
+function normalizeRegistryVariadicSpec(spec) {
+  const normalized = {
+    id: spec.id,
+    label: spec.label,
+    type: spec.ty ?? "unknown",
+    min: spec.min
+  };
+  if (spec.doc) {
+    normalized.doc = spec.doc;
+  }
+  if (typeof spec.max === "number") {
+    normalized.max = spec.max;
+  }
+  return normalized;
+}
+function normalizeRegistryParamSpec(param) {
+  const normalized = {
+    id: param.id,
+    label: param.label,
+    type: param.ty ?? "unknown"
+  };
+  if (param.doc) {
+    normalized.doc = param.doc;
+  }
+  if (param.default_json !== void 0) {
+    normalized.defaultValue = normalizePlainValue(param.default_json);
+  }
+  if (typeof param.min === "number") {
+    normalized.min = param.min;
+  }
+  if (typeof param.max === "number") {
+    normalized.max = param.max;
+  }
+  return normalized;
+}
+function normalizeRemap2(remap) {
+  const normalized = {};
+  REMAP_KEYS.forEach((key) => {
+    normalized[key] = remap[key];
+  });
+  return normalized;
+}
+function normalizeStringArray(values) {
+  if (!values || values.length === 0) {
+    return void 0;
+  }
+  const unique = Array.from(new Set(values));
+  unique.sort();
+  return unique;
+}
+function bindingSortKey(binding) {
+  const component = binding.component ?? "";
+  return `${binding.targetId}::${component}::${binding.slotId}::${binding.slotAlias}::${binding.animatableId}`;
+}
+function sortPlainObject(record) {
+  const sorted = {};
+  Object.keys(record).sort().forEach((key) => {
+    sorted[key] = normalizePlainValue(record[key]);
+  });
+  return sorted;
+}
+function normalizePlainValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizePlainValue(entry));
+  }
+  if (isPlainObject(value)) {
+    return sortPlainObject(value);
+  }
+  return value;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function diffValues(actual, expected, path, ctx) {
+  if (ctx.differences.length >= ctx.limit) {
+    ctx.limitReached = true;
+    return;
+  }
+  if (Object.is(actual, expected)) {
+    return;
+  }
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    const compareLength = Math.min(actual.length, expected.length);
+    for (let index = 0; index < compareLength; index += 1) {
+      diffValues(actual[index], expected[index], pathIndex(path, index), ctx);
+      if (ctx.differences.length >= ctx.limit) {
+        ctx.limitReached = true;
+        return;
+      }
+    }
+    if (actual.length > expected.length) {
+      for (let index = compareLength; index < actual.length; index += 1) {
+        pushDifference(ctx, {
+          kind: "unexpected",
+          path: pathIndex(path, index),
+          actual: actual[index]
+        });
+        if (ctx.differences.length >= ctx.limit) {
+          ctx.limitReached = true;
+          return;
+        }
+      }
+    } else if (expected.length > actual.length) {
+      for (let index = compareLength; index < expected.length; index += 1) {
+        pushDifference(ctx, {
+          kind: "missing",
+          path: pathIndex(path, index),
+          expected: expected[index]
+        });
+        if (ctx.differences.length >= ctx.limit) {
+          ctx.limitReached = true;
+          return;
+        }
+      }
+    }
+    return;
+  }
+  if (isPlainObject(actual) && isPlainObject(expected)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(actual), ...Object.keys(expected)]);
+    const sortedKeys = Array.from(keys).sort();
+    for (const key of sortedKeys) {
+      if (!(key in actual)) {
+        pushDifference(ctx, {
+          kind: "missing",
+          path: pathKey(path, key),
+          expected: expected[key]
+        });
+      } else if (!(key in expected)) {
+        pushDifference(ctx, {
+          kind: "unexpected",
+          path: pathKey(path, key),
+          actual: actual[key]
+        });
+      } else {
+        diffValues(actual[key], expected[key], pathKey(path, key), ctx);
+      }
+      if (ctx.differences.length >= ctx.limit) {
+        ctx.limitReached = true;
+        return;
+      }
+    }
+    return;
+  }
+  pushDifference(ctx, {
+    kind: "mismatch",
+    path,
+    actual,
+    expected
+  });
+}
+function pathKey(base, key) {
+  if (base === "") {
+    return key;
+  }
+  if (base.endsWith("]")) {
+    return `${base}.${key}`;
+  }
+  return `${base}.${key}`;
+}
+function pathIndex(base, index) {
+  return `${base}[${index}]`;
+}
+function pushDifference(ctx, entry) {
+  if (ctx.differences.length < ctx.limit) {
+    ctx.differences.push(entry);
+    if (ctx.differences.length === ctx.limit) {
+      ctx.limitReached = true;
+    }
+  } else {
+    ctx.limitReached = true;
+  }
+}
+function normalizeDiffLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) {
+    return DEFAULT_DIFF_LIMIT;
+  }
+  return Math.floor(limit);
+}
+
+// src/cli/reportIr.ts
+function usage() {
+  console.error(
+    [
+      "Usage: vizij-ir-report --input <path/to/buildGraphOptions.json> [options]",
+      "",
+      "Options:",
+      "  --dump <path|->         Write normalized machine-readable report (use '-' for stdout).",
+      "  --diff <path|->         Compare against a dumped report (use '-' or 'stdin').",
+      "  --diff-limit <number>   Maximum diff entries to emit (default 50).",
+      "  -h, --help              Show this message."
+    ].join("\n")
+  );
+  process.exit(1);
+  throw new Error("Unreachable");
+}
+function parseArgs(argv) {
+  const args = [...argv];
+  let inputPath = "";
+  let dumpPath;
+  let diffPath;
+  let diffLimit;
+  while (args.length > 0) {
+    const token = args.shift();
+    if (!token) {
+      break;
+    }
+    if (token === "--input" || token === "-i") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      inputPath = value;
+    } else if (token === "--help" || token === "-h") {
+      usage();
+    } else if (token === "--dump" || token === "--dump-json") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      dumpPath = normalizeStreamToken(value);
+    } else if (token === "--diff") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      diffPath = normalizeStreamToken(value);
+    } else if (token === "--diff-limit") {
+      const value = args.shift();
+      if (!value) {
+        usage();
+      }
+      diffLimit = parsePositiveInteger(value, "--diff-limit");
+    } else if (!token.startsWith("--") && !inputPath) {
+      inputPath = token;
+    }
+  }
+  if (!inputPath) {
+    usage();
+  }
+  return {
+    inputPath: (0, import_node_path.resolve)(process.cwd(), inputPath),
+    dumpPath: resolveOptionalPath(dumpPath),
+    diffPath: resolveOptionalPath(diffPath),
+    diffLimit
+  };
+}
+function loadCliInput(path) {
+  const raw = JSON.parse((0, import_node_fs.readFileSync)(path, "utf-8"));
+  const inputs = raw.inputs ?? [];
+  const inputsById = new Map(inputs.map((input) => [input.id, input]));
+  const inputMetadata = raw.inputMetadata ? new Map(
+    raw.inputMetadata.map((entry) => ({
+      id: entry.id,
+      value: entry
+    })).filter(
+      (entry) => Boolean(entry.id)
+    ).map((entry) => [entry.id, entry.value])
+  ) : void 0;
+  return {
+    faceId: raw.faceId,
+    animatables: raw.animatables,
+    components: raw.components,
+    bindings: raw.bindings,
+    inputsById,
+    inputBindings: raw.inputBindings ?? {},
+    inputMetadata
+  };
+}
+function printIssues(result) {
+  console.log(`
+IR Diagnostics for face "${result.summary.faceId}"`);
+  if (result.issues.fatal.length === 0) {
+    console.log("\u2022 No fatal binding issues detected.");
+  } else {
+    console.log("\u2022 Fatal issues:");
+    result.issues.fatal.forEach((issue) => console.log(`  - ${issue}`));
+  }
+  const targets = Object.entries(result.issues.byTarget);
+  if (targets.length > 0) {
+    console.log("\nPer-binding issues:");
+    targets.forEach(([targetId, issues]) => {
+      issues.forEach((issue) => {
+        console.log(`  - ${targetId}: ${issue}`);
+      });
+    });
+  }
+  const irIssues = result.ir?.graph.issues ?? [];
+  if (irIssues.length > 0) {
+    console.log("\nIR issues:");
+    irIssues.forEach((issue) => {
+      console.log(
+        `  - (${issue.severity}) ${issue.message}${issue.targetId ? ` [${issue.targetId}]` : ""}`
+      );
+    });
+  }
+}
+function printBindingSummary(result, _options) {
+  console.log("\nBinding summary:");
+  result.summary.bindings.forEach((binding) => {
+    console.log(
+      `  - ${binding.targetId} (${binding.slotAlias}): expr="${binding.expression}"`
+    );
+    if (binding.issues && binding.issues.length > 0) {
+      binding.issues.forEach((issue) => {
+        console.log(`      \u2022 ${issue}`);
+      });
+    }
+  });
+}
+async function main() {
+  const { inputPath, dumpPath, diffPath, diffLimit } = parseArgs(
+    process.argv.slice(2)
+  );
+  const options = loadCliInput(inputPath);
+  const result = buildRigGraphSpec(options);
+  const machineReport = buildMachineReport(result);
+  if (diffPath && dumpPath && diffPath !== "-" && dumpPath !== "-" && diffPath === dumpPath) {
+    throw new Error(
+      "Cannot reuse the same file path for --dump and --diff. Provide separate files."
+    );
+  }
+  if (diffPath) {
+    if (dumpPath === "-") {
+      throw new Error("Cannot dump to stdout while running --diff.");
+    }
+    if (dumpPath) {
+      writeMachineDump(machineReport, dumpPath);
+    }
+    const baseline = loadMachineDump(diffPath);
+    validateReportVersion(baseline.reportVersion);
+    const diffResult = diffMachineReports(machineReport, baseline, {
+      limit: diffLimit
+    });
+    const diffPayload = {
+      mode: "diff",
+      reportVersion: MACHINE_REPORT_VERSION,
+      faceId: machineReport.faceId,
+      inputPath,
+      baselinePath: diffPath,
+      equal: diffResult.equal,
+      differenceCount: diffResult.differences.length,
+      limitReached: diffResult.limitReached,
+      differences: diffResult.differences
+    };
+    console.log(JSON.stringify(diffPayload, null, 2));
+    process.exitCode = diffResult.equal ? 0 : 1;
+    return;
+  }
+  if (dumpPath) {
+    writeMachineDump(machineReport, dumpPath);
+    return;
+  }
+  console.log(
+    `Loaded ${options.components.length} components / ${options.faceId} from ${inputPath}`
+  );
+  printIssues(result);
+  printBindingSummary(result, options);
+  console.log("\nDone.");
+}
+main().catch((error) => {
+  console.error("[vizij-ir-report] Failed:", error);
+  process.exit(1);
+});
+function resolveOptionalPath(path) {
+  if (!path || path === "-") {
+    return path;
+  }
+  return (0, import_node_path.resolve)(process.cwd(), path);
+}
+function normalizeStreamToken(value) {
+  const lower = value.toLowerCase();
+  if (lower === "-" || lower === "stdout" || lower === "stdin") {
+    return "-";
+  }
+  return value;
+}
+function parsePositiveInteger(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    console.error(`Invalid value for ${flag}: ${value}`);
+    usage();
+  }
+  return parsed;
+}
+function writeMachineDump(report, target) {
+  const payload = `${JSON.stringify(report, null, 2)}
+`;
+  if (target === "-") {
+    process.stdout.write(payload);
+    return;
+  }
+  (0, import_node_fs.writeFileSync)(target, payload, "utf-8");
+}
+function loadMachineDump(path) {
+  const content = path === "-" ? (0, import_node_fs.readFileSync)(0, "utf-8") : (0, import_node_fs.readFileSync)(path, "utf-8");
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.reportVersion !== "number") {
+      throw new Error("Invalid machine report structure.");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("Failed to parse machine-readable report JSON.");
+    }
+    throw error;
+  }
+}
+function validateReportVersion(version) {
+  if (version !== MACHINE_REPORT_VERSION) {
+    throw new Error(
+      `Machine report version mismatch (expected ${MACHINE_REPORT_VERSION}, received ${version}).`
+    );
+  }
+}