@vizij/node-graph-authoring 0.0.4 → 0.0.5

package/dist/index.js

@@ -1,2312 +1,86 @@
-// src/graphBuilder.ts
-import { buildAnimatableValue } from "@vizij/utils";
-import { SELF_BINDING_ID as SELF_BINDING_ID2 } from "@vizij/utils";
-
-// src/state.ts
 import {
-  cloneRemapSettings,
-  SELF_BINDING_ID
-} from "@vizij/utils";
-
-// src/operators.ts
-import { requireNodeSignature } from "@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 = 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) {
-    return "scalar";
-  }
-  return VECTOR_ANIMATABLE_TYPES.has(component.animatableType) ? "vector" : "scalar";
-}
-function isBindingValueType(value) {
-  return value === "scalar" || value === "vector";
-}
-function getTargetValueType(target) {
-  return isBindingValueType(target.valueType) ? target.valueType : "scalar";
-}
-function sanitizeSlotValueType(value, targetType) {
-  return isBindingValueType(value) ? value : targetType;
-}
-function bindingTargetFromComponent(component) {
-  return {
-    id: component.id,
-    defaultValue: component.defaultValue,
-    range: {
-      min: component.range.min,
-      max: component.range.max
-    },
-    valueType: deriveComponentValueType(component)
-  };
-}
-function bindingTargetFromInput(input) {
-  return {
-    id: input.id,
-    defaultValue: input.defaultValue,
-    range: {
-      min: input.range.min,
-      max: input.range.max
-    },
-    valueType: "scalar"
-  };
-}
-var DEFAULT_INPUT_RANGE = { min: -1, max: 1 };
-var DEFAULT_INPUT_ANCHOR = 0;
-var EPSILON = 1e-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}`;
-}
-function normalizeSlotId(value, index) {
-  if (value && value.length > 0) {
-    const match = value.match(LEGACY_SLOT_PATTERN);
-    if (match) {
-      const suffix = match[1] ?? String(index + 1);
-      return `s${suffix}`;
-    }
-    return value;
-  }
-  return defaultSlotId(index);
-}
-function normalizeSlotAlias(value, fallback, index) {
-  if (value && value.length > 0) {
-    const match = value.match(LEGACY_SLOT_PATTERN);
-    if (match) {
-      const suffix = match[1] ?? String(index + 1);
-      return { alias: `s${suffix}`, replaced: value };
-    }
-    return { alias: value, replaced: null };
-  }
-  if (fallback && fallback.length > 0) {
-    return { alias: fallback, replaced: null };
-  }
-  return { alias: defaultSlotId(index), replaced: null };
-}
-function sanitizeAliasInput(raw, fallback, index) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) {
-    return fallback || defaultSlotId(index);
-  }
-  let sanitized = trimmed.replace(/\s+/g, "_").replace(ALIAS_SANITIZE_PATTERN, "");
-  if (sanitized.length === 0) {
-    sanitized = fallback || defaultSlotId(index);
-  }
-  if (/^\d/.test(sanitized)) {
-    sanitized = `s${sanitized}`;
-  }
-  return sanitized;
-}
-function ensureUniqueAlias(candidate, existing) {
-  if (!existing.has(candidate.toLowerCase())) {
-    existing.add(candidate.toLowerCase());
-    return candidate;
-  }
-  let suffix = 2;
-  let next = `${candidate}_${suffix}`;
-  while (existing.has(next.toLowerCase())) {
-    suffix += 1;
-    next = `${candidate}_${suffix}`;
-  }
-  existing.add(next.toLowerCase());
-  return next;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function rewriteLegacyExpression(expression, replacements) {
-  if (expression.trim().length === 0) {
-    return expression;
-  }
-  return expression.replace(/\bslot_(\d+)\b/gi, (match, digits) => {
-    const replacement = replacements.get(match);
-    if (replacement) {
-      return replacement;
-    }
-    return `s${digits}`;
-  });
-}
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function deriveOutputDefaults(target) {
-  const { min, max } = target.range;
-  const anchor = clamp(target.defaultValue, min, max);
-  return {
-    outLow: min,
-    outAnchor: anchor,
-    outHigh: max
-  };
-}
-function deriveInputDefaults() {
-  return {
-    inLow: DEFAULT_INPUT_RANGE.min,
-    inAnchor: DEFAULT_INPUT_ANCHOR,
-    inHigh: DEFAULT_INPUT_RANGE.max
-  };
-}
-function migrateLegacyRemap(legacy, target) {
-  const inputDefaults = deriveInputDefaults();
-  const outputDefaults = deriveOutputDefaults(target);
-  const defaults = {
-    inLow: inputDefaults.inLow,
-    inAnchor: inputDefaults.inAnchor,
-    inHigh: inputDefaults.inHigh,
-    outLow: outputDefaults.outLow,
-    outAnchor: outputDefaults.outAnchor,
-    outHigh: outputDefaults.outHigh
-  };
-  if ("inLow" in legacy && "inHigh" in legacy && "outLow" in legacy && "outHigh" in legacy) {
-    const inLow2 = isFiniteNumber(legacy.inLow) ? legacy.inLow : defaults.inLow;
-    const inAnchor2 = isFiniteNumber(legacy.inAnchor) ? legacy.inAnchor : defaults.inAnchor;
-    const inHigh2 = isFiniteNumber(legacy.inHigh) ? legacy.inHigh : defaults.inHigh;
-    let outLow = isFiniteNumber(legacy.outLow) ? legacy.outLow : defaults.outLow;
-    let outHigh = isFiniteNumber(legacy.outHigh) ? legacy.outHigh : defaults.outHigh;
-    if (outLow > outHigh) {
-      const low = outHigh;
-      const high = outLow;
-      outLow = low;
-      outHigh = high;
-    }
-    const outAnchor2 = clamp(
-      isFiniteNumber(legacy.outAnchor) ? legacy.outAnchor : defaults.outAnchor,
-      outLow,
-      outHigh
-    );
-    return {
-      inLow: inLow2,
-      inAnchor: inAnchor2,
-      inHigh: inHigh2,
-      outLow,
-      outAnchor: outAnchor2,
-      outHigh
-    };
-  }
-  const legacyTyped = legacy;
-  const inLow = isFiniteNumber(legacyTyped.inMin) ? legacyTyped.inMin : defaults.inLow;
-  const inHigh = isFiniteNumber(legacyTyped.inMax) ? legacyTyped.inMax : defaults.inHigh;
-  const inAnchor = (inLow + inHigh) / 2;
-  const legacyOutMid = isFiniteNumber(legacyTyped.outMin) && isFiniteNumber(legacyTyped.outMax) ? (legacyTyped.outMin + legacyTyped.outMax) / 2 : defaults.outAnchor;
-  const outAnchor = clamp(legacyOutMid, defaults.outLow, defaults.outHigh);
-  return {
-    inLow,
-    inAnchor,
-    inHigh,
-    outLow: defaults.outLow,
-    outAnchor,
-    outHigh: defaults.outHigh
-  };
-}
-function normalizeRemap(remap, target) {
-  if (!remap) {
-    return createDefaultRemap(target);
-  }
-  return migrateLegacyRemap(remap, target);
-}
-function cloneRemap(remap) {
-  return cloneRemapSettings(remap);
-}
-function sanitizeRemap(remap, target) {
-  const normalized = normalizeRemap(remap, target);
-  const outputDefaults = deriveOutputDefaults(target);
-  if (!Number.isFinite(normalized.outLow)) {
-    normalized.outLow = outputDefaults.outLow;
-  }
-  if (!Number.isFinite(normalized.outHigh)) {
-    normalized.outHigh = outputDefaults.outHigh;
-  }
-  if (!Number.isFinite(normalized.outAnchor)) {
-    normalized.outAnchor = outputDefaults.outAnchor;
-  }
-  if (normalized.outLow > normalized.outHigh) {
-    const low = normalized.outHigh;
-    const high = normalized.outLow;
-    normalized.outLow = low;
-    normalized.outHigh = high;
-  }
-  normalized.outAnchor = clamp(
-    normalized.outAnchor,
-    normalized.outLow,
-    normalized.outHigh
-  );
-  return normalized;
-}
-function createDefaultRemap(target) {
-  const inputDefaults = deriveInputDefaults();
-  const outputDefaults = deriveOutputDefaults(target);
-  return {
-    inLow: inputDefaults.inLow,
-    inAnchor: inputDefaults.inAnchor,
-    inHigh: inputDefaults.inHigh,
-    outLow: outputDefaults.outLow,
-    outAnchor: outputDefaults.outAnchor,
-    outHigh: outputDefaults.outHigh
-  };
-}
-function createDefaultBindings(components) {
-  const bindings = {};
-  components.forEach((component) => {
-    bindings[component.id] = createDefaultBinding(component);
-  });
-  return bindings;
-}
-function createDefaultBinding(component) {
-  const remap = createDefaultRemap(component);
-  const valueType = getTargetValueType(component);
-  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()
-  };
-}
-function createDefaultParentBinding(component) {
-  const base = createDefaultBinding(component);
-  const ensured = ensurePrimarySlot(base, component);
-  const slots = ensured.slots.map((slot, index) => {
-    if (index === 0) {
-      return {
-        ...slot,
-        alias: "self",
-        inputId: SELF_BINDING_ID
-      };
-    }
-    return slot;
-  });
-  return {
-    ...ensured,
-    inputId: SELF_BINDING_ID,
-    slots,
-    expression: "self"
-  };
-}
-function ensurePrimarySlot(binding, target) {
-  const normalizedBindingRemap = sanitizeRemap(binding.remap, target);
-  const targetValueType = getTargetValueType(target);
-  const aliasReplacements = /* @__PURE__ */ new Map();
-  const sourceSlots = Array.isArray(binding.slots) && binding.slots.length > 0 ? binding.slots : [
-    {
-      id: PRIMARY_SLOT_ID,
-      alias: PRIMARY_SLOT_ALIAS,
-      inputId: binding.inputId ?? null,
-      remap: cloneRemap(normalizedBindingRemap),
-      valueType: targetValueType
-    }
-  ];
-  const normalizedSlots = sourceSlots.map(
-    (slot, index) => {
-      const normalizedId = normalizeSlotId(slot.id, index);
-      const { alias: normalizedAlias, replaced } = normalizeSlotAlias(
-        slot.alias,
-        normalizedId,
-        index
-      );
-      if (replaced && replaced !== normalizedAlias) {
-        aliasReplacements.set(replaced, normalizedAlias);
-      }
-      const slotRemapSource = slot.remap ?? (index === 0 ? normalizedBindingRemap : createDefaultRemap(target));
-      const normalizedSlotRemap = sanitizeRemap(slotRemapSource, target);
-      const inputId = slot.inputId !== void 0 && slot.inputId !== null ? slot.inputId : index === 0 ? binding.inputId ?? null : null;
-      const slotValueType = sanitizeSlotValueType(
-        slot.valueType,
-        targetValueType
-      );
-      return {
-        id: normalizedId,
-        alias: normalizedAlias,
-        inputId,
-        remap: cloneRemap(normalizedSlotRemap),
-        valueType: slotValueType
-      };
-    }
-  );
-  const primary = normalizedSlots[0];
-  const primaryRemap = sanitizeRemap(primary.remap, target);
-  const primaryInputId = primary.inputId === SELF_BINDING_ID ? SELF_BINDING_ID : primary.inputId ?? binding.inputId ?? null;
-  const primaryAlias = primaryInputId === SELF_BINDING_ID ? "self" : primary.alias || PRIMARY_SLOT_ALIAS;
-  normalizedSlots[0] = {
-    ...primary,
-    id: primary.id || PRIMARY_SLOT_ID,
-    alias: primaryAlias,
-    inputId: primaryInputId,
-    remap: cloneRemap(primaryRemap),
-    valueType: sanitizeSlotValueType(primary.valueType, targetValueType)
-  };
-  normalizedSlots.slice(1).forEach((slot, index) => {
-    const slotRemap = sanitizeRemap(slot.remap, target);
-    normalizedSlots[index + 1] = {
-      ...slot,
-      id: slot.id || defaultSlotId(index + 1),
-      alias: slot.alias || defaultSlotId(index + 1),
-      remap: cloneRemap(slotRemap),
-      valueType: sanitizeSlotValueType(slot.valueType, targetValueType)
-    };
-  });
-  const rawExpression = typeof binding.expression === "string" ? binding.expression.trim() : "";
-  let expression = rawExpression.length > 0 ? rawExpression : normalizedSlots[0].alias;
-  expression = rewriteLegacyExpression(expression, aliasReplacements);
-  const normalizedBinding = {
-    ...binding,
-    inputId: normalizedSlots[0].inputId ?? null,
-    remap: cloneRemap(primaryRemap),
-    slots: normalizedSlots,
-    expression
-  };
-  const operators = ensureOperators(normalizedBinding);
-  if (operatorsEqual(normalizedBinding.operators, operators)) {
-    return normalizedBinding;
-  }
-  return {
-    ...normalizedBinding,
-    operators
-  };
-}
-function createDefaultInputValues(inputs = []) {
-  const values = {};
-  inputs.forEach((input) => {
-    values[input.id] = input.defaultValue;
-  });
-  return values;
-}
-function ensureBindingStructure(binding, target) {
-  return ensurePrimarySlot(binding, target);
-}
-function getPrimaryBindingSlot(binding) {
-  if (!binding.slots || binding.slots.length === 0) {
-    return null;
-  }
-  return binding.slots[0];
-}
-function addBindingSlot(binding, target) {
-  const base = ensurePrimarySlot(binding, target);
-  const nextIndex = base.slots.length + 1;
-  const slotId = defaultSlotId(nextIndex - 1);
-  const alias = slotId;
-  const remap = createDefaultRemap(target);
-  const nextSlots = [
-    ...base.slots,
-    {
-      id: slotId,
-      alias,
-      inputId: null,
-      remap: cloneRemap(remap)
-    }
-  ];
-  return ensurePrimarySlot(
-    {
-      ...base,
-      slots: nextSlots
-    },
-    target
-  );
-}
-function removeBindingSlot(binding, target, slotId) {
-  const base = ensurePrimarySlot(binding, target);
-  if (base.slots.length <= 1) {
-    return base;
-  }
-  const nextSlots = base.slots.filter((slot) => slot.id !== slotId);
-  if (nextSlots.length === base.slots.length) {
-    return base;
-  }
-  const nextBinding = ensurePrimarySlot(
-    {
-      ...base,
-      slots: nextSlots
-    },
-    target
-  );
-  if (!nextBinding.expression) {
-    return nextBinding;
-  }
-  const hasExpressionAlias = nextBinding.slots.some(
-    (slot) => slot.alias === nextBinding.expression
-  );
-  if (!hasExpressionAlias) {
-    return {
-      ...nextBinding,
-      expression: nextBinding.slots[0]?.alias ?? PRIMARY_SLOT_ALIAS
-    };
-  }
-  return nextBinding;
-}
-function updateBindingSlotAlias(binding, target, slotId, nextAlias) {
-  const base = ensurePrimarySlot(binding, target);
-  const slotIndex = base.slots.findIndex((slot) => slot.id === slotId);
-  if (slotIndex < 0) {
-    return base;
-  }
-  const slots = base.slots.map((slot) => ({ ...slot }));
-  const currentSlot = slots[slotIndex];
-  const fallbackAlias = currentSlot.alias || currentSlot.id || defaultSlotId(slotIndex);
-  const sanitized = sanitizeAliasInput(nextAlias, fallbackAlias, slotIndex);
-  const existingAliases = /* @__PURE__ */ new Set();
-  slots.forEach((slot, index) => {
-    if (index === slotIndex) {
-      return;
-    }
-    if (slot.alias) {
-      existingAliases.add(slot.alias.toLowerCase());
-    }
-  });
-  const uniqueAlias = ensureUniqueAlias(sanitized, existingAliases);
-  const previousAlias = currentSlot.alias;
-  slots[slotIndex] = {
-    ...currentSlot,
-    alias: uniqueAlias
-  };
-  let nextExpression = base.expression;
-  if (previousAlias && previousAlias !== uniqueAlias && typeof nextExpression === "string") {
-    const pattern = new RegExp(`\\b${escapeRegExp(previousAlias)}\\b`, "g");
-    nextExpression = nextExpression.replace(pattern, uniqueAlias);
-  }
-  const updated = ensurePrimarySlot(
-    {
-      ...base,
-      slots,
-      expression: nextExpression
-    },
-    target
-  );
-  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;
-  }
-  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
-  );
-  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;
-    }
-    changed = true;
-    return {
-      ...operator,
-      params: {
-        ...operator.params,
-        [paramId]: nextValue
-      }
-    };
-  });
-  if (!changed) {
-    return normalizedBinding;
-  }
-  if (operatorsEqual(normalizedBinding.operators, nextOperators)) {
-    return normalizedBinding;
-  }
-  return {
-    ...normalizedBinding,
-    operators: nextOperators
-  };
-}
-function updateBindingExpression(binding, target, expression) {
-  const base = ensurePrimarySlot(binding, target);
-  const trimmed = expression.trim();
-  return {
-    ...base,
-    expression: trimmed.length > 0 ? trimmed : base.slots[0]?.alias ?? PRIMARY_SLOT_ALIAS
-  };
-}
-function updateBindingSlotRemap(binding, target, slotId, field, value) {
-  const base = ensurePrimarySlot(binding, target);
-  const nextSlots = base.slots.map((slot) => {
-    if (slot.id !== slotId) {
-      return slot;
-    }
-    const updatedRemap = {
-      ...slot.remap,
-      [field]: value
-    };
-    const sanitized = sanitizeRemap(updatedRemap, target);
-    return {
-      ...slot,
-      remap: cloneRemap(sanitized)
-    };
-  });
-  const updated = ensurePrimarySlot(
-    {
-      ...base,
-      slots: nextSlots
-    },
-    target
-  );
-  if (updated.slots[0]?.id === slotId) {
-    updated.remap = {
-      ...updated.remap,
-      [field]: value
-    };
-  }
-  return updated;
-}
-function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID) {
-  const base = ensurePrimarySlot(binding, target);
-  const slotIndex = base.slots.findIndex((slot) => slot.id === slotId);
-  const effectiveIndex = slotIndex >= 0 ? slotIndex : base.slots.length;
-  const slots = base.slots.map((slot) => ({
-    ...slot,
-    remap: cloneRemap(slot.remap)
-  }));
-  if (slotIndex === -1) {
-    const alias = slotId === PRIMARY_SLOT_ID && slots.length === 0 ? PRIMARY_SLOT_ALIAS : slotId;
-    slots.push({
-      id: slotId,
-      alias,
-      inputId: null,
-      remap: cloneRemap(createDefaultRemap(target))
-    });
-  }
-  const currentSlot = slots[effectiveIndex];
-  if (!input) {
-    const normalizedSlotRemap = sanitizeRemap(currentSlot.remap, target);
-    const updatedRemap2 = {
-      ...normalizedSlotRemap,
-      inLow: DEFAULT_INPUT_RANGE.min,
-      inAnchor: DEFAULT_INPUT_ANCHOR,
-      inHigh: DEFAULT_INPUT_RANGE.max
-    };
-    slots[effectiveIndex] = {
-      ...currentSlot,
-      inputId: null,
-      remap: cloneRemap(updatedRemap2)
-    };
-    if (effectiveIndex === 0) {
-      return {
-        ...base,
-        inputId: null,
-        remap: cloneRemap(updatedRemap2),
-        slots
-      };
-    }
-    return {
-      ...base,
-      slots
-    };
-  }
-  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,
-      inputId: input.id,
-      remap: cloneRemap(updatedRemap),
-      slots
-    };
-  }
-  return {
-    ...base,
-    slots
-  };
-}
-function remapValue(value, remap) {
-  const { inLow, inAnchor, inHigh, outLow, outAnchor, outHigh } = remap;
-  if (Number.isNaN(value)) {
-    return outAnchor;
-  }
-  if (value <= inAnchor) {
-    const span2 = inAnchor - inLow;
-    if (Math.abs(span2) < EPSILON) {
-      return outLow;
-    }
-    const t2 = (value - inLow) / span2;
-    return outLow + t2 * (outAnchor - outLow);
-  }
-  const span = inHigh - inAnchor;
-  if (Math.abs(span) < EPSILON) {
-    return outHigh;
-  }
-  const t = (value - inAnchor) / span;
-  return outAnchor + t * (outHigh - outAnchor);
-}
-function reconcileBindings(previous, components) {
-  const next = {};
-  components.forEach((component) => {
-    const existing = previous[component.id];
-    if (existing) {
-      const ensured = ensureBindingStructure(existing, component);
-      const aliasReplacements = /* @__PURE__ */ new Map();
-      const slots = ensured.slots.map((slot, index) => {
-        const normalizedId = normalizeSlotId(slot.id, index);
-        const { alias: normalizedAlias, replaced } = normalizeSlotAlias(
-          slot.alias,
-          normalizedId,
-          index
-        );
-        if (replaced && replaced !== normalizedAlias) {
-          aliasReplacements.set(replaced, normalizedAlias);
-        }
-        const slotRemap = sanitizeRemap(slot.remap, component);
-        return {
-          ...slot,
-          id: normalizedId,
-          alias: normalizedAlias,
-          remap: cloneRemap(slotRemap)
-        };
-      });
-      const primary = slots[0];
-      let expression = typeof ensured.expression === "string" && ensured.expression.trim().length > 0 ? ensured.expression.trim() : primary.alias;
-      expression = rewriteLegacyExpression(expression, aliasReplacements);
-      next[component.id] = {
-        ...ensured,
-        targetId: component.id,
-        inputId: primary.inputId ?? null,
-        remap: cloneRemap(primary.remap),
-        slots,
-        expression
-      };
-    } else {
-      next[component.id] = createDefaultBinding(component);
-    }
-  });
-  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),
-    slots: binding.slots.map((slot) => ({
-      ...slot,
-      remap: cloneRemap(slot.remap)
-    })),
-    expression: binding.expression,
-    operators
-  };
-  return definition;
-}
-function bindingFromDefinition(target, definition) {
-  if (!definition) {
-    return createDefaultBinding(target);
-  }
-  const definitionOperators = definition.operators;
-  const binding = {
-    targetId: target.id,
-    inputId: definition.inputId ?? null,
-    remap: cloneRemap(definition.remap),
-    slots: definition.slots.map((slot) => ({
-      ...slot,
-      remap: cloneRemap(slot.remap)
-    })),
-    expression: definition.expression,
-    operators: definitionOperators ? definitionOperators.map((operator) => ({
-      type: operator.type,
-      enabled: !!operator.enabled,
-      params: { ...operator.params }
-    })) : void 0
-  };
-  return ensureBindingStructure(binding, target);
-}
-
-// src/expression.ts
-var WHITESPACE = /\s/;
-var IDENT_START = /[A-Za-z_]/;
-var IDENT_PART = /[A-Za-z0-9_]/;
-var DIGIT = /[0-9]/;
-var ControlExpressionParser = class {
-  constructor(input) {
-    this.input = input;
-    this.index = 0;
-    this.errors = [];
-  }
-  parse() {
-    this.skipWhitespace();
-    const node = this.parseExpression();
-    this.skipWhitespace();
-    if (!node) {
-      if (this.errors.length === 0) {
-        this.errors.push({
-          index: this.index,
-          message: "Empty expression."
-        });
-      }
-      return { node: null, errors: this.errors };
-    }
-    if (!this.isAtEnd()) {
-      this.errors.push({
-        index: this.index,
-        message: `Unexpected token "${this.peek()}"`
-      });
-      return { node: null, errors: this.errors };
-    }
-    return { node, errors: this.errors };
-  }
-  parseExpression() {
-    return this.parseLogicalOr();
-  }
-  parseLogicalOr() {
-    let left = this.parseLogicalAnd();
-    if (!left) {
-      return null;
-    }
-    while (true) {
-      this.skipWhitespace();
-      const operator = this.matchAny(["||"]);
-      if (!operator) {
-        break;
-      }
-      const right = this.parseLogicalAnd();
-      if (!right) {
-        this.errors.push({
-          index: this.index,
-          message: "Expected expression after operator."
-        });
-        return null;
-      }
-      left = {
-        type: "Binary",
-        operator,
-        left,
-        right
-      };
-    }
-    return left;
-  }
-  parseLogicalAnd() {
-    let left = this.parseComparison();
-    if (!left) {
-      return null;
-    }
-    while (true) {
-      this.skipWhitespace();
-      const operator = this.matchAny(["&&"]);
-      if (!operator) {
-        break;
-      }
-      const right = this.parseComparison();
-      if (!right) {
-        this.errors.push({
-          index: this.index,
-          message: "Expected expression after operator."
-        });
-        return null;
-      }
-      left = {
-        type: "Binary",
-        operator,
-        left,
-        right
-      };
-    }
-    return left;
-  }
-  parseComparison() {
-    let left = this.parseAdditive();
-    if (!left) {
-      return null;
-    }
-    while (true) {
-      this.skipWhitespace();
-      if (this.input.startsWith(">=", this.index) || this.input.startsWith("<=", this.index)) {
-        const op = this.input.slice(this.index, this.index + 2);
-        this.index += 2;
-        this.errors.push({
-          index: this.index - 2,
-          message: `Operator "${op}" is not supported.`
-        });
-        return null;
-      }
-      const operator = this.matchAny(["==", "!=", ">", "<"]);
-      if (!operator) {
-        break;
-      }
-      const right = this.parseAdditive();
-      if (!right) {
-        this.errors.push({
-          index: this.index,
-          message: "Expected expression after operator."
-        });
-        return null;
-      }
-      left = {
-        type: "Binary",
-        operator,
-        left,
-        right
-      };
-    }
-    return left;
-  }
-  parseAdditive() {
-    let left = this.parseMultiplicative();
-    if (!left) {
-      return null;
-    }
-    while (true) {
-      this.skipWhitespace();
-      const operator = this.peek();
-      if (operator !== "+" && operator !== "-") {
-        break;
-      }
-      this.index += 1;
-      const right = this.parseMultiplicative();
-      if (!right) {
-        this.errors.push({
-          index: this.index,
-          message: "Expected expression after operator."
-        });
-        return null;
-      }
-      left = {
-        type: "Binary",
-        operator,
-        left,
-        right
-      };
-    }
-    return left;
-  }
-  parseMultiplicative() {
-    let left = this.parseUnary();
-    if (!left) {
-      return null;
-    }
-    while (true) {
-      this.skipWhitespace();
-      const operator = this.peek();
-      if (operator !== "*" && operator !== "/") {
-        break;
-      }
-      this.index += 1;
-      const right = this.parseUnary();
-      if (!right) {
-        this.errors.push({
-          index: this.index,
-          message: "Expected expression after operator."
-        });
-        return null;
-      }
-      left = {
-        type: "Binary",
-        operator,
-        left,
-        right
-      };
-    }
-    return left;
-  }
-  parseUnary() {
-    this.skipWhitespace();
-    const char = this.peek();
-    if (!char) {
-      this.errors.push({
-        index: this.index,
-        message: "Unexpected end of expression."
-      });
-      return null;
-    }
-    if (char === "+" || char === "-" || char === "!") {
-      this.index += 1;
-      const operand = this.parseUnary();
-      if (!operand) {
-        this.errors.push({
-          index: this.index,
-          message: `Expected operand after unary "${char}".`
-        });
-        return null;
-      }
-      return {
-        type: "Unary",
-        operator: char,
-        operand
-      };
-    }
-    return this.parsePrimary();
-  }
-  parsePrimary() {
-    this.skipWhitespace();
-    const char = this.peek();
-    if (!char) {
-      this.errors.push({
-        index: this.index,
-        message: "Unexpected end of expression."
-      });
-      return null;
-    }
-    if (char === "(") {
-      this.index += 1;
-      const expression = this.parseExpression();
-      this.skipWhitespace();
-      if (this.peek() === ")") {
-        this.index += 1;
-        return expression;
-      }
-      this.errors.push({
-        index: this.index,
-        message: "Unmatched parenthesis."
-      });
-      return null;
-    }
-    if (IDENT_START.test(char)) {
-      return this.parseIdentifierOrFunction();
-    }
-    if (DIGIT.test(char) || char === ".") {
-      return this.parseNumber();
-    }
-    this.errors.push({
-      index: this.index,
-      message: `Unexpected character "${char}".`
-    });
-    return null;
-  }
-  parseIdentifierOrFunction() {
-    const start = this.index;
-    while (!this.isAtEnd() && IDENT_PART.test(this.peek())) {
-      this.index += 1;
-    }
-    const name = this.input.slice(start, this.index);
-    if (!name) {
-      this.errors.push({
-        index: start,
-        message: "Invalid identifier."
-      });
-      return null;
-    }
-    this.skipWhitespace();
-    if (this.peek() === "(") {
-      this.index += 1;
-      const args = [];
-      this.skipWhitespace();
-      if (this.peek() === ")") {
-        this.index += 1;
-        return {
-          type: "Function",
-          name,
-          args
-        };
-      }
-      while (true) {
-        const argument = this.parseExpression();
-        if (!argument) {
-          this.errors.push({
-            index: this.index,
-            message: `Expected expression for argument ${args.length + 1} of "${name}".`
-          });
-          return null;
-        }
-        args.push(argument);
-        this.skipWhitespace();
-        const next = this.peek();
-        if (next === ",") {
-          this.index += 1;
-          this.skipWhitespace();
-          if (this.peek() === ")") {
-            this.errors.push({
-              index: this.index,
-              message: `Expected expression after "," in call to "${name}".`
-            });
-            return null;
-          }
-          continue;
-        }
-        if (next === ")") {
-          this.index += 1;
-          break;
-        }
-        if (next === null) {
-          this.errors.push({
-            index: this.index,
-            message: `Unterminated call to "${name}".`
-          });
-        } else {
-          this.errors.push({
-            index: this.index,
-            message: `Expected "," or ")" in call to "${name}".`
-          });
-        }
-        return null;
-      }
-      return {
-        type: "Function",
-        name,
-        args
-      };
-    }
-    return {
-      type: "Reference",
-      name
-    };
-  }
-  parseNumber() {
-    const start = this.index;
-    let hasDigits = false;
-    while (!this.isAtEnd()) {
-      const char = this.peek();
-      if (DIGIT.test(char)) {
-        hasDigits = true;
-        this.index += 1;
-        continue;
-      }
-      if (char === ".") {
-        this.index += 1;
-        continue;
-      }
-      break;
-    }
-    const raw = this.input.slice(start, this.index);
-    const value = Number(raw);
-    if (!hasDigits || Number.isNaN(value)) {
-      this.errors.push({
-        index: start,
-        message: `Invalid numeric literal "${raw}".`
-      });
-      return null;
-    }
-    return {
-      type: "Literal",
-      value
-    };
-  }
-  matchAny(operators) {
-    for (const operator of operators) {
-      if (this.input.startsWith(operator, this.index)) {
-        this.index += operator.length;
-        return operator;
-      }
-    }
-    return null;
-  }
-  skipWhitespace() {
-    while (!this.isAtEnd() && WHITESPACE.test(this.peek())) {
-      this.index += 1;
-    }
-  }
-  peek() {
-    if (this.index >= this.input.length) {
-      return null;
-    }
-    return this.input[this.index] ?? null;
-  }
-  isAtEnd() {
-    return this.index >= this.input.length;
-  }
-};
-function parseControlExpression(expression) {
-  const parser = new ControlExpressionParser(expression);
-  return parser.parse();
-}
-function collectExpressionReferences(node, target = /* @__PURE__ */ new Set()) {
-  if (!node) {
-    return target;
-  }
-  switch (node.type) {
-    case "Reference":
-      target.add(node.name);
-      break;
-    case "Unary":
-      collectExpressionReferences(node.operand, target);
-      break;
-    case "Binary":
-      collectExpressionReferences(node.left, target);
-      collectExpressionReferences(node.right, target);
-      break;
-    case "Function":
-      node.args.forEach((arg) => collectExpressionReferences(arg, target));
-      break;
-    default:
-      break;
-  }
-  return target;
-}
-function mapExpression(node, visit) {
-  visit(node);
-  switch (node.type) {
-    case "Unary":
-      mapExpression(node.operand, visit);
-      break;
-    case "Binary":
-      mapExpression(node.left, visit);
-      mapExpression(node.right, visit);
-      break;
-    case "Function":
-      node.args.forEach((arg) => mapExpression(arg, visit));
-      break;
-    default:
-      break;
-  }
-}
-
-// src/expressionFunctions.ts
-import { requireNodeSignature as requireNodeSignature2 } from "@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"],
-    minArgs: 2,
-    maxArgs: 2
-  },
-  { 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: "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 = requireNodeSignature2(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,
-    min: signature.variadic_inputs.min,
-    max: signature.variadic_inputs.max ?? null
-  } : 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 definition = {
-    nodeType: config.typeId,
-    inputs,
-    variadic,
-    minArgs,
-    maxArgs
-  };
-  const names = new Set(
-    [config.typeId, ...config.names].map((name) => name.toLowerCase())
-  );
-  names.forEach((name) => {
-    SCALAR_FUNCTIONS.set(name, definition);
-  });
-}
-
-// src/graphBuilder.ts
-function evaluateBinding({
-  binding,
-  target,
-  targetId,
-  animatableId,
-  component,
-  safeId,
-  context,
-  selfNodeId
-}) {
-  const { nodes, edges, ensureInputNode, bindingIssues, summaryBindings } = context;
-  const exprContext = {
-    componentSafeId: safeId,
-    nodes,
-    edges,
-    constants: /* @__PURE__ */ new Map(),
-    counter: 0
-  };
-  const targetValueType = target.valueType === "vector" ? "vector" : "scalar";
-  const aliasNodes = /* @__PURE__ */ new Map();
-  const slotSummaries = [];
-  const expressionIssues = [];
-  const rawExpression = typeof binding.expression === "string" ? binding.expression : "";
-  const trimmedExpression = rawExpression.trim();
-  let hasActiveSlot = false;
-  binding.slots.forEach((slot, index) => {
-    const aliasBase = slot.alias?.trim() ?? "";
-    const fallbackAlias = `s${index + 1}`;
-    const alias = aliasBase.length > 0 ? aliasBase : fallbackAlias;
-    const slotId = slot.id && slot.id.length > 0 ? slot.id : alias;
-    const slotValueType = slot.valueType === "vector" ? "vector" : "scalar";
-    let slotOutputId;
-    if (slot.inputId === SELF_BINDING_ID2) {
-      if (selfNodeId) {
-        slotOutputId = selfNodeId;
-        hasActiveSlot = true;
-      } else {
-        expressionIssues.push("Self reference unavailable for this input.");
-        slotOutputId = getConstantNodeId(exprContext, target.defaultValue);
-      }
-    } else if (slot.inputId) {
-      const inputNode = ensureInputNode(slot.inputId);
-      if (inputNode) {
-        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;
-        hasActiveSlot = true;
-      } else {
-        expressionIssues.push(`Missing standard input "${slot.inputId}".`);
-        slotOutputId = getConstantNodeId(exprContext, 0);
-      }
-    } else {
-      slotOutputId = getConstantNodeId(exprContext, 0);
-    }
-    aliasNodes.set(alias, slotOutputId);
-    slotSummaries.push({
-      targetId,
-      animatableId,
-      component,
-      slotId,
-      slotAlias: alias,
-      inputId: slot.inputId ?? null,
-      remap: { ...slot.remap },
-      expression: trimmedExpression,
-      valueType: slotValueType
-    });
-  });
-  if (slotSummaries.length === 0) {
-    const alias = PRIMARY_SLOT_ALIAS;
-    aliasNodes.set(alias, getConstantNodeId(exprContext, 0));
-    slotSummaries.push({
-      targetId,
-      animatableId,
-      component,
-      slotId: PRIMARY_SLOT_ID,
-      slotAlias: alias,
-      inputId: null,
-      remap: createDefaultRemap(target),
-      expression: trimmedExpression,
-      valueType: targetValueType
-    });
-  }
-  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);
-      }
-    });
-    if (missing.length === 0) {
-      expressionAst = parseResult.node;
-    } else {
-      missing.forEach((ref) => {
-        expressionIssues.push(`Unknown control "${ref}".`);
-      });
-    }
-  } else {
-    parseResult.errors.forEach((error) => {
-      expressionIssues.push(error.message);
-    });
-  }
-  let valueNodeId = null;
-  if (expressionAst) {
-    valueNodeId = materializeExpression(
-      expressionAst,
-      exprContext,
-      aliasNodes,
-      expressionIssues
-    );
-  }
-  if (!valueNodeId) {
-    const fallbackAlias = aliasNodes.has(defaultAlias) ? defaultAlias : aliasNodes.keys().next().value;
-    valueNodeId = (fallbackAlias ? aliasNodes.get(fallbackAlias) : void 0) ?? getConstantNodeId(exprContext, 0);
-  }
-  const issuesCopy = expressionIssues.length ? [...new Set(expressionIssues)] : void 0;
-  slotSummaries.forEach((summary) => {
-    summary.expression = expressionText;
-    if (issuesCopy && issuesCopy.length > 0) {
-      summary.issues = issuesCopy;
-      const issueSet = bindingIssues.get(summary.targetId) ?? /* @__PURE__ */ new Set();
-      issuesCopy.forEach((issue) => issueSet.add(issue));
-      bindingIssues.set(summary.targetId, issueSet);
-    }
-  });
-  summaryBindings.push(...slotSummaries);
-  return {
-    valueNodeId,
-    hasActiveSlot
-  };
-}
-function sanitizeNodeId(value) {
-  return value.replace(/[^a-zA-Z0-9_]/g, "_");
-}
-function buildRigInputPath(faceId, inputPath) {
-  const trimmed = inputPath.startsWith("/") ? inputPath.slice(1) : inputPath;
-  return `rig/${faceId}/${trimmed}`;
-}
-function getComponentOrder(animatable) {
-  switch (animatable.type) {
-    case "vector2":
-      return ["x", "y"];
-    case "vector3":
-    case "euler":
-      return ["x", "y", "z"];
-    case "rgb":
-      return ["r", "g", "b"];
-    default:
-      return null;
-  }
-}
-function isComponentRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function componentIndex(component) {
-  switch (component) {
-    case "x":
-    case "r":
-      return 0;
-    case "y":
-    case "g":
-      return 1;
-    default:
-      return 2;
-  }
-}
-function extractComponentDefault(value, component) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    const candidate = value[componentIndex(component)];
-    if (typeof candidate === "number" && Number.isFinite(candidate)) {
-      return candidate;
-    }
-    return 0;
-  }
-  if (value && typeof value === "object") {
-    if (!isComponentRecord(value)) {
-      return 0;
-    }
-    const direct = value[component];
-    if (typeof direct === "number" && Number.isFinite(direct)) {
-      return direct;
-    }
-    const alt = component === "x" ? value.r : component === "y" ? value.g : value.b;
-    if (typeof alt === "number" && Number.isFinite(alt)) {
-      return alt;
-    }
-  }
-  return 0;
-}
-function getConstantNodeId(context, value) {
-  const key = Number.isFinite(value) ? value.toString() : "NaN";
-  const existing = context.constants.get(key);
-  if (existing) {
-    return existing;
-  }
-  const nodeId = `const_${context.componentSafeId}_${context.constants.size + 1}`;
-  context.nodes.push({
-    id: nodeId,
-    type: "constant",
-    params: {
-      value: Number.isFinite(value) ? value : 0
-    }
-  });
-  context.constants.set(key, nodeId);
-  return nodeId;
-}
-function createBinaryOperationNode(context, operator, leftId, rightId) {
-  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
-  context.nodes.push({
-    id: nodeId,
-    type: operator
-  });
-  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 }
-  });
-  context.edges.push({
-    from: { node_id: rightId },
-    to: { node_id: nodeId, input: rightInput }
-  });
-  return nodeId;
-}
-function createVariadicOperationNode(context, operator, operandIds) {
-  if (operandIds.length === 0) {
-    return getConstantNodeId(context, operator === "add" ? 0 : 1);
-  }
-  if (operandIds.length === 1) {
-    return operandIds[0];
-  }
-  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
-  context.nodes.push({
-    id: nodeId,
-    type: operator
-  });
-  operandIds.forEach((operandId, index) => {
-    context.edges.push({
-      from: { node_id: operandId },
-      to: { node_id: nodeId, input: `operand_${index + 1}` }
-    });
-  });
-  return nodeId;
-}
-function createNamedOperationNode(context, operator, inputNames, operandIds) {
-  const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
-  context.nodes.push({
-    id: nodeId,
-    type: operator
-  });
-  inputNames.forEach((inputName, index) => {
-    const operandId = operandIds[index];
-    context.edges.push({
-      from: { node_id: operandId },
-      to: { node_id: nodeId, input: inputName }
-    });
-  });
-  return nodeId;
-}
-function emitScalarFunctionNode(definition, operands, context) {
-  if (definition.variadic) {
-    const nodeId = `expr_${context.componentSafeId}_${context.counter++}`;
-    context.nodes.push({
-      id: nodeId,
-      type: definition.nodeType
-    });
-    operands.forEach((operandId, index) => {
-      context.edges.push({
-        from: { node_id: operandId },
-        to: {
-          node_id: nodeId,
-          input: `${definition.variadic.id}_${index + 1}`
-        }
-      });
-    });
-    return nodeId;
-  }
-  const providedNames = [];
-  const providedOperands = [];
-  definition.inputs.forEach((input, index) => {
-    const operandId = operands[index];
-    if (!operandId) {
-      return;
-    }
-    providedNames.push(input.id);
-    providedOperands.push(operandId);
-  });
-  return createNamedOperationNode(
-    context,
-    definition.nodeType,
-    providedNames,
-    providedOperands
-  );
-}
-function applyBindingOperators(operators, baseNodeId, safeId, nodes, edges) {
-  let currentNodeId = baseNodeId;
-  operators.forEach((operator, index) => {
-    if (!operator.enabled) {
-      return;
-    }
-    let definition;
-    try {
-      definition = getBindingOperatorDefinition(operator.type);
-    } catch {
-      return;
-    }
-    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;
-}
-function collectOperands(node, operator, target) {
-  if (node.type === "Binary" && node.operator === operator) {
-    collectOperands(node.left, operator, target);
-    collectOperands(node.right, operator, target);
-    return;
-  }
-  target.push(node);
-}
-var BINARY_FUNCTION_OPERATOR_MAP = {
-  ">": "greaterthan",
-  "<": "lessthan",
-  "==": "equal",
-  "!=": "notequal",
-  "&&": "and",
-  "||": "or"
-};
-function materializeExpression(node, context, aliasNodes, issues) {
-  switch (node.type) {
-    case "Literal": {
-      return getConstantNodeId(context, node.value);
-    }
-    case "Reference": {
-      const mapped = aliasNodes.get(node.name);
-      if (!mapped) {
-        issues.push(`Unknown control "${node.name}".`);
-        return getConstantNodeId(context, 0);
-      }
-      return mapped;
-    }
-    case "Unary": {
-      const operandId = materializeExpression(
-        node.operand,
-        context,
-        aliasNodes,
-        issues
-      );
-      switch (node.operator) {
-        case "+":
-          return operandId;
-        case "-": {
-          const negativeOne = getConstantNodeId(context, -1);
-          return createVariadicOperationNode(context, "multiply", [
-            negativeOne,
-            operandId
-          ]);
-        }
-        case "!": {
-          const definition = SCALAR_FUNCTIONS.get("not");
-          if (!definition) {
-            issues.push('Function "not" is not available in metadata.');
-            return getConstantNodeId(context, 0);
-          }
-          return emitScalarFunctionNode(definition, [operandId], context);
-        }
-        default:
-          issues.push("Unsupported unary operator.");
-          return operandId;
-      }
-    }
-    case "Binary": {
-      const operator = node.operator;
-      if (operator === "+") {
-        const children = [];
-        collectOperands(node, "+", children);
-        const operandIds = children.map(
-          (child) => materializeExpression(child, context, aliasNodes, issues)
-        );
-        return createVariadicOperationNode(context, "add", operandIds);
-      }
-      if (operator === "*") {
-        const children = [];
-        collectOperands(node, "*", children);
-        const operandIds = children.map(
-          (child) => materializeExpression(child, context, aliasNodes, issues)
-        );
-        return createVariadicOperationNode(context, "multiply", operandIds);
-      }
-      const leftId = materializeExpression(
-        node.left,
-        context,
-        aliasNodes,
-        issues
-      );
-      const rightId = materializeExpression(
-        node.right,
-        context,
-        aliasNodes,
-        issues
-      );
-      if (operator === "-") {
-        return createBinaryOperationNode(context, "subtract", leftId, rightId);
-      }
-      if (operator === "/") {
-        return createBinaryOperationNode(context, "divide", leftId, rightId);
-      }
-      const mappedFunction = BINARY_FUNCTION_OPERATOR_MAP[operator];
-      if (mappedFunction) {
-        const definition = SCALAR_FUNCTIONS.get(mappedFunction);
-        if (!definition) {
-          issues.push(`Function "${mappedFunction}" is not available.`);
-          return getConstantNodeId(context, 0);
-        }
-        return emitScalarFunctionNode(definition, [leftId, rightId], context);
-      }
-      issues.push(`Unsupported operator "${operator}".`);
-      return getConstantNodeId(context, 0);
-    }
-    case "Function": {
-      const name = node.name;
-      const normalized = name.toLowerCase();
-      const definition = SCALAR_FUNCTIONS.get(normalized);
-      if (!definition) {
-        issues.push(`Unknown function "${name}".`);
-        return getConstantNodeId(context, 0);
-      }
-      const operands = node.args.map(
-        (arg) => materializeExpression(arg, context, aliasNodes, issues)
-      );
-      if (operands.length < definition.minArgs) {
-        issues.push(
-          `Function "${name}" expects at least ${definition.minArgs} arguments, received ${operands.length}.`
-        );
-        return getConstantNodeId(context, 0);
-      }
-      if (definition.maxArgs !== null && operands.length > definition.maxArgs) {
-        issues.push(
-          `Function "${name}" expects at most ${definition.maxArgs} arguments, received ${operands.length}.`
-        );
-        return getConstantNodeId(context, 0);
-      }
-      return emitScalarFunctionNode(definition, operands, context);
-    }
-    default: {
-      issues.push("Unsupported expression node.");
-      return getConstantNodeId(context, 0);
-    }
-  }
-}
-function buildRigGraphSpec({
-  faceId,
-  animatables,
-  components,
-  bindings,
-  inputsById,
-  inputBindings
-}) {
-  const nodes = [];
-  const edges = [];
-  const inputNodes = /* @__PURE__ */ new Map();
-  const buildingDerived = /* @__PURE__ */ new Set();
-  const computedInputs = /* @__PURE__ */ new Set();
-  const summaryBindings = [];
-  const bindingIssues = /* @__PURE__ */ new Map();
-  const animatableEntries = /* @__PURE__ */ new Map();
-  const outputs = /* @__PURE__ */ new Set();
-  const ensureInputNode = (inputId) => {
-    const existing = inputNodes.get(inputId);
-    if (existing) {
-      return existing;
-    }
-    const input = inputsById.get(inputId);
-    if (!input) {
-      return null;
-    }
-    const defaultValue = Number.isFinite(input.defaultValue) ? input.defaultValue : 0;
-    const inputBindingRaw = inputBindings[inputId];
-    if (inputBindingRaw) {
-      if (buildingDerived.has(inputId)) {
-        const issueSet = bindingIssues.get(inputId) ?? /* @__PURE__ */ new Set();
-        issueSet.add("Derived input cycle detected.");
-        bindingIssues.set(inputId, issueSet);
-        return null;
-      }
-      buildingDerived.add(inputId);
-      try {
-        const target = bindingTargetFromInput(input);
-        const binding = ensureBindingStructure(inputBindingRaw, target);
-        const requiresSelf = binding.inputId === SELF_BINDING_ID2 || binding.slots.some((slot) => slot.inputId === SELF_BINDING_ID2);
-        let selfNodeId;
-        if (requiresSelf) {
-          const sliderNodeId = `input_raw_${sanitizeNodeId(inputId)}`;
-          nodes.push({
-            id: sliderNodeId,
-            type: "input",
-            params: {
-              path: buildRigInputPath(faceId, input.path),
-              value: { float: defaultValue }
-            }
-          });
-          selfNodeId = sliderNodeId;
-        }
-        const { valueNodeId, hasActiveSlot } = evaluateBinding({
-          binding,
-          target,
-          targetId: inputId,
-          animatableId: inputId,
-          component: void 0,
-          safeId: sanitizeNodeId(inputId),
-          context: {
-            nodes,
-            edges,
-            ensureInputNode,
-            bindingIssues,
-            summaryBindings
-          },
-          selfNodeId
-        });
-        if (!valueNodeId || !hasActiveSlot) {
-          const constNodeId = `derived_default_${sanitizeNodeId(inputId)}`;
-          nodes.push({
-            id: constNodeId,
-            type: "constant",
-            params: {
-              value: input.defaultValue
-            }
-          });
-          const record3 = { nodeId: constNodeId, input };
-          inputNodes.set(inputId, record3);
-          return record3;
-        }
-        computedInputs.add(inputId);
-        const record2 = { nodeId: valueNodeId, input };
-        inputNodes.set(inputId, record2);
-        return record2;
-      } finally {
-        buildingDerived.delete(inputId);
-      }
-    }
-    const nodeId = `input_${sanitizeNodeId(inputId)}`;
-    nodes.push({
-      id: nodeId,
-      type: "input",
-      params: {
-        path: buildRigInputPath(faceId, input.path),
-        value: { float: defaultValue }
-      }
-    });
-    const record = { nodeId, input };
-    inputNodes.set(inputId, record);
-    return record;
-  };
-  const ensureAnimatableEntry = (animatableId) => {
-    const existing = animatableEntries.get(animatableId);
-    if (existing) {
-      return existing;
-    }
-    const animatable = animatables[animatableId];
-    if (!animatable) {
-      return null;
-    }
-    const entry = {
-      animatable,
-      values: /* @__PURE__ */ new Map(),
-      defaults: /* @__PURE__ */ new Map(),
-      isDriven: false
-    };
-    animatableEntries.set(animatableId, entry);
-    return entry;
-  };
-  components.forEach((component) => {
-    const bindingRaw = bindings[component.id];
-    const target = bindingTargetFromComponent(component);
-    const binding = bindingRaw ? ensureBindingStructure(bindingRaw, target) : null;
-    const entry = ensureAnimatableEntry(component.animatableId);
-    if (!entry) {
-      return;
-    }
-    const key = component.component ?? "scalar";
-    let valueNodeId = null;
-    let hasActiveSlot = false;
-    if (binding) {
-      const { valueNodeId: producedNodeId, hasActiveSlot: active } = evaluateBinding({
-        binding,
-        target,
-        targetId: component.id,
-        animatableId: component.animatableId,
-        component: component.component,
-        safeId: component.safeId,
-        context: {
-          nodes,
-          edges,
-          ensureInputNode,
-          bindingIssues,
-          summaryBindings
-        }
-      });
-      valueNodeId = producedNodeId;
-      hasActiveSlot = active;
-      if (active) {
-        entry.isDriven = true;
-      }
-    } else {
-      summaryBindings.push({
-        targetId: component.id,
-        animatableId: component.animatableId,
-        component: component.component,
-        slotId: PRIMARY_SLOT_ID,
-        slotAlias: PRIMARY_SLOT_ALIAS,
-        inputId: null,
-        remap: createDefaultRemap(target),
-        expression: PRIMARY_SLOT_ALIAS,
-        valueType: target.valueType === "vector" ? "vector" : "scalar",
-        issues: ["Binding not found."]
-      });
-      const fallbackIssues = bindingIssues.get(component.id) ?? /* @__PURE__ */ new Set();
-      fallbackIssues.add("Binding not found.");
-      bindingIssues.set(component.id, fallbackIssues);
-    }
-    if (!valueNodeId || !hasActiveSlot) {
-      entry.defaults.set(key, component.defaultValue);
-      return;
-    }
-    const operatorList = binding ? binding.operators ?? [] : [];
-    const finalNodeId = applyBindingOperators(
-      operatorList,
-      valueNodeId,
-      component.safeId,
-      nodes,
-      edges
-    );
-    entry.values.set(key, finalNodeId);
-  });
-  inputsById.forEach((_input, inputId) => {
-    ensureInputNode(inputId);
-  });
-  animatableEntries.forEach((entry, animatableId) => {
-    if (!entry.isDriven) {
-      return;
-    }
-    outputs.add(animatableId);
-    const safeId = sanitizeNodeId(animatableId);
-    const order = getComponentOrder(entry.animatable);
-    if (!order) {
-      const valueNodeId = entry.values.get("scalar");
-      if (!valueNodeId) {
-        return;
-      }
-      const outputNodeId2 = `out_${safeId}`;
-      nodes.push({
-        id: outputNodeId2,
-        type: "output",
-        params: {
-          path: animatableId
-        }
-      });
-      edges.push({
-        from: { node_id: valueNodeId },
-        to: { node_id: outputNodeId2, input: "in" }
-      });
-      return;
-    }
-    const joinNodeId = `join_${safeId}`;
-    nodes.push({
-      id: joinNodeId,
-      type: "join"
-    });
-    order.forEach((componentKey, index) => {
-      let sourceId = entry.values.get(componentKey);
-      if (!sourceId) {
-        const componentDefault = entry.defaults.get(componentKey) ?? extractComponentDefault(
-          buildAnimatableValue(entry.animatable, void 0),
-          componentKey
-        );
-        const constNodeId = `const_${safeId}_${componentKey}`;
-        nodes.push({
-          id: constNodeId,
-          type: "constant",
-          params: {
-            value: componentDefault
-          }
-        });
-        sourceId = constNodeId;
-      }
-      edges.push({
-        from: { node_id: sourceId },
-        to: { node_id: joinNodeId, input: `operand_${index + 1}` }
-      });
-    });
-    const outputNodeId = `out_${safeId}`;
-    nodes.push({
-      id: outputNodeId,
-      type: "output",
-      params: {
-        path: animatableId
-      }
-    });
-    edges.push({
-      from: { node_id: joinNodeId },
-      to: { node_id: outputNodeId, input: "in" }
-    });
-  });
-  const nodeById = /* @__PURE__ */ new Map();
-  nodes.forEach((node) => {
-    nodeById.set(node.id, node);
-  });
-  const constantUsage = /* @__PURE__ */ new Map();
-  edges.forEach((edge) => {
-    const source = nodeById.get(edge.from.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]: value
-          };
-          nodeById.set(target.id, target);
-          constantsToRemove.add(source.id);
-          return;
-        }
-      }
-    }
-    updatedEdges.push(edge);
-  });
-  const filteredNodes = nodes.filter((node) => !constantsToRemove.has(node.id)).map((node) => nodeById.get(node.id) ?? node);
-  const remapDefaultIssues = validateRemapDefaults(filteredNodes);
-  const dynamicOutputs = Array.from(outputs);
-  const computedInputList = Array.from(computedInputs);
-  const filteredSummaryBindings = summaryBindings.filter(
-    (binding) => outputs.has(binding.animatableId) || computedInputs.has(binding.animatableId)
-  );
-  const 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) => ({
-          id: input.id,
-          path: input.path,
-          sourceId: input.sourceId,
-          label: input.label,
-          group: input.group,
-          defaultValue: input.defaultValue,
-          range: {
-            min: input.range.min,
-            max: input.range.max
-          }
-        })),
-        bindings: filteredSummaryBindings.map((binding) => ({
-          ...binding,
-          remap: { ...binding.remap },
-          expression: binding.expression,
-          valueType: binding.valueType,
-          issues: binding.issues ? [...binding.issues] : void 0
-        }))
-      }
-    }
-  };
-  const issuesByTarget = {};
-  bindingIssues.forEach((issues, targetId) => {
-    if (issues.size === 0) {
-      return;
-    }
-    issuesByTarget[targetId] = Array.from(issues);
-  });
-  const fatalIssues = /* @__PURE__ */ new Set();
-  Object.values(issuesByTarget).forEach((issues) => {
-    issues.forEach((issue) => fatalIssues.add(issue));
-  });
-  remapDefaultIssues.forEach((issue) => fatalIssues.add(issue));
-  return {
-    spec: specWithMetadata,
-    summary: {
-      faceId,
-      inputs: Array.from(inputNodes.values()).map(
-        ({ input }) => buildRigInputPath(faceId, input.path)
-      ),
-      outputs: [...dynamicOutputs, ...computedInputList],
-      bindings: filteredSummaryBindings
-    },
-    issues: {
-      byTarget: issuesByTarget,
-      fatal: Array.from(fatalIssues)
-    }
-  };
-}
-function validateRemapDefaults(nodes) {
-  const issues = [];
-  nodes.forEach((node) => {
-    if (node.type !== "centered_remap") {
-      return;
-    }
-    const defaults = node.input_defaults ?? {};
-    [
-      "in_low",
-      "in_anchor",
-      "in_high",
-      "out_low",
-      "out_anchor",
-      "out_high"
-    ].forEach((key) => {
-      const value = defaults[key];
-      if (typeof value !== "number" || !Number.isFinite(value)) {
-        issues.push(`Remap node ${node.id} missing ${key} default.`);
-      }
-    });
-  });
-  return issues;
-}
+  EXPRESSION_FUNCTION_VOCABULARY,
+  MACHINE_REPORT_VERSION,
+  PRIMARY_SLOT_ALIAS,
+  PRIMARY_SLOT_ID,
+  RESERVED_EXPRESSION_VARIABLES,
+  SCALAR_FUNCTIONS,
+  SCALAR_FUNCTION_VOCABULARY,
+  addBindingSlot,
+  bindingFromDefinition,
+  bindingTargetFromComponent,
+  bindingTargetFromInput,
+  bindingToDefinition,
+  buildCanonicalBindingExpression,
+  buildDefaultSlotExpression,
+  buildMachineReport,
+  buildPiecewiseRemapExpression,
+  buildRigGraphSpec,
+  collectExpressionReferences,
+  compileIrGraph,
+  createDefaultBinding,
+  createDefaultBindings,
+  createDefaultInputValues,
+  createDefaultParentBinding,
+  createDefaultRemap,
+  createExpressionVariableTable,
+  createIrGraphBuilder,
+  createLegacyIrGraph,
+  diffMachineReports,
+  ensureBindingStructure,
+  getPrimaryBindingSlot,
+  mapExpression,
+  parseControlExpression,
+  reconcileBindings,
+  remapValue,
+  removeBindingSlot,
+  toIrBindingSummary,
+  updateBindingExpression,
+  updateBindingSlotAlias,
+  updateBindingSlotRemap,
+  updateBindingSlotValueType,
+  updateBindingWithInput
+} from "./chunk-XYPRZPXJ.js";
 export {
+  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
 };