@vizij/node-graph-authoring 0.0.5 → 0.1.1

package/dist/{chunk-XYPRZPXJ.js → chunk-7UGGWHD3.js}

@@ -1,7 +1,7 @@
 // src/state.ts
 import {
-  cloneRemapSettings,
-  SELF_BINDING_ID
+  SELF_BINDING_ID,
+  cloneDeepSafe
 } from "@vizij/utils";
 var VECTOR_ANIMATABLE_TYPES = /* @__PURE__ */ new Set(["vector2", "vector3", "euler", "rgb"]);
 function deriveComponentValueType(component) {
@@ -41,9 +41,6 @@ function bindingTargetFromInput(input) {
     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";
@@ -119,131 +116,11 @@ function rewriteLegacyExpression(expression, replacements) {
     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 cloneBindingMetadata(metadata) {
   if (!metadata) {
     return void 0;
   }
-  return JSON.parse(JSON.stringify(metadata));
-}
-function sanitizeRemap(remap, target) {
-  const normalized = normalizeRemap(remap, target);
-  const outputDefaults = deriveOutputDefaults(target);
-  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
-  };
+  return cloneDeepSafe(metadata);
 }
 function createDefaultBindings(components) {
   const bindings = {};
@@ -253,21 +130,18 @@ function createDefaultBindings(components) {
   return bindings;
 }
 function createDefaultBinding(component) {
-  const remap = createDefaultRemap(component);
   const valueType = getTargetValueType(component);
   const slots = [
     {
       id: PRIMARY_SLOT_ID,
       alias: PRIMARY_SLOT_ALIAS,
       inputId: null,
-      remap: cloneRemap(remap),
       valueType
     }
   ];
   return {
     targetId: component.id,
     inputId: null,
-    remap,
     slots,
     expression: buildCanonicalExpressionFromSlots(slots)
   };
@@ -293,7 +167,6 @@ function createDefaultParentBinding(component) {
   };
 }
 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 : [
@@ -301,7 +174,6 @@ function ensurePrimarySlot(binding, target) {
       id: PRIMARY_SLOT_ID,
       alias: PRIMARY_SLOT_ALIAS,
       inputId: binding.inputId ?? null,
-      remap: cloneRemap(normalizedBindingRemap),
       valueType: targetValueType
     }
   ];
@@ -316,8 +188,6 @@ function ensurePrimarySlot(binding, target) {
       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,
@@ -327,13 +197,11 @@ function ensurePrimarySlot(binding, target) {
         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] = {
@@ -341,16 +209,13 @@ function ensurePrimarySlot(binding, target) {
     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)
     };
   });
@@ -365,7 +230,6 @@ function ensurePrimarySlot(binding, target) {
   const normalizedBinding = {
     ...binding,
     inputId: normalizedSlots[0].inputId ?? null,
-    remap: cloneRemap(primaryRemap),
     slots: normalizedSlots,
     expression
   };
@@ -392,14 +256,13 @@ function addBindingSlot(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)
+      valueType: getTargetValueType(target)
     }
   ];
   return ensurePrimarySlot(
@@ -513,50 +376,6 @@ function updateBindingExpression(binding, target, expression) {
     expression: trimmed.length > 0 ? trimmed : canonicalExpression
   };
 }
-function updateBindingSlotRemap(binding, target, slotId, field, value) {
-  const base = ensurePrimarySlot(binding, target);
-  const existingExpression = typeof base.expression === "string" ? base.expression.trim() : "";
-  const canonicalBefore = buildCanonicalExpressionFromSlots(base.slots);
-  const expressionWasDefault = expressionMatchesAliasOnly(existingExpression, base.slots) || expressionsEquivalent(existingExpression, canonicalBefore);
-  const nextSlots = base.slots.map((slot) => {
-    if (slot.id !== slotId) {
-      return slot;
-    }
-    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
-    };
-  }
-  if (!expressionWasDefault) {
-    return updated;
-  }
-  const canonicalAfter = buildCanonicalExpressionFromSlots(updated.slots);
-  if (expressionsEquivalent(updated.expression ?? "", canonicalAfter)) {
-    return updated;
-  }
-  return {
-    ...updated,
-    expression: canonicalAfter
-  };
-}
 function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID) {
   const base = ensurePrimarySlot(binding, target);
   const existingExpression = typeof base.expression === "string" ? base.expression.trim() : "";
@@ -564,39 +383,27 @@ function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID
   const expressionWasDefault = expressionMatchesAliasOnly(existingExpression, base.slots) || expressionsEquivalent(existingExpression, canonicalBefore);
   const slotIndex = base.slots.findIndex((slot) => slot.id === slotId);
   const effectiveIndex = slotIndex >= 0 ? slotIndex : base.slots.length;
-  const slots = base.slots.map((slot) => ({
-    ...slot,
-    remap: cloneRemap(slot.remap)
-  }));
+  const slots = base.slots.map((slot) => ({ ...slot }));
   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))
+      valueType: getTargetValueType(target)
     });
   }
   const currentSlot = slots[effectiveIndex];
   let nextBinding;
   if (!input) {
-    const normalizedSlotRemap = sanitizeRemap(currentSlot.remap, target);
-    const updatedRemap = {
-      ...normalizedSlotRemap,
-      inLow: DEFAULT_INPUT_RANGE.min,
-      inAnchor: DEFAULT_INPUT_ANCHOR,
-      inHigh: DEFAULT_INPUT_RANGE.max
-    };
     slots[effectiveIndex] = {
       ...currentSlot,
-      inputId: null,
-      remap: cloneRemap(updatedRemap)
+      inputId: null
     };
     if (effectiveIndex === 0) {
       nextBinding = {
         ...base,
         inputId: null,
-        remap: cloneRemap(updatedRemap),
         slots
       };
     } else {
@@ -606,24 +413,14 @@ function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID
       };
     }
   } else {
-    const normalizedRemap = sanitizeRemap(currentSlot.remap, target);
-    const updatedRemap = {
-      ...normalizedRemap,
-      inLow: input.range.min,
-      inAnchor: clamp(input.defaultValue, input.range.min, input.range.max),
-      inHigh: input.range.max,
-      ...deriveOutputDefaults(target)
-    };
     slots[effectiveIndex] = {
       ...currentSlot,
-      inputId: input.id,
-      remap: cloneRemap(updatedRemap)
+      inputId: input.id
     };
     if (effectiveIndex === 0) {
       nextBinding = {
         ...base,
         inputId: input.id,
-        remap: cloneRemap(updatedRemap),
         slots
       };
     } else {
@@ -645,26 +442,6 @@ function updateBindingWithInput(binding, target, input, slotId = PRIMARY_SLOT_ID
     expression: canonicalAfter
   };
 }
-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) => {
@@ -682,12 +459,10 @@ function reconcileBindings(previous, components) {
         if (replaced && replaced !== normalizedAlias) {
           aliasReplacements.set(replaced, normalizedAlias);
         }
-        const slotRemap = sanitizeRemap(slot.remap, component);
         return {
           ...slot,
           id: normalizedId,
-          alias: normalizedAlias,
-          remap: cloneRemap(slotRemap)
+          alias: normalizedAlias
         };
       });
       const primary = slots[0];
@@ -697,7 +472,6 @@ function reconcileBindings(previous, components) {
         ...ensured,
         targetId: component.id,
         inputId: primary.inputId ?? null,
-        remap: cloneRemap(primary.remap),
         slots,
         expression
       };
@@ -710,11 +484,7 @@ function reconcileBindings(previous, components) {
 function bindingToDefinition(binding) {
   const definition = {
     inputId: binding.inputId ?? null,
-    remap: cloneRemap(binding.remap),
-    slots: binding.slots.map((slot) => ({
-      ...slot,
-      remap: cloneRemap(slot.remap)
-    })),
+    slots: binding.slots.map((slot) => ({ ...slot })),
     expression: binding.expression,
     metadata: cloneBindingMetadata(binding.metadata)
   };
@@ -727,46 +497,12 @@ function bindingFromDefinition(target, definition) {
   const binding = {
     targetId: target.id,
     inputId: definition.inputId ?? null,
-    remap: cloneRemap(definition.remap),
-    slots: definition.slots.map((slot) => ({
-      ...slot,
-      remap: cloneRemap(slot.remap)
-    })),
+    slots: definition.slots.map((slot) => ({ ...slot })),
     expression: definition.expression,
     metadata: cloneBindingMetadata(definition.metadata)
   };
   return ensureBindingStructure(binding, target);
 }
-function sanitizeLiteral(value) {
-  if (!Number.isFinite(value)) {
-    return 0;
-  }
-  if (Object.is(value, -0)) {
-    return 0;
-  }
-  return value;
-}
-function formatVectorLiteral(values) {
-  return `vec(${values.map((value) => sanitizeLiteral(value)).join(", ")})`;
-}
-function buildPiecewiseRemapExpression(alias, remap) {
-  const sanitizedAlias = alias && alias.trim().length > 0 ? alias.trim() : PRIMARY_SLOT_ALIAS;
-  const inputBreakpoints = [remap.inLow, remap.inAnchor, remap.inHigh];
-  const outputBreakpoints = [remap.outLow, remap.outAnchor, remap.outHigh];
-  return `piecewise_remap(${sanitizedAlias}, ${formatVectorLiteral(
-    inputBreakpoints
-  )}, ${formatVectorLiteral(outputBreakpoints)})`;
-}
-function isSelfAlias(alias) {
-  return alias.trim().toLowerCase() === "self";
-}
-function buildDefaultSlotExpression(alias, inputId, remap) {
-  const sanitizedAlias = alias && alias.trim().length > 0 ? alias.trim() : PRIMARY_SLOT_ALIAS;
-  if (inputId === SELF_BINDING_ID || isSelfAlias(sanitizedAlias)) {
-    return sanitizedAlias;
-  }
-  return buildPiecewiseRemapExpression(sanitizedAlias, remap);
-}
 function normalizeSlotAliasForExpression(slot, index) {
   if (slot.alias && slot.alias.trim().length > 0) {
     return slot.alias.trim();
@@ -783,16 +519,7 @@ function buildAliasOnlyExpression(slots) {
   return slots.map((slot, index) => normalizeSlotAliasForExpression(slot, index)).join(" + ");
 }
 function buildCanonicalExpressionFromSlots(slots) {
-  if (!slots.length) {
-    return PRIMARY_SLOT_ALIAS;
-  }
-  return slots.map(
-    (slot, index) => buildDefaultSlotExpression(
-      normalizeSlotAliasForExpression(slot, index),
-      slot.inputId ?? null,
-      slot.remap
-    )
-  ).join(" + ");
+  return buildAliasOnlyExpression(slots);
 }
 function expressionsEquivalent(left, right) {
   return left.trim() === right.trim();
@@ -1903,9 +1630,7 @@ var DefaultExpressionVariableTable = class {
         targetId: options.targetId,
         animatableId: options.animatableId,
         component: options.component,
-        valueType: options.valueType,
-        remap: options.remap,
-        autoRemap: options.autoRemap
+        valueType: options.valueType
       }
     });
   }
@@ -2088,12 +1813,12 @@ function createLegacyIrGraph(payload) {
 function toIrBindingSummary(summaries) {
   return summaries.map((summary) => ({
     ...summary,
-    remap: { ...summary.remap },
     issues: summary.issues ? [...summary.issues] : void 0
   }));
 }
 
 // src/ir/compiler.ts
+import { cloneDeepSafe as cloneDeepSafe2 } from "@vizij/utils";
 function compileIrGraph(graph, options = {}) {
   const preferLegacy = options.preferLegacySpec === true;
   const legacySpec = graph.legacy?.spec;
@@ -2178,7 +1903,7 @@ function cloneJsonLike(value) {
   if (value === void 0 || value === null) {
     return value;
   }
-  return JSON.parse(JSON.stringify(value));
+  return cloneDeepSafe2(value);
 }
 function inlineSingleUseConstants(spec) {
   const nodes = spec.nodes ?? [];
@@ -2217,13 +1942,25 @@ function inlineSingleUseConstants(spec) {
 }
 
 // src/graphBuilder.ts
-import { buildAnimatableValue } from "@vizij/utils";
+import {
+  RIG_PIPELINE_V1_VERSION,
+  buildAnimatableValue,
+  cloneDeepSafe as cloneDeepSafe4,
+  hasRigPipelineV1InputConfig,
+  isRigElementStandardInputPath,
+  normalizeStandardRigInputPath,
+  resolveRigPipelineV1InputConfig,
+  resolveStandardRigInputId
+} from "@vizij/utils";
 import { SELF_BINDING_ID as SELF_BINDING_ID2 } from "@vizij/utils";
 import { nodeRegistryVersion } from "@vizij/node-graph-wasm/metadata";
 
 // src/bindingMetadata.ts
+import {
+  cloneDeepSafe as cloneDeepSafe3
+} from "@vizij/utils";
 function cloneOperand(entry) {
-  return JSON.parse(JSON.stringify(entry));
+  return cloneDeepSafe3(entry);
 }
 function describeSlot(entry) {
   const metadata = entry.metadata;
@@ -2265,17 +2002,17 @@ function describeReference(node, variables) {
 function stringifyExpression(node) {
   switch (node.type) {
     case "Literal":
-      return Number.isFinite(node.value) ? `${node.value}` : "0";
+      return Number.isFinite(node.value) ? `${node.value} ` : "0";
     case "VectorLiteral":
       return `vec(${node.values.join(", ")})`;
     case "Reference":
       return node.name;
     case "Unary":
-      return `${node.operator}${stringifyExpression(node.operand)}`;
+      return `${node.operator}${stringifyExpression(node.operand)} `;
     case "Binary":
-      return `${stringifyExpression(node.left)} ${node.operator} ${stringifyExpression(node.right)}`;
+      return `${stringifyExpression(node.left)} ${node.operator} ${stringifyExpression(node.right)} `;
     case "Function":
-      return `${node.name}(${node.args.map(stringifyExpression).join(", ")})`;
+      return `${node.name} (${node.args.map(stringifyExpression).join(", ")})`;
     default:
       return "";
   }
@@ -2340,6 +2077,61 @@ function buildBindingMetadataFromExpression(node, variables) {
 }
 
 // src/graphBuilder.ts
+function resolveBindingSlotInputId(bindingInputId, inputsById) {
+  if (!bindingInputId || bindingInputId === SELF_BINDING_ID2) {
+    return bindingInputId;
+  }
+  const resolvedInputId = resolveStandardRigInputId(bindingInputId, inputsById);
+  if (inputsById.has(resolvedInputId)) {
+    return resolvedInputId;
+  }
+  return bindingInputId;
+}
+function isRigElementAliasInput(inputId, inputsById) {
+  const input = inputsById.get(inputId);
+  if (!input?.path) {
+    return false;
+  }
+  return isRigElementStandardInputPath(input.path);
+}
+function isHigherOrderRigBindingInput(inputId, inputsById) {
+  const input = inputsById.get(inputId);
+  if (!input?.path) {
+    return false;
+  }
+  if (isRigElementAliasInput(inputId, inputsById)) {
+    return false;
+  }
+  return true;
+}
+function bindingReferencesRigElementInput(binding, inputsById) {
+  const candidateInputIds = /* @__PURE__ */ new Set();
+  if (binding.inputId && binding.inputId !== SELF_BINDING_ID2) {
+    candidateInputIds.add(binding.inputId);
+  }
+  binding.slots.forEach((slot) => {
+    if (slot.inputId && slot.inputId !== SELF_BINDING_ID2) {
+      candidateInputIds.add(slot.inputId);
+    }
+  });
+  for (const candidateInputId of candidateInputIds) {
+    if (isRigElementStandardInputPath(candidateInputId)) {
+      return true;
+    }
+    const resolvedCandidateId = resolveBindingSlotInputId(
+      candidateInputId,
+      inputsById
+    );
+    if (!resolvedCandidateId || resolvedCandidateId === SELF_BINDING_ID2) {
+      continue;
+    }
+    const resolvedInput = inputsById.get(resolvedCandidateId);
+    if (resolvedInput && isRigElementStandardInputPath(resolvedInput.path)) {
+      return true;
+    }
+  }
+  return false;
+}
 function evaluateBinding({
   binding,
   target,
@@ -2348,9 +2140,18 @@ function evaluateBinding({
   component,
   safeId,
   context,
-  selfNodeId
+  selfNodeId,
+  enforceRigBoundaryRules = false
 }) {
-  const { nodes, edges, ensureInputNode, bindingIssues, summaryBindings } = context;
+  const {
+    nodes,
+    edges,
+    ensureInputNode,
+    bindingIssues,
+    summaryBindings,
+    inputsById,
+    inputBindings
+  } = context;
   const exprContext = {
     componentSafeId: safeId,
     nodes,
@@ -2359,7 +2160,6 @@ function evaluateBinding({
     counter: 0,
     reservedNodes: /* @__PURE__ */ new Map(),
     nodeValueTypes: /* @__PURE__ */ new Map(),
-    slotRemapNodes: /* @__PURE__ */ new Map(),
     graphReservedNodes: context.graphReservedNodes,
     generateReservedNodeId: context.generateReservedNodeId
   };
@@ -2375,6 +2175,10 @@ function evaluateBinding({
     const fallbackAlias = `s${index + 1}`;
     const alias = aliasBase.length > 0 ? aliasBase : fallbackAlias;
     const slotId = slot.id && slot.id.length > 0 ? slot.id : alias;
+    const resolvedSlotInputId = resolveBindingSlotInputId(
+      slot.inputId,
+      inputsById
+    );
     const slotValueType = slot.valueType === "vector" ? "vector" : "scalar";
     let slotOutputId;
     if (slot.inputId === SELF_BINDING_ID2) {
@@ -2390,19 +2194,30 @@ function evaluateBinding({
         expressionIssues.push("Self reference unavailable for this input.");
         slotOutputId = getConstantNodeId(exprContext, target.defaultValue);
       }
-    } else if (slot.inputId) {
-      const inputNode = ensureInputNode(slot.inputId);
-      if (inputNode) {
-        slotOutputId = inputNode.nodeId;
-        hasActiveSlot = true;
-        setNodeValueType(
-          exprContext,
-          slotOutputId,
-          slotValueType === "vector" ? "vector" : "scalar"
+    } else if (resolvedSlotInputId) {
+      const inputId = resolvedSlotInputId;
+      const sourceBinding = inputBindings[inputId];
+      const allowedHigherOrderViaRigElementSource = sourceBinding !== void 0 && bindingReferencesRigElementInput(sourceBinding, inputsById);
+      if (enforceRigBoundaryRules && isHigherOrderRigBindingInput(inputId, inputsById) && !allowedHigherOrderViaRigElementSource && inputId !== SELF_BINDING_ID2) {
+        expressionIssues.push(
+          `Input "${inputId}" is a higher-order rig input and cannot directly drive animatable "${target.id}".`
         );
-      } else {
-        expressionIssues.push(`Missing standard input "${slot.inputId}".`);
         slotOutputId = getConstantNodeId(exprContext, 0);
+        hasActiveSlot = true;
+      } else {
+        const inputNode = ensureInputNode(inputId);
+        if (inputNode) {
+          slotOutputId = inputNode.nodeId;
+          hasActiveSlot = true;
+          setNodeValueType(
+            exprContext,
+            slotOutputId,
+            slotValueType === "vector" ? "vector" : "scalar"
+          );
+        } else {
+          expressionIssues.push(`Missing standard input "${inputId}".`);
+          slotOutputId = getConstantNodeId(exprContext, 0);
+        }
       }
     } else {
       slotOutputId = getConstantNodeId(exprContext, 0);
@@ -2412,13 +2227,11 @@ function evaluateBinding({
       nodeId: slotOutputId,
       slotId,
       slotAlias: alias,
-      inputId: slot.inputId ?? null,
+      inputId: resolvedSlotInputId ?? null,
       targetId,
       animatableId,
       component,
-      valueType: slotValueType,
-      remap: { ...slot.remap },
-      autoRemap: slot.inputId !== SELF_BINDING_ID2 && slotValueType === "scalar"
+      valueType: slotValueType
     });
     setNodeValueType(
       exprContext,
@@ -2431,8 +2244,7 @@ function evaluateBinding({
       component,
       slotId,
       slotAlias: alias,
-      inputId: slot.inputId ?? null,
-      remap: { ...slot.remap },
+      inputId: resolvedSlotInputId ?? null,
       expression: trimmedExpression,
       valueType: slotValueType,
       nodeId: slotOutputId,
@@ -2451,9 +2263,7 @@ function evaluateBinding({
       targetId,
       animatableId,
       component,
-      valueType: targetValueType,
-      remap: createDefaultRemap(target),
-      autoRemap: false
+      valueType: targetValueType
     });
     setNodeValueType(
       exprContext,
@@ -2467,7 +2277,6 @@ function evaluateBinding({
       slotId: PRIMARY_SLOT_ID,
       slotAlias: alias,
       inputId: null,
-      remap: createDefaultRemap(target),
       expression: trimmedExpression,
       valueType: targetValueType,
       nodeId: constantId,
@@ -2582,6 +2391,20 @@ function buildRigInputPath(faceId, inputPath) {
   const suffix = trimmed ? `/${trimmed}` : "";
   return `rig/${faceId}${suffix}`;
 }
+function buildPoseControlInputPath(faceId, inputId) {
+  return `rig/${faceId}/pose/control/${inputId}`;
+}
+function isPoseWeightInputPath(path) {
+  const normalized = normalizeStandardRigInputPath(path);
+  return normalized.startsWith("/poses/") && normalized.endsWith(".weight");
+}
+function isPoseControlPath(path) {
+  const normalized = normalizeStandardRigInputPath(path);
+  return normalized.startsWith("/pose/control/");
+}
+function resolveInputComposeMode(mode) {
+  return mode === "average" ? "average" : "add";
+}
 function getComponentOrder(animatable) {
   switch (animatable.type) {
     case "vector2":
@@ -2664,73 +2487,6 @@ function ensureOperandValueType(context, operandId, expected, functionName, inpu
     `Function "${functionName}" expects ${expectation} input for "${inputId}", but the expression produced ${actual}.`
   );
 }
-function resolveSlotReferenceNode(entry, fallbackNodeId, context) {
-  if (entry.kind !== "slot") {
-    return fallbackNodeId;
-  }
-  const metadata = entry.metadata;
-  if (!metadata || metadata.autoRemap === false || !metadata.remap) {
-    return fallbackNodeId;
-  }
-  if (metadata.valueType !== "scalar") {
-    return fallbackNodeId;
-  }
-  if (isIdentityRemap(metadata.remap)) {
-    return fallbackNodeId;
-  }
-  const cacheKey = metadata.slotId ?? entry.name;
-  const existing = context.slotRemapNodes.get(cacheKey);
-  if (existing) {
-    return existing;
-  }
-  const remapNodeId = createSlotRemapNode(
-    context,
-    fallbackNodeId,
-    metadata.remap,
-    metadata.slotAlias ?? cacheKey
-  );
-  context.slotRemapNodes.set(cacheKey, remapNodeId);
-  return remapNodeId;
-}
-function createSlotRemapNode(context, sourceNodeId, remap, slotKey) {
-  const safeSlotKey = sanitizeNodeId(slotKey || "slot");
-  const nodeId = `slot_remap_${safeSlotKey}_${context.counter++}`;
-  context.nodes.push({
-    id: nodeId,
-    type: "centered_remap",
-    inputDefaults: {
-      in_low: remap.inLow,
-      in_anchor: remap.inAnchor,
-      in_high: remap.inHigh,
-      out_low: remap.outLow,
-      out_anchor: remap.outAnchor,
-      out_high: remap.outHigh
-    }
-  });
-  context.edges.push({
-    from: { nodeId: sourceNodeId },
-    to: { nodeId, portId: "in" }
-  });
-  setNodeValueType(context, nodeId, "scalar");
-  return nodeId;
-}
-function isIdentityRemap(remap) {
-  return nearlyEqual(remap.inLow, remap.outLow) && nearlyEqual(remap.inAnchor, remap.outAnchor) && nearlyEqual(remap.inHigh, remap.outHigh);
-}
-function nearlyEqual(a, b, epsilon = 1e-4) {
-  return Math.abs(a - b) <= epsilon;
-}
-var REMAP_FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
-  "piecewise_remap",
-  "centered_remap",
-  "remap"
-]);
-function shouldSkipAutoRemapForArgument(nodeType, index) {
-  if (!REMAP_FUNCTION_NODE_TYPES.has(nodeType)) {
-    return false;
-  }
-  return index === 0;
-}
 function getConstantNodeId(context, value) {
   const key = Number.isFinite(value) ? value.toString() : "NaN";
   const existing = context.constants.get(key);
@@ -3189,8 +2945,7 @@ var BINARY_FUNCTION_OPERATOR_MAP = {
   "&&": "and",
   "||": "or"
 };
-function materializeExpression(node, context, variables, issues, options) {
-  const autoRemap = options?.autoRemap !== false;
+function materializeExpression(node, context, variables, issues) {
   switch (node.type) {
     case "Literal": {
       return getConstantNodeId(context, node.value);
@@ -3205,10 +2960,7 @@ function materializeExpression(node, context, variables, issues, options) {
         return getConstantNodeId(context, 0);
       }
       const mappedId = entry.nodeId ?? getConstantNodeId(context, 0);
-      if (!autoRemap || entry.kind !== "slot") {
-        return mappedId;
-      }
-      return resolveSlotReferenceNode(entry, mappedId, context);
+      return mappedId;
     }
     case "Unary": {
       const operandId = materializeExpression(
@@ -3346,13 +3098,7 @@ function materializeExpression(node, context, variables, issues, options) {
       );
       const operandNodes = argNodes.slice(0, operandLimit);
       const operands = operandNodes.map(
-        (arg, index) => materializeExpression(
-          arg,
-          context,
-          variables,
-          issues,
-          shouldSkipAutoRemapForArgument(definition.nodeType, index) ? { autoRemap: false } : void 0
-        )
+        (arg, _index) => materializeExpression(arg, context, variables, issues)
       );
       const paramArgStart = operandLimit;
       const paramArgNodes = paramArgCount > 0 ? argNodes.slice(paramArgStart, paramArgStart + paramArgCount) : [];
@@ -3381,7 +3127,9 @@ function buildRigGraphSpec({
   bindings,
   inputsById,
   inputBindings,
-  inputMetadata
+  inputMetadata,
+  inputComposeModesById,
+  pipelineV1
 }) {
   const metadataByInputId = inputMetadata ?? /* @__PURE__ */ new Map();
   const irBuilder = createIrGraphBuilder({
@@ -3404,8 +3152,634 @@ function buildRigGraphSpec({
   const computedInputs = /* @__PURE__ */ new Set();
   const summaryBindings = [];
   const bindingIssues = /* @__PURE__ */ new Map();
+  const stagedPipelineByInputId = /* @__PURE__ */ new Map();
   const animatableEntries = /* @__PURE__ */ new Map();
   const outputs = /* @__PURE__ */ new Set();
+  const composeModeByInputId = /* @__PURE__ */ new Map();
+  Object.entries(inputComposeModesById ?? {}).forEach(([inputId, mode]) => {
+    if (!inputsById.has(inputId)) {
+      return;
+    }
+    composeModeByInputId.set(inputId, resolveInputComposeMode(mode));
+  });
+  const shouldComposeInputWithPoseControl = (input) => {
+    if (!composeModeByInputId.has(input.id)) {
+      return false;
+    }
+    if (isPoseWeightInputPath(input.path)) {
+      return false;
+    }
+    if (isPoseControlPath(input.path)) {
+      return false;
+    }
+    return true;
+  };
+  const buildNormalizedAdditiveBlendNodeId = ({
+    nodeIdPrefix,
+    sourceNodeIds,
+    baseline
+  }) => {
+    if (sourceNodeIds.length === 0) {
+      const fallbackNodeId = `${nodeIdPrefix}_baseline`;
+      nodes.push({
+        id: fallbackNodeId,
+        type: "constant",
+        params: {
+          value: baseline
+        }
+      });
+      return fallbackNodeId;
+    }
+    if (sourceNodeIds.length === 1) {
+      return sourceNodeIds[0];
+    }
+    const addNodeId = `${nodeIdPrefix}_add`;
+    nodes.push({
+      id: addNodeId,
+      type: "add"
+    });
+    sourceNodeIds.forEach((sourceNodeId, index) => {
+      edges.push({
+        from: { nodeId: sourceNodeId },
+        to: { nodeId: addNodeId, portId: `operand_${index + 1}` }
+      });
+    });
+    const normalizedNodeId = `${nodeIdPrefix}_normalized_add`;
+    nodes.push({
+      id: normalizedNodeId,
+      type: "subtract",
+      inputDefaults: {
+        rhs: (sourceNodeIds.length - 1) * baseline
+      }
+    });
+    edges.push({
+      from: { nodeId: addNodeId },
+      to: { nodeId: normalizedNodeId, portId: "lhs" }
+    });
+    return normalizedNodeId;
+  };
+  const splitTopLevelCommaSeparated = (value) => {
+    const segments = [];
+    let depthParen = 0;
+    let depthBracket = 0;
+    let start = 0;
+    for (let index = 0; index < value.length; index += 1) {
+      const char = value[index];
+      if (char === "(") {
+        depthParen += 1;
+        continue;
+      }
+      if (char === ")") {
+        depthParen = Math.max(0, depthParen - 1);
+        continue;
+      }
+      if (char === "[") {
+        depthBracket += 1;
+        continue;
+      }
+      if (char === "]") {
+        depthBracket = Math.max(0, depthBracket - 1);
+        continue;
+      }
+      if (char === "," && depthParen === 0 && depthBracket === 0) {
+        segments.push(value.slice(start, index));
+        start = index + 1;
+      }
+    }
+    segments.push(value.slice(start));
+    return segments;
+  };
+  const stripTopLevelAssignment = (value) => {
+    let depthParen = 0;
+    let depthBracket = 0;
+    for (let index = 0; index < value.length; index += 1) {
+      const char = value[index];
+      if (char === "(") {
+        depthParen += 1;
+        continue;
+      }
+      if (char === ")") {
+        depthParen = Math.max(0, depthParen - 1);
+        continue;
+      }
+      if (char === "[") {
+        depthBracket += 1;
+        continue;
+      }
+      if (char === "]") {
+        depthBracket = Math.max(0, depthBracket - 1);
+        continue;
+      }
+      if (char !== "=" || depthParen !== 0 || depthBracket !== 0) {
+        continue;
+      }
+      const previous = value[index - 1];
+      const next = value[index + 1];
+      if (previous === "=" || next === "=") {
+        continue;
+      }
+      return value.slice(index + 1).trim();
+    }
+    return value.trim();
+  };
+  const isNormalizedAdditiveFunctionName = (value) => {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "normalizedadditive" || normalized === "normalizedaddative" || normalized === "noramalizedadditive" || normalized === "noramalizedaddative";
+  };
+  const buildNormalizedAdditiveExpression = (value) => {
+    const args = splitTopLevelCommaSeparated(value).map(
+      (entry) => entry.trim()
+    );
+    if (args.length === 0) {
+      return "default";
+    }
+    const parentTerms = [];
+    let baselineExpression = "default";
+    const firstArg = args[0];
+    if (firstArg && firstArg.startsWith("[") && firstArg.endsWith("]")) {
+      const inner = firstArg.slice(1, -1).trim();
+      if (inner.length > 0) {
+        splitTopLevelCommaSeparated(inner).forEach((entry) => {
+          const term = entry.trim();
+          if (term.length > 0) {
+            parentTerms.push(term);
+          }
+        });
+      }
+      args.slice(1).forEach((entry) => {
+        const baselineMatch = entry.match(/^baseline\s*=\s*(.+)$/i);
+        if (baselineMatch?.[1]) {
+          baselineExpression = baselineMatch[1].trim();
+          return;
+        }
+        const term = entry.trim();
+        if (term.length > 0) {
+          parentTerms.push(term);
+        }
+      });
+    } else {
+      args.forEach((entry) => {
+        const baselineMatch = entry.match(/^baseline\s*=\s*(.+)$/i);
+        if (baselineMatch?.[1]) {
+          baselineExpression = baselineMatch[1].trim();
+          return;
+        }
+        const term = entry.trim();
+        if (term.length > 0) {
+          parentTerms.push(term);
+        }
+      });
+    }
+    if (parentTerms.length === 0) {
+      return `(${baselineExpression})`;
+    }
+    if (parentTerms.length === 1) {
+      return `(${parentTerms[0]})`;
+    }
+    return `((${parentTerms.join(" + ")}) - (${parentTerms.length - 1}) * (${baselineExpression}))`;
+  };
+  const rewriteNormalizedAdditiveCalls = (value) => {
+    let cursor = 0;
+    let rewritten = "";
+    while (cursor < value.length) {
+      const remaining = value.slice(cursor);
+      const match = remaining.match(
+        /(normalizedadditive|normalizedaddative|noramalizedadditive|noramalizedaddative)\s*\(/i
+      );
+      if (!match || match.index === void 0) {
+        rewritten += remaining;
+        break;
+      }
+      const matchStart = cursor + match.index;
+      const functionName = match[1] ?? "";
+      const openParenIndex = value.indexOf(
+        "(",
+        matchStart + functionName.length
+      );
+      if (openParenIndex < 0) {
+        rewritten += value.slice(cursor);
+        break;
+      }
+      rewritten += value.slice(cursor, matchStart);
+      let depth = 1;
+      let closeParenIndex = openParenIndex + 1;
+      while (closeParenIndex < value.length && depth > 0) {
+        const char = value[closeParenIndex];
+        if (char === "(") {
+          depth += 1;
+        } else if (char === ")") {
+          depth -= 1;
+        }
+        closeParenIndex += 1;
+      }
+      if (depth !== 0) {
+        rewritten += value.slice(matchStart);
+        break;
+      }
+      const argsContent = value.slice(openParenIndex + 1, closeParenIndex - 1);
+      if (isNormalizedAdditiveFunctionName(functionName)) {
+        rewritten += buildNormalizedAdditiveExpression(argsContent);
+      } else {
+        rewritten += value.slice(matchStart, closeParenIndex);
+      }
+      cursor = closeParenIndex;
+    }
+    return rewritten;
+  };
+  const normalizeStagedFormulaExpression = (expression) => {
+    const rhs = stripTopLevelAssignment(expression);
+    return rewriteNormalizedAdditiveCalls(rhs);
+  };
+  const normalizeFormulaSignature = (expression) => normalizeStagedFormulaExpression(expression).replace(/\s+/g, "").toLowerCase();
+  const buildDefaultParentTransformNodeId = (params) => {
+    let transformedNodeId = params.sourceNodeId;
+    if (params.scale !== 1) {
+      const scaledNodeId = `input_parent_scale_${params.nodeSuffix}`;
+      nodes.push({
+        id: scaledNodeId,
+        type: "multiply",
+        inputDefaults: {
+          operand_2: params.scale
+        }
+      });
+      edges.push({
+        from: { nodeId: transformedNodeId },
+        to: { nodeId: scaledNodeId, portId: "operand_1" }
+      });
+      transformedNodeId = scaledNodeId;
+    }
+    if (params.offset !== 0) {
+      const offsetNodeId = `input_parent_offset_${params.nodeSuffix}`;
+      nodes.push({
+        id: offsetNodeId,
+        type: "add",
+        inputDefaults: {
+          operand_2: params.offset
+        }
+      });
+      edges.push({
+        from: { nodeId: transformedNodeId },
+        to: { nodeId: offsetNodeId, portId: "operand_1" }
+      });
+      transformedNodeId = offsetNodeId;
+    }
+    return transformedNodeId;
+  };
+  const buildStagedFormulaNodeId = (params) => {
+    const normalizedExpression = normalizeStagedFormulaExpression(
+      params.expression
+    );
+    if (!normalizedExpression) {
+      return params.fallbackNodeId;
+    }
+    const parseResult = parseControlExpression(normalizedExpression);
+    const issues = [];
+    if (!parseResult.node) {
+      parseResult.errors.forEach((error) => {
+        issues.push(
+          `${params.issuePrefix}: ${error.message} (index ${error.index}).`
+        );
+      });
+    }
+    if (!parseResult.node || issues.length > 0) {
+      const issueSet = bindingIssues.get(params.inputId) ?? /* @__PURE__ */ new Set();
+      issues.forEach((issue) => issueSet.add(issue));
+      if (issues.length > 0) {
+        bindingIssues.set(params.inputId, issueSet);
+      }
+      return params.fallbackNodeId;
+    }
+    const exprContext = {
+      componentSafeId: params.componentSafeId,
+      nodes,
+      edges,
+      constants: /* @__PURE__ */ new Map(),
+      counter: 1,
+      reservedNodes: /* @__PURE__ */ new Map(),
+      nodeValueTypes: /* @__PURE__ */ new Map(),
+      graphReservedNodes,
+      generateReservedNodeId
+    };
+    const variableTable = createExpressionVariableTable();
+    const registerVariableName = (name, nodeId2) => {
+      const trimmed = name.trim();
+      if (!trimmed) {
+        return;
+      }
+      variableTable.registerReservedVariable({
+        name: trimmed,
+        nodeId: nodeId2,
+        description: "Staged pipeline formula variable"
+      });
+      const lower = trimmed.toLowerCase();
+      if (lower !== trimmed) {
+        variableTable.registerReservedVariable({
+          name: lower,
+          nodeId: nodeId2,
+          description: "Staged pipeline formula variable"
+        });
+      }
+    };
+    Object.entries(params.variables).forEach(([name, variable]) => {
+      const nodeId2 = variable.nodeId ?? (typeof variable.value === "number" && Number.isFinite(variable.value) ? getConstantNodeId(exprContext, variable.value) : null);
+      if (!nodeId2) {
+        return;
+      }
+      registerVariableName(name, nodeId2);
+    });
+    const references = collectExpressionReferences(parseResult.node);
+    const missingVariables = variableTable.missing(references);
+    if (missingVariables.length > 0) {
+      const issueSet = bindingIssues.get(params.inputId) ?? /* @__PURE__ */ new Set();
+      missingVariables.forEach((entry) => {
+        issueSet.add(
+          `${params.issuePrefix}: unknown formula variable "${entry.name}".`
+        );
+      });
+      bindingIssues.set(params.inputId, issueSet);
+      return params.fallbackNodeId;
+    }
+    validateLiteralParamArguments(parseResult.node, issues);
+    const nodeId = materializeExpression(
+      parseResult.node,
+      exprContext,
+      variableTable,
+      issues
+    );
+    if (issues.length > 0) {
+      const issueSet = bindingIssues.get(params.inputId) ?? /* @__PURE__ */ new Set();
+      issues.forEach(
+        (issue) => issueSet.add(`${params.issuePrefix}: ${issue}`)
+      );
+      bindingIssues.set(params.inputId, issueSet);
+      return params.fallbackNodeId;
+    }
+    return nodeId;
+  };
+  const buildLegacyEffectiveInputNodeId = (input, directNodeId) => {
+    if (!shouldComposeInputWithPoseControl(input)) {
+      return directNodeId;
+    }
+    const safeInputId = sanitizeNodeId(input.id);
+    const composeBaseline = Number.isFinite(input.defaultValue) ? input.defaultValue : 0;
+    const poseControlNodeId = `input_pose_control_${safeInputId}`;
+    nodes.push({
+      id: poseControlNodeId,
+      type: "input",
+      params: {
+        path: buildPoseControlInputPath(faceId, input.id),
+        value: { float: composeBaseline }
+      }
+    });
+    const composeAddNodeId = `input_compose_add_${safeInputId}`;
+    nodes.push({
+      id: composeAddNodeId,
+      type: "add"
+    });
+    edges.push(
+      {
+        from: { nodeId: directNodeId },
+        to: { nodeId: composeAddNodeId, portId: "operand_1" }
+      },
+      {
+        from: { nodeId: poseControlNodeId },
+        to: { nodeId: composeAddNodeId, portId: "operand_2" }
+      }
+    );
+    const composeMode = composeModeByInputId.get(input.id) ?? "add";
+    let composeOutputNodeId = composeAddNodeId;
+    if (composeMode === "average") {
+      composeOutputNodeId = `input_compose_average_${safeInputId}`;
+      nodes.push({
+        id: composeOutputNodeId,
+        type: "divide",
+        inputDefaults: { rhs: 2 }
+      });
+      edges.push({
+        from: { nodeId: composeAddNodeId },
+        to: { nodeId: composeOutputNodeId, portId: "lhs" }
+      });
+    } else {
+      composeOutputNodeId = `input_compose_normalized_add_${safeInputId}`;
+      nodes.push({
+        id: composeOutputNodeId,
+        type: "subtract",
+        inputDefaults: { rhs: composeBaseline }
+      });
+      edges.push({
+        from: { nodeId: composeAddNodeId },
+        to: { nodeId: composeOutputNodeId, portId: "lhs" }
+      });
+    }
+    const minValue = Number.isFinite(input.range.min) ? input.range.min : -1;
+    const maxValue = Number.isFinite(input.range.max) ? input.range.max : 1;
+    const clampNodeId = `input_effective_${safeInputId}`;
+    nodes.push({
+      id: clampNodeId,
+      type: "clamp",
+      inputDefaults: { min: minValue, max: maxValue }
+    });
+    edges.push({
+      from: { nodeId: composeOutputNodeId },
+      to: { nodeId: clampNodeId, portId: "in" }
+    });
+    return clampNodeId;
+  };
+  const buildStagedEffectiveInputNodeId = (input, stagedConfig) => {
+    const safeInputId = sanitizeNodeId(input.id);
+    const composeBaseline = Number.isFinite(input.defaultValue) ? input.defaultValue : 0;
+    const parentContributionNodes = [];
+    const parentNodeIdByAlias = /* @__PURE__ */ new Map();
+    stagedConfig.parents.forEach((parent, index) => {
+      if (!parent.enabled) {
+        return;
+      }
+      const resolvedParentInputId = resolveStandardRigInputId(
+        parent.inputId,
+        inputsById
+      );
+      const parentInput = ensureInputNode(resolvedParentInputId);
+      if (!parentInput) {
+        const issueSet = bindingIssues.get(input.id) ?? /* @__PURE__ */ new Set();
+        issueSet.add(
+          `Staged parent "${resolvedParentInputId}" missing for "${input.id}".`
+        );
+        bindingIssues.set(input.id, issueSet);
+        return;
+      }
+      const nodeSuffix = `${safeInputId}_${index + 1}`;
+      const fallbackParentNodeId = buildDefaultParentTransformNodeId({
+        sourceNodeId: parentInput.nodeId,
+        nodeSuffix,
+        scale: parent.scale,
+        offset: parent.offset
+      });
+      const defaultParentFormulaExpression = `${parent.alias} = parent * scale + offset`;
+      const parentFormulaNodeId = normalizeFormulaSignature(parent.expression) === normalizeFormulaSignature(defaultParentFormulaExpression) ? fallbackParentNodeId : buildStagedFormulaNodeId({
+        expression: parent.expression,
+        fallbackNodeId: fallbackParentNodeId,
+        componentSafeId: `staged_parent_${nodeSuffix}`,
+        inputId: input.id,
+        issuePrefix: `Parent formula "${parent.alias}"`,
+        variables: {
+          parent: { nodeId: parentInput.nodeId },
+          scale: { value: parent.scale },
+          offset: { value: parent.offset },
+          default: { value: composeBaseline },
+          baseline: { value: composeBaseline }
+        }
+      });
+      parentContributionNodes.push(parentFormulaNodeId);
+      parentNodeIdByAlias.set(parent.alias, parentFormulaNodeId);
+      const normalizedAlias = parent.alias.toLowerCase();
+      if (normalizedAlias !== parent.alias) {
+        parentNodeIdByAlias.set(normalizedAlias, parentFormulaNodeId);
+      }
+    });
+    const parentContributionNodeId = parentContributionNodes.length > 0 ? (() => {
+      const defaultParentContributionNodeId = buildNormalizedAdditiveBlendNodeId({
+        nodeIdPrefix: `input_parent_blend_${safeInputId}`,
+        sourceNodeIds: parentContributionNodes,
+        baseline: composeBaseline
+      });
+      const defaultParentContributionExpression = `parentContribution = normalizedAdditive([${stagedConfig.parents.filter((entry) => entry.enabled).map((entry) => entry.alias).join(", ")}], baseline=default)`;
+      if (normalizeFormulaSignature(stagedConfig.parentBlend.expression) === normalizeFormulaSignature(defaultParentContributionExpression)) {
+        return defaultParentContributionNodeId;
+      }
+      return buildStagedFormulaNodeId({
+        expression: stagedConfig.parentBlend.expression,
+        fallbackNodeId: defaultParentContributionNodeId,
+        componentSafeId: `staged_parent_contribution_${safeInputId}`,
+        inputId: input.id,
+        issuePrefix: "Parent contribution formula",
+        variables: {
+          ...Object.fromEntries(
+            Array.from(parentNodeIdByAlias.entries()).map(
+              ([alias, nodeId]) => [alias, { nodeId }]
+            )
+          ),
+          default: { value: composeBaseline },
+          baseline: { value: composeBaseline }
+        }
+      });
+    })() : null;
+    let poseContributionNodeId = null;
+    const hasPoseContribution = stagedConfig.poseSource.targetIds.length > 0 || shouldComposeInputWithPoseControl(input);
+    if (hasPoseContribution) {
+      poseContributionNodeId = `input_pose_control_${safeInputId}`;
+      nodes.push({
+        id: poseContributionNodeId,
+        type: "input",
+        params: {
+          path: buildPoseControlInputPath(faceId, input.id),
+          value: { float: composeBaseline }
+        }
+      });
+    }
+    const sourceBranchNodeIds = [];
+    if (parentContributionNodeId) {
+      sourceBranchNodeIds.push(parentContributionNodeId);
+    }
+    if (poseContributionNodeId) {
+      sourceBranchNodeIds.push(poseContributionNodeId);
+    }
+    if (stagedConfig.directInput.enabled) {
+      const directNodeId = `input_direct_${safeInputId}`;
+      nodes.push({
+        id: directNodeId,
+        type: "input",
+        params: {
+          path: stagedConfig.directInput.valuePath,
+          value: { float: composeBaseline }
+        }
+      });
+      sourceBranchNodeIds.push(directNodeId);
+    }
+    const sourceBlendNodeId = buildNormalizedAdditiveBlendNodeId({
+      nodeIdPrefix: `input_source_blend_${safeInputId}`,
+      sourceNodeIds: sourceBranchNodeIds,
+      baseline: composeBaseline
+    });
+    const overrideEnabledNodeId = `input_override_enabled_${safeInputId}`;
+    nodes.push({
+      id: overrideEnabledNodeId,
+      type: "input",
+      params: {
+        path: stagedConfig.override.enabledPath,
+        value: { float: stagedConfig.override.enabledDefault ? 1 : 0 }
+      }
+    });
+    const overrideValueNodeId = `input_override_value_${safeInputId}`;
+    nodes.push({
+      id: overrideValueNodeId,
+      type: "input",
+      params: {
+        path: stagedConfig.override.valuePath,
+        value: { float: stagedConfig.override.valueDefault }
+      }
+    });
+    const overrideDeltaNodeId = `input_override_delta_${safeInputId}`;
+    nodes.push({
+      id: overrideDeltaNodeId,
+      type: "subtract"
+    });
+    edges.push(
+      {
+        from: { nodeId: overrideValueNodeId },
+        to: { nodeId: overrideDeltaNodeId, portId: "lhs" }
+      },
+      {
+        from: { nodeId: sourceBlendNodeId },
+        to: { nodeId: overrideDeltaNodeId, portId: "rhs" }
+      }
+    );
+    const overrideScaleNodeId = `input_override_scale_${safeInputId}`;
+    nodes.push({
+      id: overrideScaleNodeId,
+      type: "multiply"
+    });
+    edges.push(
+      {
+        from: { nodeId: overrideEnabledNodeId },
+        to: { nodeId: overrideScaleNodeId, portId: "operand_1" }
+      },
+      {
+        from: { nodeId: overrideDeltaNodeId },
+        to: { nodeId: overrideScaleNodeId, portId: "operand_2" }
+      }
+    );
+    const overrideSelectedNodeId = `input_override_selected_${safeInputId}`;
+    nodes.push({
+      id: overrideSelectedNodeId,
+      type: "add"
+    });
+    edges.push(
+      {
+        from: { nodeId: sourceBlendNodeId },
+        to: { nodeId: overrideSelectedNodeId, portId: "operand_1" }
+      },
+      {
+        from: { nodeId: overrideScaleNodeId },
+        to: { nodeId: overrideSelectedNodeId, portId: "operand_2" }
+      }
+    );
+    if (!stagedConfig.clamp.enabled) {
+      return overrideSelectedNodeId;
+    }
+    const minValue = Number.isFinite(input.range.min) ? input.range.min : -1;
+    const maxValue = Number.isFinite(input.range.max) ? input.range.max : 1;
+    const clampNodeId = `input_effective_${safeInputId}`;
+    nodes.push({
+      id: clampNodeId,
+      type: "clamp",
+      inputDefaults: { min: minValue, max: maxValue }
+    });
+    edges.push({
+      from: { nodeId: overrideSelectedNodeId },
+      to: { nodeId: clampNodeId, portId: "in" }
+    });
+    return clampNodeId;
+  };
   const ensureInputNode = (inputId) => {
     const existing = inputNodes.get(inputId);
     if (existing) {
@@ -3417,7 +3791,8 @@ function buildRigGraphSpec({
     }
     const defaultValue = Number.isFinite(input.defaultValue) ? input.defaultValue : 0;
     const inputBindingRaw = inputBindings[inputId];
-    if (inputBindingRaw) {
+    const isStagedInput = hasRigPipelineV1InputConfig(pipelineV1, inputId);
+    if (isStagedInput || inputBindingRaw) {
       if (buildingDerived.has(inputId)) {
         const issueSet = bindingIssues.get(inputId) ?? /* @__PURE__ */ new Set();
         issueSet.add("Derived input cycle detected.");
@@ -3426,6 +3801,21 @@ function buildRigGraphSpec({
       }
       buildingDerived.add(inputId);
       try {
+        if (isStagedInput) {
+          const stagedConfig = resolveRigPipelineV1InputConfig({
+            faceId,
+            input,
+            pipelineV1
+          });
+          stagedPipelineByInputId.set(input.id, stagedConfig);
+          computedInputs.add(inputId);
+          const record3 = {
+            nodeId: buildStagedEffectiveInputNodeId(input, stagedConfig),
+            input
+          };
+          inputNodes.set(inputId, record3);
+          return record3;
+        }
         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);
@@ -3449,7 +3839,10 @@ function buildRigGraphSpec({
           animatableId: inputId,
           component: void 0,
           safeId: sanitizeNodeId(inputId),
+          enforceRigBoundaryRules: false,
           context: {
+            inputsById,
+            inputBindings,
             nodes,
             edges,
             ensureInputNode,
@@ -3469,12 +3862,18 @@ function buildRigGraphSpec({
               value: input.defaultValue
             }
           });
-          const record3 = { nodeId: constNodeId, input };
+          const record3 = {
+            nodeId: buildLegacyEffectiveInputNodeId(input, constNodeId),
+            input
+          };
           inputNodes.set(inputId, record3);
           return record3;
         }
         computedInputs.add(inputId);
-        const record2 = { nodeId: valueNodeId, input };
+        const record2 = {
+          nodeId: buildLegacyEffectiveInputNodeId(input, valueNodeId),
+          input
+        };
         inputNodes.set(inputId, record2);
         return record2;
       } finally {
@@ -3490,7 +3889,10 @@ function buildRigGraphSpec({
         value: { float: defaultValue }
       }
     });
-    const record = { nodeId, input };
+    const record = {
+      nodeId: buildLegacyEffectiveInputNodeId(input, nodeId),
+      input
+    };
     inputNodes.set(inputId, record);
     return record;
   };
@@ -3531,7 +3933,10 @@ function buildRigGraphSpec({
         animatableId: component.animatableId,
         component: component.component,
         safeId: component.safeId,
+        enforceRigBoundaryRules: true,
         context: {
+          inputsById,
+          inputBindings,
           nodes,
           edges,
           ensureInputNode,
@@ -3554,7 +3959,6 @@ function buildRigGraphSpec({
         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."],
@@ -3680,6 +4084,61 @@ function buildRigGraphSpec({
   const filteredSummaryBindings = summaryBindings.filter(
     (binding) => outputs.has(binding.animatableId) || computedInputs.has(binding.animatableId)
   );
+  const pipelineV1ByInputId = stagedPipelineByInputId.size > 0 ? Object.fromEntries(
+    Array.from(stagedPipelineByInputId.entries()).map(
+      ([inputId, stagedConfig]) => [
+        inputId,
+        {
+          inputId: stagedConfig.inputId,
+          parents: stagedConfig.parents.map((parent) => ({
+            linkId: parent.linkId,
+            inputId: parent.inputId,
+            alias: parent.alias,
+            scale: parent.scale,
+            offset: parent.offset,
+            enabled: parent.enabled,
+            expression: parent.expression
+          })),
+          children: stagedConfig.children.map((child) => ({
+            linkId: child.linkId,
+            childInputId: child.childInputId
+          })),
+          parentBlend: {
+            mode: stagedConfig.parentBlend.mode,
+            expression: stagedConfig.parentBlend.expression
+          },
+          poseSource: {
+            targetIds: [...stagedConfig.poseSource.targetIds]
+          },
+          directInput: {
+            enabled: stagedConfig.directInput.enabled,
+            valuePath: stagedConfig.directInput.valuePath
+          },
+          sourceBlend: {
+            mode: stagedConfig.sourceBlend.mode
+          },
+          sourceFallback: {
+            whenNoSources: stagedConfig.sourceFallback.whenNoSources
+          },
+          clamp: {
+            enabled: stagedConfig.clamp.enabled
+          },
+          override: {
+            enabledDefault: stagedConfig.override.enabledDefault,
+            valueDefault: stagedConfig.override.valueDefault,
+            enabledPath: stagedConfig.override.enabledPath,
+            valuePath: stagedConfig.override.valuePath
+          }
+        }
+      ]
+    )
+  ) : void 0;
+  const hasPipelineLinks = pipelineV1?.links && typeof pipelineV1.links === "object" && Object.keys(pipelineV1.links).length > 0;
+  const pipelineV1Metadata = pipelineV1ByInputId || hasPipelineLinks ? {
+    version: RIG_PIPELINE_V1_VERSION,
+    ...pipelineV1ByInputId ? { byInputId: pipelineV1ByInputId } : {},
+    ...hasPipelineLinks ? { links: cloneJsonLike2(pipelineV1?.links) } : {}
+  } : void 0;
   const vizijMetadata = {
     vizij: {
       faceId,
@@ -3712,12 +4171,12 @@ function buildRigGraphSpec({
       }),
       bindings: filteredSummaryBindings.map((binding) => ({
         ...binding,
-        remap: { ...binding.remap },
         expression: binding.expression,
         valueType: binding.valueType,
         issues: binding.issues ? [...binding.issues] : void 0,
         metadata: binding.metadata ? cloneJsonLike2(binding.metadata) : void 0
-      }))
+      })),
+      ...pipelineV1Metadata ? { pipelineV1: pipelineV1Metadata } : {}
     }
   };
   const issuesByTarget = {};
@@ -3747,7 +4206,6 @@ function buildRigGraphSpec({
     bindings: toIrBindingSummary(
       filteredSummaryBindings.map((binding) => ({
         ...binding,
-        remap: { ...binding.remap },
         issues: binding.issues ? [...binding.issues] : void 0
       }))
     )
@@ -3866,7 +4324,7 @@ function cloneJsonLike2(value) {
   if (value === void 0 || value === null) {
     return value;
   }
-  return JSON.parse(JSON.stringify(value));
+  return cloneDeepSafe4(value);
 }
 function validateRemapDefaults(nodes) {
   const issues = [];
@@ -3894,15 +4352,8 @@ function validateRemapDefaults(nodes) {
 
 // src/ir/inspection.ts
 import { findNodeSignature } from "@vizij/node-graph-wasm/metadata";
+import { cloneDeepSafe as cloneDeepSafe5 } from "@vizij/utils";
 var MACHINE_REPORT_VERSION = 1;
-var REMAP_KEYS = [
-  "inLow",
-  "inAnchor",
-  "inHigh",
-  "outLow",
-  "outAnchor",
-  "outHigh"
-];
 var DEFAULT_DIFF_LIMIT = 50;
 function buildMachineReport(result) {
   return {
@@ -3943,7 +4394,6 @@ function normalizeGraphBindingSummaries(bindings) {
     slotId: binding.slotId,
     slotAlias: binding.slotAlias,
     inputId: binding.inputId ?? null,
-    remap: normalizeRemap2(binding.remap),
     expression: binding.expression,
     valueType: binding.valueType,
     nodeId: binding.nodeId,
@@ -3958,7 +4408,7 @@ function cloneBindingMetadata2(metadata) {
   if (!metadata) {
     return void 0;
   }
-  return JSON.parse(JSON.stringify(metadata));
+  return cloneDeepSafe5(metadata);
 }
 function normalizeIssues(issues) {
   const byTargetEntries = Object.entries(issues.byTarget ?? {}).map(
@@ -4042,7 +4492,6 @@ function normalizeIrGraphSummary(summary) {
 function normalizeIrBindingSummaries(bindings) {
   const normalized = bindings.map((binding) => ({
     ...binding,
-    remap: sortPlainObject(binding.remap),
     issues: normalizeStringArray(binding.issues)
   }));
   normalized.sort((a, b) => bindingSortKey(a).localeCompare(bindingSortKey(b)));
@@ -4123,6 +4572,9 @@ function normalizeRegistryVariadicSpec(spec) {
   if (typeof spec.max === "number") {
     normalized.max = spec.max;
   }
+  if (spec.keyed) {
+    normalized.keyed = true;
+  }
   return normalized;
 }
 function normalizeRegistryParamSpec(param) {
@@ -4145,13 +4597,6 @@ function normalizeRegistryParamSpec(param) {
   }
   return normalized;
 }
-function normalizeRemap2(remap) {
-  const normalized = {};
-  REMAP_KEYS.forEach((key) => {
-    normalized[key] = remap[key];
-  });
-  return normalized;
-}
 function normalizeStringArray(values) {
   if (!values || values.length === 0) {
     return void 0;
@@ -4294,7 +4739,6 @@ export {
   bindingTargetFromInput,
   PRIMARY_SLOT_ID,
   PRIMARY_SLOT_ALIAS,
-  createDefaultRemap,
   createDefaultBindings,
   createDefaultBinding,
   createDefaultParentBinding,
@@ -4306,14 +4750,10 @@ export {
   updateBindingSlotAlias,
   updateBindingSlotValueType,
   updateBindingExpression,
-  updateBindingSlotRemap,
   updateBindingWithInput,
-  remapValue,
   reconcileBindings,
   bindingToDefinition,
   bindingFromDefinition,
-  buildPiecewiseRemapExpression,
-  buildDefaultSlotExpression,
   buildCanonicalBindingExpression,
   parseControlExpression,
   collectExpressionReferences,