@vizij/node-graph-authoring 0.0.4 → 0.0.5

package/dist/index.cjs

@@ -20,37 +20,46 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  EXPRESSION_FUNCTION_VOCABULARY: () => EXPRESSION_FUNCTION_VOCABULARY,
+  MACHINE_REPORT_VERSION: () => MACHINE_REPORT_VERSION,
   PRIMARY_SLOT_ALIAS: () => PRIMARY_SLOT_ALIAS,
   PRIMARY_SLOT_ID: () => PRIMARY_SLOT_ID,
+  RESERVED_EXPRESSION_VARIABLES: () => RESERVED_EXPRESSION_VARIABLES,
+  SCALAR_FUNCTIONS: () => SCALAR_FUNCTIONS,
+  SCALAR_FUNCTION_VOCABULARY: () => SCALAR_FUNCTION_VOCABULARY,
   addBindingSlot: () => addBindingSlot,
   bindingFromDefinition: () => bindingFromDefinition,
-  bindingOperatorDefinitions: () => bindingOperatorDefinitions,
-  bindingOperatorTypes: () => bindingOperatorTypes,
   bindingTargetFromComponent: () => bindingTargetFromComponent,
   bindingTargetFromInput: () => bindingTargetFromInput,
   bindingToDefinition: () => bindingToDefinition,
+  buildCanonicalBindingExpression: () => buildCanonicalBindingExpression,
+  buildDefaultSlotExpression: () => buildDefaultSlotExpression,
+  buildMachineReport: () => buildMachineReport,
+  buildPiecewiseRemapExpression: () => buildPiecewiseRemapExpression,
   buildRigGraphSpec: () => buildRigGraphSpec,
   collectExpressionReferences: () => collectExpressionReferences,
+  compileIrGraph: () => compileIrGraph,
   createDefaultBinding: () => createDefaultBinding,
   createDefaultBindings: () => createDefaultBindings,
   createDefaultInputValues: () => createDefaultInputValues,
-  createDefaultOperatorSettings: () => createDefaultOperatorSettings,
   createDefaultParentBinding: () => createDefaultParentBinding,
   createDefaultRemap: () => createDefaultRemap,
+  createExpressionVariableTable: () => createExpressionVariableTable,
+  createIrGraphBuilder: () => createIrGraphBuilder,
+  createLegacyIrGraph: () => createLegacyIrGraph,
+  diffMachineReports: () => diffMachineReports,
   ensureBindingStructure: () => ensureBindingStructure,
-  ensureOperatorParams: () => ensureOperatorParams,
-  getBindingOperatorDefinition: () => getBindingOperatorDefinition,
   getPrimaryBindingSlot: () => getPrimaryBindingSlot,
   mapExpression: () => mapExpression,
   parseControlExpression: () => parseControlExpression,
   reconcileBindings: () => reconcileBindings,
   remapValue: () => remapValue,
   removeBindingSlot: () => removeBindingSlot,
-  setBindingOperatorEnabled: () => setBindingOperatorEnabled,
+  toIrBindingSummary: () => toIrBindingSummary,
   updateBindingExpression: () => updateBindingExpression,
-  updateBindingOperatorParam: () => updateBindingOperatorParam,
   updateBindingSlotAlias: () => updateBindingSlotAlias,
   updateBindingSlotRemap: () => updateBindingSlotRemap,
+  updateBindingSlotValueType: () => updateBindingSlotValueType,
   updateBindingWithInput: () => updateBindingWithInput
 });
 module.exports = __toCommonJS(index_exports);
@@ -61,84 +70,6 @@ var import_utils3 = require("@vizij/utils");
 
 // src/state.ts
 var import_utils = require("@vizij/utils");
-
-// src/operators.ts
-var import_metadata = require("@vizij/node-graph-wasm/metadata");
-var OPERATOR_TYPES = [
-  "spring",
-  "damp",
-  "slew"
-];
-function valueJsonToNumber(value) {
-  if (!value || typeof value !== "object") {
-    return typeof value === "number" ? value : 0;
-  }
-  if ("float" in value && typeof value.float === "number") {
-    return value.float;
-  }
-  if ("int" in value && typeof value.int === "number") {
-    return value.int;
-  }
-  return 0;
-}
-var operatorDefinitionMap = /* @__PURE__ */ new Map();
-OPERATOR_TYPES.forEach((type) => {
-  const signature = (0, import_metadata.requireNodeSignature)(type);
-  const params = signature.params.map(
-    (param) => ({
-      id: param.id,
-      label: param.label,
-      doc: param.doc,
-      min: param.min ?? void 0,
-      max: param.max ?? void 0,
-      defaultValue: valueJsonToNumber(param.default_json)
-    })
-  );
-  operatorDefinitionMap.set(type, {
-    type,
-    nodeType: signature.type_id,
-    label: signature.name,
-    description: signature.doc,
-    inputs: signature.inputs.map((input) => input.id),
-    params
-  });
-});
-function getBindingOperatorDefinition(type) {
-  const definition = operatorDefinitionMap.get(type);
-  if (!definition) {
-    throw new Error(`Unknown binding operator type '${type}'.`);
-  }
-  return definition;
-}
-var bindingOperatorDefinitions = OPERATOR_TYPES.map((type) => getBindingOperatorDefinition(type));
-function createDefaultOperatorSettings(type) {
-  const definition = getBindingOperatorDefinition(type);
-  const params = {};
-  definition.params.forEach((param) => {
-    params[param.id] = param.defaultValue;
-  });
-  return {
-    type,
-    enabled: false,
-    params
-  };
-}
-function ensureOperatorParams(operator) {
-  const definition = getBindingOperatorDefinition(operator.type);
-  const params = {};
-  definition.params.forEach((param) => {
-    const value = operator.params?.[param.id];
-    params[param.id] = typeof value === "number" ? value : param.defaultValue;
-  });
-  return {
-    type: operator.type,
-    enabled: !!operator.enabled,
-    params
-  };
-}
-var bindingOperatorTypes = OPERATOR_TYPES;
-
-// src/state.ts
 var VECTOR_ANIMATABLE_TYPES = /* @__PURE__ */ new Set(["vector2", "vector3", "euler", "rgb"]);
 function deriveComponentValueType(component) {
   if (component.component) {
@@ -184,83 +115,6 @@ var LEGACY_SLOT_PATTERN = /^slot_(\d+)$/i;
 var ALIAS_SANITIZE_PATTERN = /[^A-Za-z0-9_]+/g;
 var PRIMARY_SLOT_ID = "s1";
 var PRIMARY_SLOT_ALIAS = "s1";
-function createDefaultOperators() {
-  return bindingOperatorTypes.map(
-    (type) => createDefaultOperatorSettings(type)
-  );
-}
-function normalizeOperator(operator) {
-  const normalized = ensureOperatorParams(operator);
-  const definition = getBindingOperatorDefinition(normalized.type);
-  const params = {};
-  definition.params.forEach((param) => {
-    const value = normalized.params[param.id];
-    params[param.id] = typeof value === "number" ? value : param.defaultValue;
-  });
-  return {
-    type: normalized.type,
-    enabled: !!normalized.enabled,
-    params
-  };
-}
-function ensureOperators(binding) {
-  const existing = /* @__PURE__ */ new Map();
-  (binding.operators ?? []).forEach((operator) => {
-    try {
-      existing.set(operator.type, normalizeOperator(operator));
-    } catch {
-    }
-  });
-  return bindingOperatorTypes.map((type) => {
-    const current = existing.get(type);
-    if (current) {
-      return current;
-    }
-    return createDefaultOperatorSettings(type);
-  });
-}
-function paramsEqual(a, b) {
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) {
-    return false;
-  }
-  for (const key of aKeys) {
-    if (a[key] !== b[key]) {
-      return false;
-    }
-  }
-  return true;
-}
-function operatorsEqual(a, b) {
-  if (!a || a.length !== b.length) {
-    return false;
-  }
-  for (let index = 0; index < a.length; index += 1) {
-    const left = a[index];
-    const right = b[index];
-    if (left.type !== right.type || left.enabled !== right.enabled) {
-      return false;
-    }
-    if (!paramsEqual(left.params, right.params)) {
-      return false;
-    }
-  }
-  return true;
-}
-function normalizeBindingWithOperators(binding) {
-  const operators = ensureOperators(binding);
-  if (operatorsEqual(binding.operators, operators)) {
-    return { binding, operators };
-  }
-  return {
-    binding: {
-      ...binding,
-      operators
-    },
-    operators
-  };
-}
 function defaultSlotId(index) {
   return `s${index + 1}`;
 }
@@ -415,6 +269,12 @@ function normalizeRemap(remap, target) {
 function cloneRemap(remap) {
   return (0, import_utils.cloneRemapSettings)(remap);
 }
+function cloneBindingMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  return JSON.parse(JSON.stringify(metadata));
+}
 function sanitizeRemap(remap, target) {
   const normalized = normalizeRemap(remap, target);
   const outputDefaults = deriveOutputDefaults(target);
@@ -462,21 +322,21 @@ function createDefaultBindings(components) {
 function createDefaultBinding(component) {
   const remap = createDefaultRemap(component);
   const valueType = getTargetValueType(component);
+  const slots = [
+    {
+      id: PRIMARY_SLOT_ID,
+      alias: PRIMARY_SLOT_ALIAS,
+      inputId: null,
+      remap: cloneRemap(remap),
+      valueType
+    }
+  ];
   return {
     targetId: component.id,
     inputId: null,
     remap,
-    slots: [
-      {
-        id: PRIMARY_SLOT_ID,
-        alias: PRIMARY_SLOT_ALIAS,
-        inputId: null,
-        remap: cloneRemap(remap),
-        valueType
-      }
-    ],
-    expression: PRIMARY_SLOT_ALIAS,
-    operators: createDefaultOperators()
+    slots,
+    expression: buildCanonicalExpressionFromSlots(slots)
   };
 }
 function createDefaultParentBinding(component) {
@@ -496,7 +356,7 @@ function createDefaultParentBinding(component) {
     ...ensured,
     inputId: import_utils.SELF_BINDING_ID,
     slots,
-    expression: "self"
+    expression: buildCanonicalExpressionFromSlots(slots)
   };
 }
 function ensurePrimarySlot(binding, target) {
@@ -562,8 +422,13 @@ function ensurePrimarySlot(binding, target) {
     };
   });
   const rawExpression = typeof binding.expression === "string" ? binding.expression.trim() : "";
-  let expression = rawExpression.length > 0 ? rawExpression : normalizedSlots[0].alias;
-  expression = rewriteLegacyExpression(expression, aliasReplacements);
+  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,
@@ -571,14 +436,7 @@ function ensurePrimarySlot(binding, target) {
     slots: normalizedSlots,
     expression
   };
-  const operators = ensureOperators(normalizedBinding);
-  if (operatorsEqual(normalizedBinding.operators, operators)) {
-    return normalizedBinding;
-  }
-  return {
-    ...normalizedBinding,
-    operators
-  };
+  return normalizedBinding;
 }
 function createDefaultInputValues(inputs = []) {
   const values = {};
@@ -689,87 +547,44 @@ function updateBindingSlotAlias(binding, target, slotId, nextAlias) {
   );
   return updated;
 }
-function setBindingOperatorEnabled(binding, type, enabled) {
-  const { binding: normalizedBinding, operators } = normalizeBindingWithOperators(binding);
-  let changed = false;
-  const nextOperators = operators.map((operator) => {
-    if (operator.type !== type) {
-      return operator;
-    }
-    if (operator.enabled === enabled) {
-      return operator;
-    }
-    changed = true;
-    return {
-      ...operator,
-      enabled
-    };
-  });
-  if (!changed) {
-    return normalizedBinding;
-  }
-  if (operatorsEqual(normalizedBinding.operators, nextOperators)) {
-    return normalizedBinding;
+function updateBindingSlotValueType(binding, target, slotId, nextValueType) {
+  const base = ensurePrimarySlot(binding, target);
+  const slotIndex = base.slots.findIndex((slot) => slot.id === slotId);
+  if (slotIndex < 0) {
+    return base;
   }
-  return {
-    ...normalizedBinding,
-    operators: nextOperators
-  };
-}
-function updateBindingOperatorParam(binding, type, paramId, value) {
-  const { binding: normalizedBinding, operators } = normalizeBindingWithOperators(binding);
-  const definition = getBindingOperatorDefinition(type);
-  const paramDefinition = definition.params.find(
-    (param) => param.id === paramId
+  const normalizedType = sanitizeSlotValueType(
+    nextValueType,
+    getTargetValueType(target)
   );
-  if (!paramDefinition) {
-    return normalizedBinding;
-  }
-  let nextValue = value;
-  if (typeof paramDefinition.min === "number") {
-    nextValue = Math.max(paramDefinition.min, nextValue);
-  }
-  if (typeof paramDefinition.max === "number") {
-    nextValue = Math.min(paramDefinition.max, nextValue);
-  }
-  let changed = false;
-  const nextOperators = operators.map((operator) => {
-    if (operator.type !== type) {
-      return operator;
-    }
-    if (operator.params[paramId] === nextValue) {
-      return operator;
+  const slots = base.slots.map((slot, index) => {
+    if (index !== slotIndex) {
+      return slot;
     }
-    changed = true;
     return {
-      ...operator,
-      params: {
-        ...operator.params,
-        [paramId]: nextValue
-      }
+      ...slot,
+      valueType: normalizedType
     };
   });
-  if (!changed) {
-    return normalizedBinding;
-  }
-  if (operatorsEqual(normalizedBinding.operators, nextOperators)) {
-    return normalizedBinding;
-  }
   return {
-    ...normalizedBinding,
-    operators: nextOperators
+    ...base,
+    slots
   };
 }
 function updateBindingExpression(binding, target, expression) {
   const base = ensurePrimarySlot(binding, target);
   const trimmed = expression.trim();
+  const canonicalExpression = buildCanonicalExpressionFromSlots(base.slots);
   return {
     ...base,
-    expression: trimmed.length > 0 ? trimmed : base.slots[0]?.alias ?? PRIMARY_SLOT_ALIAS
+    expression: trimmed.length > 0 ? trimmed : canonicalExpression
   };
 }
 function updateBindingSlotRemap(binding, target, slotId, field, value) {
   const base = ensurePrimarySlot(binding, target);
+  const existingExpression = typeof base.expression === "string" ? base.expression.trim() : "";
+  const canonicalBefore = buildCanonicalExpressionFromSlots(base.slots);
+  const expressionWasDefault = expressionMatchesAliasOnly(existingExpression, base.slots) || expressionsEquivalent(existingExpression, canonicalBefore);
   const nextSlots = base.slots.map((slot) => {
     if (slot.id !== slotId) {
       return slot;
@@ -797,10 +612,23 @@ function updateBindingSlotRemap(binding, target, slotId, field, value) {
       [field]: value
     };
   }
-  return updated;
+  if (!expressionWasDefault) {
+    return updated;
+  }
+  const canonicalAfter = buildCanonicalExpressionFromSlots(updated.slots);
+  if (expressionsEquivalent(updated.expression ?? "", canonicalAfter)) {
+    return updated;
+  }
+  return {
+    ...updated,
+    expression: canonicalAfter
+  };
 }
 function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID) {
   const base = ensurePrimarySlot(binding, target);
+  const existingExpression = typeof base.expression === "string" ? base.expression.trim() : "";
+  const canonicalBefore = buildCanonicalExpressionFromSlots(base.slots);
+  const expressionWasDefault = expressionMatchesAliasOnly(existingExpression, base.slots) || expressionsEquivalent(existingExpression, canonicalBefore);
   const slotIndex = base.slots.findIndex((slot) => slot.id === slotId);
   const effectiveIndex = slotIndex >= 0 ? slotIndex : base.slots.length;
   const slots = base.slots.map((slot) => ({
@@ -817,9 +645,10 @@ function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID
     });
   }
   const currentSlot = slots[effectiveIndex];
+  let nextBinding;
   if (!input) {
     const normalizedSlotRemap = sanitizeRemap(currentSlot.remap, target);
-    const updatedRemap2 = {
+    const updatedRemap = {
       ...normalizedSlotRemap,
       inLow: DEFAULT_INPUT_RANGE.min,
       inAnchor: DEFAULT_INPUT_ANCHOR,
@@ -828,45 +657,59 @@ function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID
     slots[effectiveIndex] = {
       ...currentSlot,
       inputId: null,
-      remap: cloneRemap(updatedRemap2)
+      remap: cloneRemap(updatedRemap)
     };
     if (effectiveIndex === 0) {
-      return {
+      nextBinding = {
         ...base,
         inputId: null,
-        remap: cloneRemap(updatedRemap2),
+        remap: cloneRemap(updatedRemap),
+        slots
+      };
+    } else {
+      nextBinding = {
+        ...base,
         slots
       };
     }
-    return {
-      ...base,
-      slots
+  } else {
+    const normalizedRemap = sanitizeRemap(currentSlot.remap, target);
+    const updatedRemap = {
+      ...normalizedRemap,
+      inLow: input.range.min,
+      inAnchor: clamp(input.defaultValue, input.range.min, input.range.max),
+      inHigh: input.range.max,
+      ...deriveOutputDefaults(target)
     };
-  }
-  const normalizedRemap = sanitizeRemap(currentSlot.remap, target);
-  const updatedRemap = {
-    ...normalizedRemap,
-    inLow: input.range.min,
-    inAnchor: clamp(input.defaultValue, input.range.min, input.range.max),
-    inHigh: input.range.max,
-    ...deriveOutputDefaults(target)
-  };
-  slots[effectiveIndex] = {
-    ...currentSlot,
-    inputId: input.id,
-    remap: cloneRemap(updatedRemap)
-  };
-  if (effectiveIndex === 0) {
-    return {
-      ...base,
+    slots[effectiveIndex] = {
+      ...currentSlot,
       inputId: input.id,
-      remap: cloneRemap(updatedRemap),
-      slots
+      remap: cloneRemap(updatedRemap)
     };
+    if (effectiveIndex === 0) {
+      nextBinding = {
+        ...base,
+        inputId: input.id,
+        remap: cloneRemap(updatedRemap),
+        slots
+      };
+    } else {
+      nextBinding = {
+        ...base,
+        slots
+      };
+    }
+  }
+  if (!expressionWasDefault) {
+    return nextBinding;
+  }
+  const canonicalAfter = buildCanonicalExpressionFromSlots(nextBinding.slots);
+  if (expressionsEquivalent(nextBinding.expression ?? "", canonicalAfter)) {
+    return nextBinding;
   }
   return {
-    ...base,
-    slots
+    ...nextBinding,
+    expression: canonicalAfter
   };
 }
 function remapValue(value, remap) {
@@ -932,11 +775,6 @@ function reconcileBindings(previous, components) {
   return next;
 }
 function bindingToDefinition(binding) {
-  const operators = binding.operators ? binding.operators.map((operator) => ({
-    type: operator.type,
-    enabled: !!operator.enabled,
-    params: { ...operator.params }
-  })) : void 0;
   const definition = {
     inputId: binding.inputId ?? null,
     remap: cloneRemap(binding.remap),
@@ -945,7 +783,7 @@ function bindingToDefinition(binding) {
       remap: cloneRemap(slot.remap)
     })),
     expression: binding.expression,
-    operators
+    metadata: cloneBindingMetadata(binding.metadata)
   };
   return definition;
 }
@@ -953,7 +791,6 @@ function bindingFromDefinition(target, definition) {
   if (!definition) {
     return createDefaultBinding(target);
   }
-  const definitionOperators = definition.operators;
   const binding = {
     targetId: target.id,
     inputId: definition.inputId ?? null,
@@ -963,17 +800,91 @@ function bindingFromDefinition(target, definition) {
       remap: cloneRemap(slot.remap)
     })),
     expression: definition.expression,
-    operators: definitionOperators ? definitionOperators.map((operator) => ({
-      type: operator.type,
-      enabled: !!operator.enabled,
-      params: { ...operator.params }
-    })) : void 0
+    metadata: cloneBindingMetadata(definition.metadata)
   };
   return ensureBindingStructure(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);
+}
+function buildCanonicalBindingExpression(binding) {
+  const slots = binding.slots ?? [];
+  return buildCanonicalExpressionFromSlots(slots);
+}
 
 // src/expression.ts
-var WHITESPACE = /\s/;
+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]/;
@@ -1211,6 +1122,10 @@ var ControlExpressionParser = class {
       });
       return null;
     }
+    if (char === "[") {
+      this.index += 1;
+      return this.parseVectorLiteral("]", "vector literal");
+    }
     if (IDENT_START.test(char)) {
       return this.parseIdentifierOrFunction();
     }
@@ -1239,6 +1154,9 @@ var ControlExpressionParser = class {
     this.skipWhitespace();
     if (this.peek() === "(") {
       this.index += 1;
+      if (name.toLowerCase() === "vec") {
+        return this.parseVectorLiteral(")", `"${name}" literal`);
+      }
       const args = [];
       this.skipWhitespace();
       if (this.peek() === ")") {
@@ -1301,28 +1219,134 @@ var ControlExpressionParser = class {
       name
     };
   }
-  parseNumber() {
+  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 === ".") {
+      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 (!hasDigits || Number.isNaN(value)) {
+    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 "${raw}".`
+        message: "Invalid numeric literal."
       });
       return null;
     }
@@ -1341,7 +1365,11 @@ var ControlExpressionParser = class {
     return null;
   }
   skipWhitespace() {
-    while (!this.isAtEnd() && WHITESPACE.test(this.peek())) {
+    while (!this.isAtEnd()) {
+      const char = this.peek();
+      if (!isWhitespaceCharacter(char)) {
+        break;
+      }
       this.index += 1;
     }
   }
@@ -1401,70 +1429,979 @@ function mapExpression(node, visit) {
 }
 
 // src/expressionFunctions.ts
-var import_metadata2 = require("@vizij/node-graph-wasm/metadata");
-var FUNCTION_CONFIGS = [
-  { typeId: "sin", names: ["sin"] },
-  { typeId: "cos", names: ["cos"] },
-  { typeId: "tan", names: ["tan"] },
-  { typeId: "power", names: ["power", "pow"] },
-  { typeId: "log", names: ["log"] },
-  { typeId: "clamp", names: ["clamp"] },
-  { typeId: "add", names: ["add"] },
-  { typeId: "multiply", names: ["multiply"] },
-  { typeId: "subtract", names: ["subtract"] },
-  { typeId: "divide", names: ["divide"] },
-  {
-    typeId: "greaterthan",
-    names: ["greaterthan", "gt"],
+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: "lessthan", names: ["lessthan", "lt"], minArgs: 2, maxArgs: 2 },
-  { typeId: "equal", names: ["equal", "eq"], minArgs: 2, maxArgs: 2 },
   {
-    typeId: "notequal",
-    names: ["notequal", "neq", "ne"],
-    minArgs: 2,
-    maxArgs: 2
+    typeId: "cos",
+    names: ["cos"],
+    category: "math",
+    description: "Cosine of the input value (radians)."
   },
-  { typeId: "and", names: ["and"], minArgs: 2, maxArgs: 2 },
-  { typeId: "or", names: ["or"], minArgs: 2, maxArgs: 2 },
-  { typeId: "xor", names: ["xor"], minArgs: 2, maxArgs: 2 },
-  { typeId: "not", names: ["not"], minArgs: 1, maxArgs: 1 },
-  { typeId: "if", names: ["if"], minArgs: 2, maxArgs: 3 },
-  { typeId: "time", names: ["time"], minArgs: 0, maxArgs: 0 },
-  { typeId: "oscillator", names: ["oscillator"], minArgs: 2, maxArgs: 2 }
-];
-var SCALAR_FUNCTIONS = /* @__PURE__ */ new Map();
-for (const config of FUNCTION_CONFIGS) {
-  const signature = (0, import_metadata2.requireNodeSignature)(config.typeId);
-  const signatureInputs = signature.inputs;
-  const inputs = signatureInputs.map((input) => ({
-    id: input.id,
-    optional: Boolean(input.optional)
-  }));
-  const variadic = signature.variadic_inputs ? {
-    id: signature.variadic_inputs.id,
+  {
+    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: signature.variadic_inputs.max ?? null
+    max: typeof signature.variadic_inputs.max === "number" ? signature.variadic_inputs.max : null,
+    valueType: inferExpressionValueType(signature.variadic_inputs.ty)
   } : null;
-  const derivedMin = variadic ? variadic.min : inputs.filter((input) => !input.optional).length;
-  const derivedMax = variadic ? variadic.max : inputs.length;
-  const minArgs = config.minArgs ?? derivedMin;
-  const maxArgs = config.maxArgs !== void 0 ? config.maxArgs : derivedMax ?? 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
+    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
+  }
+];
+var EXPRESSION_FUNCTION_VOCABULARY = SCALAR_FUNCTION_VOCABULARY;
+
+// 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 createLegacyIrGraph(payload) {
+  const builder = createIrGraphBuilder({
+    faceId: payload.faceId,
+    registryVersion: payload.registryVersion,
+    source: payload.source ?? "legacy-graph-builder",
+    annotations: payload.annotations,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  builder.setSummary(payload.summary);
+  (payload.issues ?? []).forEach((issue) => builder.addIssue(issue));
+  const graph = builder.build();
+  return {
+    ...graph,
+    legacy: { spec: payload.spec }
+  };
+}
+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
@@ -1484,10 +2421,15 @@ function evaluateBinding({
     nodes,
     edges,
     constants: /* @__PURE__ */ new Map(),
-    counter: 0
+    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 aliasNodes = /* @__PURE__ */ new Map();
+  const variableTable = createExpressionVariableTable();
   const slotSummaries = [];
   const expressionIssues = [];
   const rawExpression = typeof binding.expression === "string" ? binding.expression : "";
@@ -1504,6 +2446,11 @@ function evaluateBinding({
       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);
@@ -1511,25 +2458,13 @@ function evaluateBinding({
     } else if (slot.inputId) {
       const inputNode = ensureInputNode(slot.inputId);
       if (inputNode) {
-        const remapNodeId = `remap_${safeId}_${sanitizeNodeId(slotId)}`;
-        nodes.push({
-          id: remapNodeId,
-          type: "centered_remap",
-          input_defaults: {
-            in_low: slot.remap.inLow,
-            in_anchor: slot.remap.inAnchor,
-            in_high: slot.remap.inHigh,
-            out_low: slot.remap.outLow,
-            out_anchor: slot.remap.outAnchor,
-            out_high: slot.remap.outHigh
-          }
-        });
-        edges.push({
-          from: { node_id: inputNode.nodeId },
-          to: { node_id: remapNodeId, input: "in" }
-        });
-        slotOutputId = remapNodeId;
+        slotOutputId = inputNode.nodeId;
         hasActiveSlot = true;
+        setNodeValueType(
+          exprContext,
+          slotOutputId,
+          slotValueType === "vector" ? "vector" : "scalar"
+        );
       } else {
         expressionIssues.push(`Missing standard input "${slot.inputId}".`);
         slotOutputId = getConstantNodeId(exprContext, 0);
@@ -1537,7 +2472,24 @@ function evaluateBinding({
     } else {
       slotOutputId = getConstantNodeId(exprContext, 0);
     }
-    aliasNodes.set(alias, slotOutputId);
+    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,
@@ -1547,12 +2499,32 @@ function evaluateBinding({
       inputId: slot.inputId ?? null,
       remap: { ...slot.remap },
       expression: trimmedExpression,
-      valueType: slotValueType
+      valueType: slotValueType,
+      nodeId: slotOutputId,
+      expressionNodeId: slotOutputId
     });
   });
   if (slotSummaries.length === 0) {
     const alias = PRIMARY_SLOT_ALIAS;
-    aliasNodes.set(alias, getConstantNodeId(exprContext, 0));
+    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,
@@ -1562,26 +2534,51 @@ function evaluateBinding({
       inputId: null,
       remap: createDefaultRemap(target),
       expression: trimmedExpression,
-      valueType: targetValueType
+      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 = collectExpressionReferences(parseResult.node);
-    const missing = [];
-    references.forEach((ref) => {
-      if (!aliasNodes.has(ref)) {
-        missing.push(ref);
-      }
-    });
+    const references = Array.from(
+      collectExpressionReferences(parseResult.node)
+    );
+    const missing = variableTable.missing(references);
     if (missing.length === 0) {
       expressionAst = parseResult.node;
     } else {
-      missing.forEach((ref) => {
-        expressionIssues.push(`Unknown control "${ref}".`);
+      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 {
@@ -1589,22 +2586,30 @@ function evaluateBinding({
       expressionIssues.push(error.message);
     });
   }
+  const expressionMetadata = buildBindingMetadataFromExpression(
+    expressionAst,
+    variableTable
+  );
   let valueNodeId = null;
   if (expressionAst) {
     valueNodeId = materializeExpression(
       expressionAst,
       exprContext,
-      aliasNodes,
+      variableTable,
       expressionIssues
     );
   }
   if (!valueNodeId) {
-    const fallbackAlias = aliasNodes.has(defaultAlias) ? defaultAlias : aliasNodes.keys().next().value;
-    valueNodeId = (fallbackAlias ? aliasNodes.get(fallbackAlias) : void 0) ?? getConstantNodeId(exprContext, 0);
+    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();
@@ -1622,8 +2627,25 @@ function sanitizeNodeId(value) {
   return value.replace(/[^a-zA-Z0-9_]/g, "_");
 }
 function buildRigInputPath(faceId, inputPath) {
-  const trimmed = inputPath.startsWith("/") ? inputPath.slice(1) : inputPath;
-  return `rig/${faceId}/${trimmed}`;
+  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) {
@@ -1679,6 +2701,101 @@ function extractComponentDefault(value, component) {
   }
   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);
@@ -1694,6 +2811,30 @@ function getConstantNodeId(context, value) {
     }
   });
   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) {
@@ -1702,15 +2843,16 @@ function createBinaryOperationNode(context, operator, leftId, rightId) {
     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: { node_id: leftId },
-    to: { node_id: nodeId, input: leftInput }
+    from: { nodeId: leftId },
+    to: { nodeId, portId: leftInput }
   });
   context.edges.push({
-    from: { node_id: rightId },
-    to: { node_id: nodeId, input: rightInput }
+    from: { nodeId: rightId },
+    to: { nodeId, portId: rightInput }
   });
   return nodeId;
 }
@@ -1726,95 +2868,339 @@ function createVariadicOperationNode(context, operator, operandIds) {
     id: nodeId,
     type: operator
   });
+  setNodeValueType(context, nodeId, "scalar");
   operandIds.forEach((operandId, index) => {
     context.edges.push({
-      from: { node_id: operandId },
-      to: { node_id: nodeId, input: `operand_${index + 1}` }
+      from: { nodeId: operandId },
+      to: { nodeId, portId: `operand_${index + 1}` }
     });
   });
   return nodeId;
 }
-function createNamedOperationNode(context, operator, inputNames, operandIds) {
+function createNamedOperationNode(context, operator, inputNames, operandIds, resultType = "scalar", params) {
   const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
-  context.nodes.push({
+  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: { node_id: operandId },
-      to: { node_id: nodeId, input: inputName }
+      from: { nodeId: operandId },
+      to: { nodeId, portId: inputName }
     });
   });
   return nodeId;
 }
-function emitScalarFunctionNode(definition, operands, context) {
+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) {
-    const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
-    context.nodes.push({
-      id: nodeId,
-      type: definition.nodeType
+    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)
     });
-    operands.forEach((operandId, index) => {
+  }
+  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: { node_id: operandId },
+        from: { nodeId: operandId },
         to: {
-          node_id: nodeId,
-          input: `${definition.variadic.id}_${index + 1}`
+          nodeId: nodeId2,
+          portId: `${definition.variadic.id}_${index + 1}`
         }
       });
     });
-    return nodeId;
+    setNodeValueType(context, nodeId2, definition.resultValueType);
+    return nodeId2;
   }
   const providedNames = [];
   const providedOperands = [];
   definition.inputs.forEach((input, index) => {
-    const operandId = operands[index];
+    const operandId = orderedOperands[index];
     if (!operandId) {
       return;
     }
     providedNames.push(input.id);
     providedOperands.push(operandId);
   });
-  return createNamedOperationNode(
+  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,
-    providedNames,
-    providedOperands
+    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 applyBindingOperators(operators, baseNodeId, safeId, nodes, edges) {
-  let currentNodeId = baseNodeId;
-  operators.forEach((operator, index) => {
-    if (!operator.enabled) {
+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;
     }
-    let definition;
-    try {
-      definition = getBindingOperatorDefinition(operator.type);
-    } catch {
-      return;
+    const literal = extractParamLiteral(
+      node,
+      spec,
+      definition.nodeType,
+      issues
+    );
+    if (literal !== null) {
+      assignments[spec.id] = literal;
     }
-    const nodeId = `${operator.type}_${safeId}_${index + 1}`;
-    const params = {};
-    definition.params.forEach((param) => {
-      const configured = operator.params?.[param.id];
-      params[param.id] = typeof configured === "number" ? configured : param.defaultValue;
-    });
-    nodes.push({
-      id: nodeId,
-      type: definition.nodeType,
-      params
-    });
-    const inputId = definition.inputs[0] ?? "in";
-    edges.push({
-      from: { node_id: currentNodeId },
-      to: { node_id: nodeId, input: inputId }
-    });
-    currentNodeId = nodeId;
   });
-  return currentNodeId;
+  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) {
@@ -1824,6 +3210,42 @@ function collectOperands(node, operator, target) {
   }
   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",
@@ -1832,24 +3254,32 @@ var BINARY_FUNCTION_OPERATOR_MAP = {
   "&&": "and",
   "||": "or"
 };
-function materializeExpression(node, context, aliasNodes, issues) {
+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 mapped = aliasNodes.get(node.name);
-      if (!mapped) {
+      const entry = variables.resolve(node.name);
+      if (!entry) {
         issues.push(`Unknown control "${node.name}".`);
         return getConstantNodeId(context, 0);
       }
-      return mapped;
+      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,
-        aliasNodes,
+        variables,
         issues
       );
       switch (node.operator) {
@@ -1868,7 +3298,15 @@ function materializeExpression(node, context, aliasNodes, issues) {
             issues.push('Function "not" is not available in metadata.');
             return getConstantNodeId(context, 0);
           }
-          return emitScalarFunctionNode(definition, [operandId], context);
+          return emitScalarFunctionNode(
+            definition,
+            [operandId],
+            [node.operand],
+            1,
+            context,
+            variables,
+            issues
+          );
         }
         default:
           issues.push("Unsupported unary operator.");
@@ -1881,7 +3319,7 @@ function materializeExpression(node, context, aliasNodes, issues) {
         const children = [];
         collectOperands(node, "+", children);
         const operandIds = children.map(
-          (child) => materializeExpression(child, context, aliasNodes, issues)
+          (child) => materializeExpression(child, context, variables, issues)
         );
         return createVariadicOperationNode(context, "add", operandIds);
       }
@@ -1889,20 +3327,20 @@ function materializeExpression(node, context, aliasNodes, issues) {
         const children = [];
         collectOperands(node, "*", children);
         const operandIds = children.map(
-          (child) => materializeExpression(child, context, aliasNodes, issues)
+          (child) => materializeExpression(child, context, variables, issues)
         );
         return createVariadicOperationNode(context, "multiply", operandIds);
       }
       const leftId = materializeExpression(
         node.left,
         context,
-        aliasNodes,
+        variables,
         issues
       );
       const rightId = materializeExpression(
         node.right,
         context,
-        aliasNodes,
+        variables,
         issues
       );
       if (operator === "-") {
@@ -1918,7 +3356,15 @@ function materializeExpression(node, context, aliasNodes, issues) {
           issues.push(`Function "${mappedFunction}" is not available.`);
           return getConstantNodeId(context, 0);
         }
-        return emitScalarFunctionNode(definition, [leftId, rightId], context);
+        return emitScalarFunctionNode(
+          definition,
+          [leftId, rightId],
+          [node.left, node.right],
+          2,
+          context,
+          variables,
+          issues
+        );
       }
       issues.push(`Unsupported operator "${operator}".`);
       return getConstantNodeId(context, 0);
@@ -1931,22 +3377,61 @@ function materializeExpression(node, context, aliasNodes, issues) {
         issues.push(`Unknown function "${name}".`);
         return getConstantNodeId(context, 0);
       }
-      const operands = node.args.map(
-        (arg) => materializeExpression(arg, context, aliasNodes, issues)
-      );
-      if (operands.length < definition.minArgs) {
+      const argNodes = node.args;
+      const argCount = argNodes.length;
+      if (argCount < definition.minArgs) {
         issues.push(
-          `Function "${name}" expects at least ${definition.minArgs} arguments, received ${operands.length}.`
+          `Function "${name}" expects at least ${definition.minArgs} arguments, received ${argCount}.`
         );
         return getConstantNodeId(context, 0);
       }
-      if (definition.maxArgs !== null && operands.length > definition.maxArgs) {
+      if (definition.maxArgs !== null && argCount > definition.maxArgs) {
         issues.push(
-          `Function "${name}" expects at most ${definition.maxArgs} arguments, received ${operands.length}.`
+          `Function "${name}" expects at most ${definition.maxArgs} arguments, received ${argCount}.`
         );
         return getConstantNodeId(context, 0);
       }
-      return emitScalarFunctionNode(definition, operands, context);
+      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.");
@@ -1960,10 +3445,25 @@ function buildRigGraphSpec({
   components,
   bindings,
   inputsById,
-  inputBindings
+  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();
@@ -2019,7 +3519,9 @@ function buildRigGraphSpec({
             edges,
             ensureInputNode,
             bindingIssues,
-            summaryBindings
+            summaryBindings,
+            graphReservedNodes,
+            generateReservedNodeId
           },
           selfNodeId
         });
@@ -2099,7 +3601,9 @@ function buildRigGraphSpec({
           edges,
           ensureInputNode,
           bindingIssues,
-          summaryBindings
+          summaryBindings,
+          graphReservedNodes,
+          generateReservedNodeId
         }
       });
       valueNodeId = producedNodeId;
@@ -2118,7 +3622,9 @@ function buildRigGraphSpec({
         remap: createDefaultRemap(target),
         expression: PRIMARY_SLOT_ALIAS,
         valueType: target.valueType === "vector" ? "vector" : "scalar",
-        issues: ["Binding not found."]
+        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.");
@@ -2128,15 +3634,7 @@ function buildRigGraphSpec({
       entry.defaults.set(key, component.defaultValue);
       return;
     }
-    const operatorList = binding ? binding.operators ?? [] : [];
-    const finalNodeId = applyBindingOperators(
-      operatorList,
-      valueNodeId,
-      component.safeId,
-      nodes,
-      edges
-    );
-    entry.values.set(key, finalNodeId);
+    entry.values.set(key, valueNodeId);
   });
   inputsById.forEach((_input, inputId) => {
     ensureInputNode(inputId);
@@ -2162,8 +3660,8 @@ function buildRigGraphSpec({
         }
       });
       edges.push({
-        from: { node_id: valueNodeId },
-        to: { node_id: outputNodeId2, input: "in" }
+        from: { nodeId: valueNodeId },
+        to: { nodeId: outputNodeId2, portId: "in" }
       });
       return;
     }
@@ -2190,8 +3688,8 @@ function buildRigGraphSpec({
         sourceId = constNodeId;
       }
       edges.push({
-        from: { node_id: sourceId },
-        to: { node_id: joinNodeId, input: `operand_${index + 1}` }
+        from: { nodeId: sourceId },
+        to: { nodeId: joinNodeId, portId: `operand_${index + 1}` }
       });
     });
     const outputNodeId = `out_${safeId}`;
@@ -2203,8 +3701,8 @@ function buildRigGraphSpec({
       }
     });
     edges.push({
-      from: { node_id: joinNodeId },
-      to: { node_id: outputNodeId, input: "in" }
+      from: { nodeId: joinNodeId },
+      to: { nodeId: outputNodeId, portId: "in" }
     });
   });
   const nodeById = /* @__PURE__ */ new Map();
@@ -2213,7 +3711,7 @@ function buildRigGraphSpec({
   });
   const constantUsage = /* @__PURE__ */ new Map();
   edges.forEach((edge) => {
-    const source = nodeById.get(edge.from.node_id);
+    const source = nodeById.get(edge.from.nodeId);
     if (source?.type === "constant") {
       constantUsage.set(source.id, (constantUsage.get(source.id) ?? 0) + 1);
     }
@@ -2221,15 +3719,16 @@ function buildRigGraphSpec({
   const updatedEdges = [];
   const constantsToRemove = /* @__PURE__ */ new Set();
   edges.forEach((edge) => {
-    const source = nodeById.get(edge.from.node_id);
+    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.node_id);
+      const target = nodeById.get(edge.to.nodeId);
       if (target) {
         const value = source.params.value;
         if (value !== void 0) {
-          target.input_defaults = {
-            ...target.input_defaults ?? {},
-            [edge.to.input]: value
+          const targetPort = edge.to.portId ?? "in";
+          target.inputDefaults = {
+            ...target.inputDefaults ?? {},
+            [targetPort]: value
           };
           nodeById.set(target.id, target);
           constantsToRemove.add(source.id);
@@ -2246,18 +3745,17 @@ function buildRigGraphSpec({
   const filteredSummaryBindings = summaryBindings.filter(
     (binding) => outputs.has(binding.animatableId) || computedInputs.has(binding.animatableId)
   );
-  const spec = {
-    nodes: filteredNodes,
-    edges: updatedEdges.length ? updatedEdges : void 0
-  };
-  const baseSpec = spec;
-  const specWithMetadata = {
-    ...baseSpec,
-    metadata: {
-      ...baseSpec.metadata,
-      vizij: {
-        faceId,
-        inputs: Array.from(inputsById.values()).map((input) => ({
+  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,
@@ -2268,15 +3766,23 @@ function buildRigGraphSpec({
             min: input.range.min,
             max: input.range.max
           }
-        })),
-        bindings: filteredSummaryBindings.map((binding) => ({
-          ...binding,
-          remap: { ...binding.remap },
-          expression: binding.expression,
-          valueType: binding.valueType,
-          issues: binding.issues ? [...binding.issues] : void 0
-        }))
-      }
+        };
+        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 = {};
@@ -2291,29 +3797,149 @@ function buildRigGraphSpec({
     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: specWithMetadata,
-    summary: {
-      faceId,
-      inputs: Array.from(inputNodes.values()).map(
-        ({ input }) => buildRigInputPath(faceId, input.path)
-      ),
-      outputs: [...dynamicOutputs, ...computedInputList],
-      bindings: filteredSummaryBindings
-    },
+    spec: compiled.spec,
+    summary: summaryPayload,
     issues: {
       byTarget: issuesByTarget,
-      fatal: Array.from(fatalIssues)
+      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.input_defaults ?? {};
+    const defaults = node.inputDefaults ?? {};
     [
       "in_low",
       "in_anchor",
@@ -2330,38 +3956,444 @@ function validateRemapDefaults(nodes) {
   });
   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: cloneBindingMetadata2(binding.metadata)
+  }));
+  normalized.sort((a, b) => bindingSortKey(a).localeCompare(bindingSortKey(b)));
+  return normalized;
+}
+function cloneBindingMetadata2(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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EXPRESSION_FUNCTION_VOCABULARY,
+  MACHINE_REPORT_VERSION,
   PRIMARY_SLOT_ALIAS,
   PRIMARY_SLOT_ID,
+  RESERVED_EXPRESSION_VARIABLES,
+  SCALAR_FUNCTIONS,
+  SCALAR_FUNCTION_VOCABULARY,
   addBindingSlot,
   bindingFromDefinition,
-  bindingOperatorDefinitions,
-  bindingOperatorTypes,
   bindingTargetFromComponent,
   bindingTargetFromInput,
   bindingToDefinition,
+  buildCanonicalBindingExpression,
+  buildDefaultSlotExpression,
+  buildMachineReport,
+  buildPiecewiseRemapExpression,
   buildRigGraphSpec,
   collectExpressionReferences,
+  compileIrGraph,
   createDefaultBinding,
   createDefaultBindings,
   createDefaultInputValues,
-  createDefaultOperatorSettings,
   createDefaultParentBinding,
   createDefaultRemap,
+  createExpressionVariableTable,
+  createIrGraphBuilder,
+  createLegacyIrGraph,
+  diffMachineReports,
   ensureBindingStructure,
-  ensureOperatorParams,
-  getBindingOperatorDefinition,
   getPrimaryBindingSlot,
   mapExpression,
   parseControlExpression,
   reconcileBindings,
   remapValue,
   removeBindingSlot,
-  setBindingOperatorEnabled,
+  toIrBindingSummary,
   updateBindingExpression,
-  updateBindingOperatorParam,
   updateBindingSlotAlias,
   updateBindingSlotRemap,
+  updateBindingSlotValueType,
   updateBindingWithInput
 });