@vizij/node-graph-authoring 0.0.5 → 0.1.0

package/dist/index.cjs

@@ -33,9 +33,7 @@ __export(index_exports, {
   bindingTargetFromInput: () => bindingTargetFromInput,
   bindingToDefinition: () => bindingToDefinition,
   buildCanonicalBindingExpression: () => buildCanonicalBindingExpression,
-  buildDefaultSlotExpression: () => buildDefaultSlotExpression,
   buildMachineReport: () => buildMachineReport,
-  buildPiecewiseRemapExpression: () => buildPiecewiseRemapExpression,
   buildRigGraphSpec: () => buildRigGraphSpec,
   collectExpressionReferences: () => collectExpressionReferences,
   compileIrGraph: () => compileIrGraph,
@@ -43,7 +41,6 @@ __export(index_exports, {
   createDefaultBindings: () => createDefaultBindings,
   createDefaultInputValues: () => createDefaultInputValues,
   createDefaultParentBinding: () => createDefaultParentBinding,
-  createDefaultRemap: () => createDefaultRemap,
   createExpressionVariableTable: () => createExpressionVariableTable,
   createIrGraphBuilder: () => createIrGraphBuilder,
   createLegacyIrGraph: () => createLegacyIrGraph,
@@ -53,20 +50,19 @@ __export(index_exports, {
   mapExpression: () => mapExpression,
   parseControlExpression: () => parseControlExpression,
   reconcileBindings: () => reconcileBindings,
-  remapValue: () => remapValue,
   removeBindingSlot: () => removeBindingSlot,
   toIrBindingSummary: () => toIrBindingSummary,
   updateBindingExpression: () => updateBindingExpression,
   updateBindingSlotAlias: () => updateBindingSlotAlias,
-  updateBindingSlotRemap: () => updateBindingSlotRemap,
   updateBindingSlotValueType: () => updateBindingSlotValueType,
   updateBindingWithInput: () => updateBindingWithInput
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/graphBuilder.ts
-var import_utils2 = require("@vizij/utils");
-var import_utils3 = require("@vizij/utils");
+var import_utils4 = require("@vizij/utils");
+var import_utils5 = require("@vizij/utils");
+var import_metadata2 = require("@vizij/node-graph-wasm/metadata");
 
 // src/state.ts
 var import_utils = require("@vizij/utils");
@@ -108,9 +104,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";
@@ -186,131 +179,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 (0, import_utils.cloneRemapSettings)(remap);
-}
 function cloneBindingMetadata(metadata) {
   if (!metadata) {
     return void 0;
   }
-  return JSON.parse(JSON.stringify(metadata));
-}
-function sanitizeRemap(remap, target) {
-  const normalized = normalizeRemap(remap, target);
-  const outputDefaults = deriveOutputDefaults(target);
-  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 (0, import_utils.cloneDeepSafe)(metadata);
 }
 function createDefaultBindings(components) {
   const bindings = {};
@@ -320,21 +193,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)
   };
@@ -360,7 +230,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 : [
@@ -368,7 +237,6 @@ function ensurePrimarySlot(binding, target) {
       id: PRIMARY_SLOT_ID,
       alias: PRIMARY_SLOT_ALIAS,
       inputId: binding.inputId ?? null,
-      remap: cloneRemap(normalizedBindingRemap),
       valueType: targetValueType
     }
   ];
@@ -383,8 +251,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,
@@ -394,13 +260,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 === 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] = {
@@ -408,16 +272,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)
     };
   });
@@ -432,7 +293,6 @@ function ensurePrimarySlot(binding, target) {
   const normalizedBinding = {
     ...binding,
     inputId: normalizedSlots[0].inputId ?? null,
-    remap: cloneRemap(primaryRemap),
     slots: normalizedSlots,
     expression
   };
@@ -459,14 +319,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(
@@ -580,50 +439,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() : "";
@@ -631,39 +446,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 {
@@ -673,24 +476,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 {
@@ -712,26 +505,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) => {
@@ -749,12 +522,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];
@@ -764,7 +535,6 @@ function reconcileBindings(previous, components) {
         ...ensured,
         targetId: component.id,
         inputId: primary.inputId ?? null,
-        remap: cloneRemap(primary.remap),
         slots,
         expression
       };
@@ -777,11 +547,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)
   };
@@ -794,46 +560,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 === import_utils.SELF_BINDING_ID || isSelfAlias(sanitizedAlias)) {
-    return sanitizedAlias;
-  }
-  return buildPiecewiseRemapExpression(sanitizedAlias, remap);
-}
 function normalizeSlotAliasForExpression(slot, index) {
   if (slot.alias && slot.alias.trim().length > 0) {
     return slot.alias.trim();
@@ -850,16 +582,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();
@@ -1970,9 +1693,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
       }
     });
   }
@@ -2069,9 +1790,6 @@ var RESERVED_EXPRESSION_VARIABLES = [
 ];
 var EXPRESSION_FUNCTION_VOCABULARY = SCALAR_FUNCTION_VOCABULARY;
 
-// src/graphBuilder.ts
-var import_metadata2 = require("@vizij/node-graph-wasm/metadata");
-
 // src/ir/builder.ts
 var graphSequence = 0;
 function generateGraphId(faceId) {
@@ -2158,12 +1876,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
+var import_utils2 = require("@vizij/utils");
 function compileIrGraph(graph, options = {}) {
   const preferLegacy = options.preferLegacySpec === true;
   const legacySpec = graph.legacy?.spec;
@@ -2248,7 +1966,7 @@ function cloneJsonLike(value) {
   if (value === void 0 || value === null) {
     return value;
   }
-  return JSON.parse(JSON.stringify(value));
+  return (0, import_utils2.cloneDeepSafe)(value);
 }
 function inlineSingleUseConstants(spec) {
   const nodes = spec.nodes ?? [];
@@ -2287,8 +2005,9 @@ function inlineSingleUseConstants(spec) {
 }
 
 // src/bindingMetadata.ts
+var import_utils3 = require("@vizij/utils");
 function cloneOperand(entry) {
-  return JSON.parse(JSON.stringify(entry));
+  return (0, import_utils3.cloneDeepSafe)(entry);
 }
 function describeSlot(entry) {
   const metadata = entry.metadata;
@@ -2330,17 +2049,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 "";
   }
@@ -2424,7 +2143,6 @@ function evaluateBinding({
     counter: 0,
     reservedNodes: /* @__PURE__ */ new Map(),
     nodeValueTypes: /* @__PURE__ */ new Map(),
-    slotRemapNodes: /* @__PURE__ */ new Map(),
     graphReservedNodes: context.graphReservedNodes,
     generateReservedNodeId: context.generateReservedNodeId
   };
@@ -2442,7 +2160,7 @@ function evaluateBinding({
     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 (slot.inputId === import_utils5.SELF_BINDING_ID) {
       if (selfNodeId) {
         slotOutputId = selfNodeId;
         hasActiveSlot = true;
@@ -2481,9 +2199,7 @@ function evaluateBinding({
       targetId,
       animatableId,
       component,
-      valueType: slotValueType,
-      remap: { ...slot.remap },
-      autoRemap: slot.inputId !== import_utils3.SELF_BINDING_ID && slotValueType === "scalar"
+      valueType: slotValueType
     });
     setNodeValueType(
       exprContext,
@@ -2497,7 +2213,6 @@ function evaluateBinding({
       slotId,
       slotAlias: alias,
       inputId: slot.inputId ?? null,
-      remap: { ...slot.remap },
       expression: trimmedExpression,
       valueType: slotValueType,
       nodeId: slotOutputId,
@@ -2516,9 +2231,7 @@ function evaluateBinding({
       targetId,
       animatableId,
       component,
-      valueType: targetValueType,
-      remap: createDefaultRemap(target),
-      autoRemap: false
+      valueType: targetValueType
     });
     setNodeValueType(
       exprContext,
@@ -2532,7 +2245,6 @@ function evaluateBinding({
       slotId: PRIMARY_SLOT_ID,
       slotAlias: alias,
       inputId: null,
-      remap: createDefaultRemap(target),
       expression: trimmedExpression,
       valueType: targetValueType,
       nodeId: constantId,
@@ -2729,73 +2441,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);
@@ -3254,8 +2899,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);
@@ -3270,10 +2914,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(
@@ -3411,13 +3052,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) : [];
@@ -3493,7 +3128,7 @@ function buildRigGraphSpec({
       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);
+        const requiresSelf = binding.inputId === import_utils5.SELF_BINDING_ID || binding.slots.some((slot) => slot.inputId === import_utils5.SELF_BINDING_ID);
         let selfNodeId;
         if (requiresSelf) {
           const sliderNodeId = `input_raw_${sanitizeNodeId(inputId)}`;
@@ -3619,7 +3254,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."],
@@ -3674,7 +3308,7 @@ function buildRigGraphSpec({
       let sourceId = entry.values.get(componentKey);
       if (!sourceId) {
         const componentDefault = entry.defaults.get(componentKey) ?? extractComponentDefault(
-          (0, import_utils2.buildAnimatableValue)(entry.animatable, void 0),
+          (0, import_utils4.buildAnimatableValue)(entry.animatable, void 0),
           componentKey
         );
         const constNodeId = `const_${safeId}_${componentKey}`;
@@ -3777,7 +3411,6 @@ function buildRigGraphSpec({
       }),
       bindings: filteredSummaryBindings.map((binding) => ({
         ...binding,
-        remap: { ...binding.remap },
         expression: binding.expression,
         valueType: binding.valueType,
         issues: binding.issues ? [...binding.issues] : void 0,
@@ -3812,7 +3445,6 @@ function buildRigGraphSpec({
     bindings: toIrBindingSummary(
       filteredSummaryBindings.map((binding) => ({
         ...binding,
-        remap: { ...binding.remap },
         issues: binding.issues ? [...binding.issues] : void 0
       }))
     )
@@ -3931,7 +3563,7 @@ function cloneJsonLike2(value) {
   if (value === void 0 || value === null) {
     return value;
   }
-  return JSON.parse(JSON.stringify(value));
+  return (0, import_utils4.cloneDeepSafe)(value);
 }
 function validateRemapDefaults(nodes) {
   const issues = [];
@@ -3959,15 +3591,8 @@ function validateRemapDefaults(nodes) {
 
 // src/ir/inspection.ts
 var import_metadata3 = require("@vizij/node-graph-wasm/metadata");
+var import_utils6 = require("@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 {
@@ -4008,7 +3633,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,
@@ -4023,7 +3647,7 @@ function cloneBindingMetadata2(metadata) {
   if (!metadata) {
     return void 0;
   }
-  return JSON.parse(JSON.stringify(metadata));
+  return (0, import_utils6.cloneDeepSafe)(metadata);
 }
 function normalizeIssues(issues) {
   const byTargetEntries = Object.entries(issues.byTarget ?? {}).map(
@@ -4107,7 +3731,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)));
@@ -4210,13 +3833,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;
@@ -4368,9 +3984,7 @@ function normalizeDiffLimit(limit) {
   bindingTargetFromInput,
   bindingToDefinition,
   buildCanonicalBindingExpression,
-  buildDefaultSlotExpression,
   buildMachineReport,
-  buildPiecewiseRemapExpression,
   buildRigGraphSpec,
   collectExpressionReferences,
   compileIrGraph,
@@ -4378,7 +3992,6 @@ function normalizeDiffLimit(limit) {
   createDefaultBindings,
   createDefaultInputValues,
   createDefaultParentBinding,
-  createDefaultRemap,
   createExpressionVariableTable,
   createIrGraphBuilder,
   createLegacyIrGraph,
@@ -4388,12 +4001,10 @@ function normalizeDiffLimit(limit) {
   mapExpression,
   parseControlExpression,
   reconcileBindings,
-  remapValue,
   removeBindingSlot,
   toIrBindingSummary,
   updateBindingExpression,
   updateBindingSlotAlias,
-  updateBindingSlotRemap,
   updateBindingSlotValueType,
   updateBindingWithInput
 });