@vizij/node-graph-authoring 0.0.2

package/dist/index.cjs

@@ -0,0 +1,2367 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PRIMARY_SLOT_ALIAS: () => PRIMARY_SLOT_ALIAS,
+  PRIMARY_SLOT_ID: () => PRIMARY_SLOT_ID,
+  addBindingSlot: () => addBindingSlot,
+  bindingFromDefinition: () => bindingFromDefinition,
+  bindingOperatorDefinitions: () => bindingOperatorDefinitions,
+  bindingOperatorTypes: () => bindingOperatorTypes,
+  bindingTargetFromComponent: () => bindingTargetFromComponent,
+  bindingTargetFromInput: () => bindingTargetFromInput,
+  bindingToDefinition: () => bindingToDefinition,
+  buildRigGraphSpec: () => buildRigGraphSpec,
+  collectExpressionReferences: () => collectExpressionReferences,
+  createDefaultBinding: () => createDefaultBinding,
+  createDefaultBindings: () => createDefaultBindings,
+  createDefaultInputValues: () => createDefaultInputValues,
+  createDefaultOperatorSettings: () => createDefaultOperatorSettings,
+  createDefaultParentBinding: () => createDefaultParentBinding,
+  createDefaultRemap: () => createDefaultRemap,
+  ensureBindingStructure: () => ensureBindingStructure,
+  ensureOperatorParams: () => ensureOperatorParams,
+  getBindingOperatorDefinition: () => getBindingOperatorDefinition,
+  getPrimaryBindingSlot: () => getPrimaryBindingSlot,
+  mapExpression: () => mapExpression,
+  parseControlExpression: () => parseControlExpression,
+  reconcileBindings: () => reconcileBindings,
+  remapValue: () => remapValue,
+  removeBindingSlot: () => removeBindingSlot,
+  setBindingOperatorEnabled: () => setBindingOperatorEnabled,
+  updateBindingExpression: () => updateBindingExpression,
+  updateBindingOperatorParam: () => updateBindingOperatorParam,
+  updateBindingSlotAlias: () => updateBindingSlotAlias,
+  updateBindingSlotRemap: () => updateBindingSlotRemap,
+  updateBindingWithInput: () => updateBindingWithInput
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/graphBuilder.ts
+var import_utils2 = require("@vizij/utils");
+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) {
+    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 (0, import_utils.cloneRemapSettings)(remap);
+}
+function sanitizeRemap(remap, target) {
+  const normalized = normalizeRemap(remap, target);
+  const outputDefaults = deriveOutputDefaults(target);
+  if (!Number.isFinite(normalized.outLow)) {
+    normalized.outLow = outputDefaults.outLow;
+  }
+  if (!Number.isFinite(normalized.outHigh)) {
+    normalized.outHigh = outputDefaults.outHigh;
+  }
+  if (!Number.isFinite(normalized.outAnchor)) {
+    normalized.outAnchor = outputDefaults.outAnchor;
+  }
+  if (normalized.outLow > normalized.outHigh) {
+    const low = normalized.outHigh;
+    const high = normalized.outLow;
+    normalized.outLow = low;
+    normalized.outHigh = high;
+  }
+  normalized.outAnchor = clamp(
+    normalized.outAnchor,
+    normalized.outLow,
+    normalized.outHigh
+  );
+  return normalized;
+}
+function createDefaultRemap(target) {
+  const inputDefaults = deriveInputDefaults();
+  const outputDefaults = deriveOutputDefaults(target);
+  return {
+    inLow: inputDefaults.inLow,
+    inAnchor: inputDefaults.inAnchor,
+    inHigh: inputDefaults.inHigh,
+    outLow: outputDefaults.outLow,
+    outAnchor: outputDefaults.outAnchor,
+    outHigh: outputDefaults.outHigh
+  };
+}
+function 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: import_utils.SELF_BINDING_ID
+      };
+    }
+    return slot;
+  });
+  return {
+    ...ensured,
+    inputId: import_utils.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 === import_utils.SELF_BINDING_ID ? import_utils.SELF_BINDING_ID : primary.inputId ?? binding.inputId ?? null;
+  const primaryAlias = primaryInputId === import_utils.SELF_BINDING_ID ? "self" : primary.alias || PRIMARY_SLOT_ALIAS;
+  normalizedSlots[0] = {
+    ...primary,
+    id: primary.id || PRIMARY_SLOT_ID,
+    alias: primaryAlias,
+    inputId: primaryInputId,
+    remap: cloneRemap(primaryRemap),
+    valueType: sanitizeSlotValueType(primary.valueType, targetValueType)
+  };
+  normalizedSlots.slice(1).forEach((slot, index) => {
+    const slotRemap = sanitizeRemap(slot.remap, target);
+    normalizedSlots[index + 1] = {
+      ...slot,
+      id: slot.id || defaultSlotId(index + 1),
+      alias: slot.alias || defaultSlotId(index + 1),
+      remap: cloneRemap(slotRemap),
+      valueType: sanitizeSlotValueType(slot.valueType, targetValueType)
+    };
+  });
+  const rawExpression = typeof binding.expression === "string" ? binding.expression.trim() : "";
+  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
+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"],
+    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 = (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,
+    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 === import_utils3.SELF_BINDING_ID) {
+      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 === import_utils3.SELF_BINDING_ID || binding.slots.some((slot) => slot.inputId === import_utils3.SELF_BINDING_ID);
+        let selfNodeId;
+        if (requiresSelf) {
+          const sliderNodeId = `input_raw_${sanitizeNodeId(inputId)}`;
+          nodes.push({
+            id: sliderNodeId,
+            type: "input",
+            params: {
+              path: buildRigInputPath(faceId, input.path),
+              value: { float: defaultValue }
+            }
+          });
+          selfNodeId = sliderNodeId;
+        }
+        const { valueNodeId, hasActiveSlot } = evaluateBinding({
+          binding,
+          target,
+          targetId: inputId,
+          animatableId: inputId,
+          component: void 0,
+          safeId: sanitizeNodeId(inputId),
+          context: {
+            nodes,
+            edges,
+            ensureInputNode,
+            bindingIssues,
+            summaryBindings
+          },
+          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(
+          (0, import_utils2.buildAnimatableValue)(entry.animatable, void 0),
+          componentKey
+        );
+        const constNodeId = `const_${safeId}_${componentKey}`;
+        nodes.push({
+          id: constNodeId,
+          type: "constant",
+          params: {
+            value: componentDefault
+          }
+        });
+        sourceId = constNodeId;
+      }
+      edges.push({
+        from: { 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRIMARY_SLOT_ALIAS,
+  PRIMARY_SLOT_ID,
+  addBindingSlot,
+  bindingFromDefinition,
+  bindingOperatorDefinitions,
+  bindingOperatorTypes,
+  bindingTargetFromComponent,
+  bindingTargetFromInput,
+  bindingToDefinition,
+  buildRigGraphSpec,
+  collectExpressionReferences,
+  createDefaultBinding,
+  createDefaultBindings,
+  createDefaultInputValues,
+  createDefaultOperatorSettings,
+  createDefaultParentBinding,
+  createDefaultRemap,
+  ensureBindingStructure,
+  ensureOperatorParams,
+  getBindingOperatorDefinition,
+  getPrimaryBindingSlot,
+  mapExpression,
+  parseControlExpression,
+  reconcileBindings,
+  remapValue,
+  removeBindingSlot,
+  setBindingOperatorEnabled,
+  updateBindingExpression,
+  updateBindingOperatorParam,
+  updateBindingSlotAlias,
+  updateBindingSlotRemap,
+  updateBindingWithInput
+});