@lovelace_lol/loom3 1.0.42 → 1.0.44

package/dist/index.cjs

@@ -74,6 +74,9 @@ function bindingTargets(binding) {
   if (targets && targets.length > 0) return targets;
   return binding.morph !== void 0 && binding.morph !== "" ? [binding.morph] : [];
 }
+function normalizeBindingWeight(weight) {
+  return Number.isFinite(weight) ? Math.max(0, weight ?? 1) : 1;
+}
 function getProfileVisemeSlots(profile) {
   if (profile.visemeSlots && profile.visemeSlots.length > 0) {
     return [...profile.visemeSlots].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
@@ -99,6 +102,23 @@ function compileVisemeKeys(profile) {
     return target ?? profile.visemeKeys?.[index] ?? "";
   });
 }
+function getVisemeBindingTargets(profile, visemeIndex) {
+  const slots = getProfileVisemeSlots(profile);
+  const slot = slots[visemeIndex];
+  const binding = slot ? profile.visemeBindings?.[slot.id] : void 0;
+  const boundTargets = binding?.targets?.filter((target) => target.morph !== void 0 && target.morph !== "").map((target) => ({
+    morph: target.morph,
+    weight: normalizeBindingWeight(target.weight)
+  }));
+  if (boundTargets && boundTargets.length > 0) {
+    return boundTargets;
+  }
+  if (binding?.morph !== void 0 && binding.morph !== "") {
+    return [{ morph: binding.morph, weight: 1 }];
+  }
+  const legacyTarget = profile.visemeKeys?.[visemeIndex];
+  return legacyTarget !== void 0 && legacyTarget !== "" ? [{ morph: legacyTarget, weight: 1 }] : [];
+}
 function getVisemeJawAmounts(profile) {
   const slots = getProfileVisemeSlots(profile);
   if (slots.length === 0) return profile.visemeJawAmounts ? [...profile.visemeJawAmounts] : void 0;
@@ -510,14 +530,19 @@ var Y_AXIS = new THREE2.Vector3(0, 1, 0);
 var Z_AXIS = new THREE2.Vector3(0, 0, 1);
 var CLIP_EVENT_METADATA_KEY = "__loom3ClipEvents";
 var CLIP_EVENT_EPSILON = 1e-4;
+var ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX = "__loom3_additive_delta";
 var BakedAnimationController = class {
   constructor(host) {
     __publicField(this, "host");
+    // Clip-backed snippets need a later mixer pass so they can override baked additive tracks.
     __publicField(this, "animationMixer", null);
+    __publicField(this, "clipAnimationMixer", null);
     __publicField(this, "mixerFinishedListenerAttached", false);
+    __publicField(this, "clipMixerFinishedListenerAttached", false);
     __publicField(this, "animationClips", []);
     __publicField(this, "bakedSourceClips", /* @__PURE__ */ new Map());
     __publicField(this, "bakedRuntimeActions", /* @__PURE__ */ new Map());
+    __publicField(this, "bakedAdditiveRuntimeClips", /* @__PURE__ */ new Map());
     __publicField(this, "bakedActionGroups", /* @__PURE__ */ new Map());
     __publicField(this, "bakedRuntimeClipToSource", /* @__PURE__ */ new Map());
     __publicField(this, "animationActions", /* @__PURE__ */ new Map());
@@ -542,6 +567,173 @@ var BakedAnimationController = class {
     action.__actionId = actionId;
     return actionId;
   }
+  clearActionId(action) {
+    if (!action) return;
+    const actionId = this.getActionId(action);
+    if (actionId) {
+      this.actionIdToClip.delete(actionId);
+    }
+    this.actionIds.delete(action);
+    delete action.__actionId;
+  }
+  uncacheClip(clip, mixer = this.animationMixer) {
+    if (!clip || !mixer) return;
+    try {
+      mixer.uncacheClip(clip);
+    } catch {
+    }
+  }
+  uncacheAction(action, mixer = this.animationMixer) {
+    if (!action || !mixer) return;
+    try {
+      const clip = action.getClip();
+      if (clip) {
+        mixer.uncacheAction(clip);
+        mixer.uncacheClip(clip);
+      }
+    } catch {
+    }
+  }
+  releaseBakedRuntimeAction(runtimeClipName) {
+    const action = this.bakedRuntimeActions.get(runtimeClipName);
+    if (!action) return;
+    try {
+      action.stop();
+    } catch {
+    }
+    this.uncacheAction(action);
+    this.clearActionId(action);
+    this.bakedRuntimeActions.delete(runtimeClipName);
+  }
+  clearBakedAdditiveRuntimeClip(runtimeClipName) {
+    const clip = this.bakedAdditiveRuntimeClips.get(runtimeClipName);
+    if (!clip) return;
+    this.uncacheClip(clip);
+    this.bakedAdditiveRuntimeClips.delete(runtimeClipName);
+  }
+  clearAllBakedAdditiveRuntimeClips() {
+    for (const runtimeClipName of Array.from(this.bakedAdditiveRuntimeClips.keys())) {
+      this.clearBakedAdditiveRuntimeClip(runtimeClipName);
+    }
+  }
+  resolveTrackTarget(model, parsed) {
+    const targetKey = parsed.objectName === "bones" && parsed.objectIndex ? parsed.objectIndex : parsed.nodeName;
+    if (!targetKey) {
+      return null;
+    }
+    return model.getObjectByProperty("uuid", targetKey) ?? THREE2.PropertyBinding.findNode(model, targetKey) ?? null;
+  }
+  getMorphTrackBaseValue(target, propertyIndex) {
+    if (!target) {
+      return 0;
+    }
+    const meshTarget = target;
+    const influences = meshTarget.morphTargetInfluences;
+    if (!influences) {
+      return 0;
+    }
+    let morphIndex;
+    if (typeof propertyIndex === "number" && Number.isInteger(propertyIndex)) {
+      morphIndex = propertyIndex;
+    } else if (typeof propertyIndex === "string") {
+      if (/^\d+$/.test(propertyIndex)) {
+        morphIndex = Number(propertyIndex);
+      } else {
+        morphIndex = meshTarget.morphTargetDictionary?.[propertyIndex];
+      }
+    }
+    if (morphIndex === void 0) {
+      return 0;
+    }
+    return influences[morphIndex] ?? 0;
+  }
+  canCreateFirstFrameReferenceTrack(track) {
+    const valueSize = track.getValueSize();
+    if (!Number.isFinite(valueSize) || valueSize <= 0 || track.values.length < valueSize) {
+      return false;
+    }
+    return track.ValueTypeName === "number" || track.ValueTypeName === "quaternion" || track.ValueTypeName === "vector";
+  }
+  createFirstFrameReferenceTrack(track) {
+    const valueSize = track.getValueSize();
+    if (!this.canCreateFirstFrameReferenceTrack(track)) {
+      return null;
+    }
+    const values = Array.from(track.values.slice(0, valueSize));
+    if (track.ValueTypeName === "number") {
+      return new THREE2.NumberKeyframeTrack(track.name, [0], values);
+    }
+    if (track.ValueTypeName === "quaternion") {
+      return new THREE2.QuaternionKeyframeTrack(track.name, [0], values);
+    }
+    if (track.ValueTypeName === "vector") {
+      return new THREE2.VectorKeyframeTrack(track.name, [0], values);
+    }
+    return null;
+  }
+  createAdditiveReferenceTrack(track, model) {
+    const trackName = typeof track?.name === "string" ? track.name : "";
+    if (!trackName) {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = THREE2.PropertyBinding.parseTrackName(trackName);
+    } catch {
+      return null;
+    }
+    const target = this.resolveTrackTarget(model, parsed);
+    if (parsed.propertyName === "morphTargetInfluences") {
+      return new THREE2.NumberKeyframeTrack(
+        track.name,
+        [0],
+        [this.getMorphTrackBaseValue(target, parsed.propertyIndex)]
+      );
+    }
+    return this.createFirstFrameReferenceTrack(track);
+  }
+  createAdditiveRuntimeClip(runtimeClip) {
+    const model = this.host.getModel();
+    if (!model) {
+      return null;
+    }
+    const additiveTracks = [];
+    const referenceTracks = [];
+    for (const track of runtimeClip.tracks) {
+      const referenceTrack = this.createAdditiveReferenceTrack(track, model);
+      if (!referenceTrack) {
+        continue;
+      }
+      additiveTracks.push(track.clone());
+      referenceTracks.push(referenceTrack);
+    }
+    const additiveClip = new THREE2.AnimationClip(
+      `${runtimeClip.name}${ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX}`,
+      runtimeClip.duration,
+      additiveTracks
+    );
+    if (additiveTracks.length > 0) {
+      const referenceClip = new THREE2.AnimationClip(
+        `${runtimeClip.name}${ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX}_reference`,
+        0,
+        referenceTracks
+      );
+      THREE2.AnimationUtils.makeClipAdditive(additiveClip, 0, referenceClip);
+    }
+    return additiveClip;
+  }
+  getOrCreateBakedAdditiveRuntimeClip(runtimeClip) {
+    const cached = this.bakedAdditiveRuntimeClips.get(runtimeClip.name);
+    if (cached) {
+      return cached;
+    }
+    const additiveClip = this.createAdditiveRuntimeClip(runtimeClip);
+    if (!additiveClip) {
+      return null;
+    }
+    this.bakedAdditiveRuntimeClips.set(runtimeClip.name, additiveClip);
+    return additiveClip;
+  }
   setClipEventMetadata(clip, metadata) {
     const userData = clip.userData ?? (clip.userData = {});
     userData[CLIP_EVENT_METADATA_KEY] = metadata;
@@ -827,21 +1019,28 @@ var BakedAnimationController = class {
     }
     return 0;
   }
-  getOrCreateBakedRuntimeAction(sourceClipName, channel) {
+  getOrCreateBakedRuntimeAction(sourceClipName, channel, blendMode = "replace") {
     const bakedClip = this.getBakedSourceClip(sourceClipName);
     const runtimeClip = bakedClip?.runtimeClips.find((entry) => entry.channel === channel)?.clip;
     if (!runtimeClip) {
       return null;
     }
+    const desiredClip = blendMode === "additive" ? this.getOrCreateBakedAdditiveRuntimeClip(runtimeClip) : runtimeClip;
+    if (!desiredClip) {
+      return null;
+    }
     const existing = this.bakedRuntimeActions.get(runtimeClip.name);
-    if (existing) {
+    if (existing?.getClip() === desiredClip) {
       return existing;
     }
     this.ensureMixer();
     if (!this.animationMixer) {
       return null;
     }
-    const action = this.animationMixer.clipAction(runtimeClip);
+    if (existing) {
+      this.releaseBakedRuntimeAction(runtimeClip.name);
+    }
+    const action = this.animationMixer.clipAction(desiredClip);
     this.bakedRuntimeActions.set(runtimeClip.name, action);
     return action;
   }
@@ -859,7 +1058,15 @@ var BakedAnimationController = class {
     }
     const channelActions = /* @__PURE__ */ new Map();
     for (const runtimeClip of bakedClip.runtimeClips) {
-      const action = this.getOrCreateBakedRuntimeAction(clipName, runtimeClip.channel);
+      const channelBlendMode = resolveBakedChannelBlendMode(
+        runtimeClip.channel,
+        playbackState.requestedBlendMode
+      ) ?? "replace";
+      const action = this.getOrCreateBakedRuntimeAction(
+        clipName,
+        runtimeClip.channel,
+        channelBlendMode
+      );
       if (action) {
         channelActions.set(runtimeClip.channel, action);
       }
@@ -898,13 +1105,39 @@ var BakedAnimationController = class {
     }
     return getMeshNamesForVisemeProfile(config);
   }
+  hasActiveAdditivePlayback() {
+    for (const [clipName, group] of this.bakedActionGroups) {
+      const state = this.playbackState.get(clipName);
+      if (state?.blendMode !== "additive") {
+        continue;
+      }
+      for (const action of group.channelActions.values()) {
+        if (action.isRunning() && !action.paused) {
+          return true;
+        }
+      }
+    }
+    for (const [clipName, action] of this.animationActions) {
+      const state = this.playbackState.get(clipName);
+      if (state?.blendMode !== "additive") {
+        continue;
+      }
+      if (action.isRunning() && !action.paused) {
+        return true;
+      }
+    }
+    return false;
+  }
   update(dtSeconds) {
     if (this.animationMixer) {
+      this.animationMixer.update(dtSeconds);
+    }
+    if (this.clipAnimationMixer) {
       const snapshots = Array.from(this.clipMonitors.values()).map((monitor) => ({
         actionId: monitor.actionId,
         previousTime: monitor.action.time
       }));
-      this.animationMixer.update(dtSeconds);
+      this.clipAnimationMixer.update(dtSeconds);
       for (const { actionId, previousTime } of snapshots) {
         const monitor = this.clipMonitors.get(actionId);
         if (!monitor) continue;
@@ -923,16 +1156,27 @@ var BakedAnimationController = class {
         }
       }
     }
+    if (this.hasActiveAdditivePlayback()) {
+      this.host.reapplyProceduralState?.();
+    }
   }
   dispose() {
     this.stopAllAnimations();
+    this.clearAllBakedAdditiveRuntimeClips();
     if (this.animationMixer) {
       this.animationMixer.stopAllAction();
       this.animationMixer = null;
     }
+    if (this.clipAnimationMixer) {
+      this.clipAnimationMixer.stopAllAction();
+      this.clipAnimationMixer = null;
+    }
+    this.mixerFinishedListenerAttached = false;
+    this.clipMixerFinishedListenerAttached = false;
     this.animationClips = [];
     this.bakedSourceClips.clear();
     this.bakedRuntimeActions.clear();
+    this.bakedAdditiveRuntimeClips.clear();
     this.bakedActionGroups.clear();
     this.bakedRuntimeClipToSource.clear();
     this.animationActions.clear();
@@ -955,6 +1199,8 @@ var BakedAnimationController = class {
     if (this.animationMixer) {
       for (const bakedClip of this.bakedSourceClips.values()) {
         for (const runtimeClip of bakedClip.runtimeClips) {
+          this.releaseBakedRuntimeAction(runtimeClip.clip.name);
+          this.clearBakedAdditiveRuntimeClip(runtimeClip.clip.name);
           try {
             this.animationMixer.uncacheAction(runtimeClip.clip);
           } catch {
@@ -966,6 +1212,7 @@ var BakedAnimationController = class {
         }
       }
     }
+    this.clearAllBakedAdditiveRuntimeClips();
     for (const clipName of this.bakedSourceClips.keys()) {
       this.playbackState.delete(clipName);
       this.clipSources.delete(clipName);
@@ -1006,6 +1253,8 @@ var BakedAnimationController = class {
     if (this.animationMixer) {
       for (const runtimeClip of bakedClip.runtimeClips) {
         const action = this.bakedRuntimeActions.get(runtimeClip.clip.name);
+        this.releaseBakedRuntimeAction(runtimeClip.clip.name);
+        this.clearBakedAdditiveRuntimeClip(runtimeClip.clip.name);
         try {
           this.animationMixer.uncacheAction(runtimeClip.clip);
         } catch {
@@ -1014,7 +1263,6 @@ var BakedAnimationController = class {
           this.animationMixer.uncacheClip(runtimeClip.clip);
         } catch {
         }
-        this.bakedRuntimeActions.delete(runtimeClip.clip.name);
         this.bakedRuntimeClipToSource.delete(runtimeClip.clip.name);
         const actionId = this.getActionId(action);
         if (actionId && action) {
@@ -1023,6 +1271,10 @@ var BakedAnimationController = class {
         }
       }
     }
+    for (const runtimeClip of bakedClip.runtimeClips) {
+      this.clearBakedAdditiveRuntimeClip(runtimeClip.clip.name);
+      this.bakedRuntimeActions.delete(runtimeClip.clip.name);
+    }
     this.animationClips = this.animationClips.filter((entry) => entry.name !== clipName);
     this.bakedSourceClips.delete(clipName);
     this.bakedActionGroups.delete(clipName);
@@ -1083,12 +1335,12 @@ var BakedAnimationController = class {
       const actionId = this.getActionId(action);
       const isBaked = (this.clipSources.get(clipName) ?? "baked") === "baked";
       action.stop();
-      if (!isBaked && this.animationMixer) {
+      if (!isBaked && this.clipAnimationMixer) {
         try {
           const clip = action.getClip();
           if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
+            this.clipAnimationMixer.uncacheAction(clip);
+            this.clipAnimationMixer.uncacheClip(clip);
           }
         } catch {
         }
@@ -1110,11 +1362,11 @@ var BakedAnimationController = class {
       const actionId = this.getActionId(clipAction);
       try {
         clipAction.stop();
-        if (this.animationMixer) {
+        if (this.clipAnimationMixer) {
           const clip = clipAction.getClip();
           if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
+            this.clipAnimationMixer.uncacheAction(clip);
+            this.clipAnimationMixer.uncacheClip(clip);
           }
         }
       } catch {
@@ -1318,8 +1570,23 @@ var BakedAnimationController = class {
       next.blendMode = this.getBakedAggregateBlendMode(clipName, next);
       const bakedGroup = this.bakedActionGroups.get(clipName);
       if (bakedGroup) {
-        for (const [channel, action2] of bakedGroup.channelActions) {
+        for (const [channel, currentAction] of Array.from(bakedGroup.channelActions)) {
+          const channelBlendMode = resolveBakedChannelBlendMode(channel, next.requestedBlendMode) ?? "replace";
+          const previousTime = currentAction.time;
+          const wasActive = currentAction.isRunning() || currentAction.paused;
+          const wasPaused = currentAction.paused;
+          const action2 = this.getOrCreateBakedRuntimeAction(clipName, channel, channelBlendMode);
+          if (!action2) {
+            bakedGroup.channelActions.delete(channel);
+            continue;
+          }
           this.applyPlaybackStateToBakedAction(action2, next, channel);
+          action2.time = Math.max(0, Math.min(action2.getClip().duration, previousTime));
+          if (action2 !== currentAction && wasActive) {
+            action2.play();
+          }
+          action2.paused = wasPaused;
+          bakedGroup.channelActions.set(channel, action2);
         }
       }
       this.setPlaybackState(clipName, next);
@@ -1334,6 +1601,10 @@ var BakedAnimationController = class {
   seekAnimation(clipName, time) {
     const bakedGroup = this.bakedActionGroups.get(clipName);
     if (bakedGroup) {
+      const state = this.getPlaybackStateSnapshot(clipName, {
+        loop: true,
+        source: this.clipSources.get(clipName) ?? "baked"
+      });
       const duration2 = this.getBakedSourceClip(clipName)?.sourceClip.duration ?? 0;
       const clamped = Math.max(0, Math.min(duration2, Number.isFinite(time) ? time : 0));
       for (const action2 of bakedGroup.channelActions.values()) {
@@ -1341,6 +1612,10 @@ var BakedAnimationController = class {
       }
       try {
         this.animationMixer?.update(0);
+        this.clipAnimationMixer?.update(0);
+        if (state.blendMode === "additive") {
+          this.host.reapplyProceduralState?.();
+        }
       } catch {
       }
       return;
@@ -1350,7 +1625,11 @@ var BakedAnimationController = class {
     const duration = action.getClip().duration;
     action.time = Math.max(0, Math.min(duration, Number.isFinite(time) ? time : 0));
     try {
-      this.animationMixer?.update(0);
+      this.clipAnimationMixer?.update(0);
+      const state = this.playbackState.get(clipName);
+      if (state?.blendMode === "additive") {
+        this.host.reapplyProceduralState?.();
+      }
     } catch {
     }
   }
@@ -1358,6 +1637,9 @@ var BakedAnimationController = class {
     if (this.animationMixer) {
       this.animationMixer.timeScale = timeScale;
     }
+    if (this.clipAnimationMixer) {
+      this.clipAnimationMixer.timeScale = timeScale;
+    }
   }
   getAnimationState(clipName) {
     const bakedClip = this.getBakedSourceClip(clipName);
@@ -1473,12 +1755,13 @@ var BakedAnimationController = class {
     const globalBalance = options?.balance ?? 0;
     const balanceMap = options?.balanceMap;
     const meshNames = options?.meshNames;
+    const visemeSlotCount = getProfileVisemeSlots(config).length;
     let maxTime = 0;
     const isNumericAU = (id) => /^\d+$/.test(id);
     const isVisemeIndex = (id) => {
       if (options?.snippetCategory !== "visemeSnippet") return false;
       const num = Number(id);
-      return !Number.isNaN(num) && num >= 0 && num < config.visemeKeys.length;
+      return !Number.isNaN(num) && num >= 0 && num < visemeSlotCount;
     };
     const sampleAt = (arr, t) => {
       if (!arr.length) return 0;
@@ -1516,11 +1799,13 @@ var BakedAnimationController = class {
         const auId = Number(curveId);
         if (isVisemeIndex(curveId)) {
           const visemeMeshNames = this.getMeshNamesForViseme(config, meshNames);
-          const visemeKey = config.visemeKeys[auId];
-          if (typeof visemeKey === "number") {
-            this.addMorphIndexTracks(tracks, visemeKey, keyframes, intensityScale, visemeMeshNames);
-          } else if (visemeKey) {
-            this.addMorphTracks(tracks, visemeKey, keyframes, intensityScale, visemeMeshNames);
+          for (const target of getVisemeBindingTargets(config, auId)) {
+            const effectiveScale = intensityScale * target.weight;
+            if (typeof target.morph === "number") {
+              this.addMorphIndexTracks(tracks, target.morph, keyframes, effectiveScale, visemeMeshNames);
+            } else if (target.morph) {
+              this.addMorphTracks(tracks, target.morph, keyframes, effectiveScale, visemeMeshNames);
+            }
           }
         } else {
           const auMeshNames = this.getMeshNamesForAU(auId, config, meshNames);
@@ -1563,7 +1848,7 @@ var BakedAnimationController = class {
     }
     const autoVisemeJaw = options?.autoVisemeJaw !== false;
     const jawScale = options?.jawScale ?? 1;
-    const visemeJawAmounts = config.visemeJawAmounts;
+    const visemeJawAmounts = getVisemeJawAmounts(config);
     if (autoVisemeJaw && jawScale > 0 && visemeJawAmounts && options?.snippetCategory === "visemeSnippet" && keyframeTimes.length > 0) {
       const bones = this.host.getBones();
       const jawEntry = bones["JAW"];
@@ -1571,7 +1856,7 @@ var BakedAnimationController = class {
         const jawValues = [];
         for (const t of keyframeTimes) {
           let jawAmount = 0;
-          for (let visemeIdx = 0; visemeIdx < config.visemeKeys.length; visemeIdx++) {
+          for (let visemeIdx = 0; visemeIdx < visemeSlotCount; visemeIdx++) {
             const visemeCurve = curves[String(visemeIdx)];
             if (!visemeCurve) continue;
             const visemeValue = clampIntensity(sampleAt(visemeCurve, t) * intensityScale);
@@ -1687,8 +1972,8 @@ var BakedAnimationController = class {
     return clip;
   }
   playClip(clip, options) {
-    this.ensureMixer();
-    if (!this.animationMixer) {
+    const mixer = this.ensureClipMixer();
+    if (!mixer) {
       console.warn("[Loom3] playClip: No model loaded, cannot create mixer");
       return null;
     }
@@ -1706,7 +1991,7 @@ var BakedAnimationController = class {
       actionId = this.setActionId(action, clip.name);
     }
     if (!action) {
-      action = this.animationMixer.clipAction(clip);
+      action = mixer.clipAction(clip);
       actionId = this.setActionId(action, clip.name);
     }
     const existingClip = this.animationClips.find((c) => c.name === clip.name);
@@ -1767,15 +2052,13 @@ var BakedAnimationController = class {
       },
       stop: () => {
         action.stop();
-        if (this.animationMixer) {
-          try {
-            this.animationMixer.uncacheAction(clip);
-          } catch {
-          }
-          try {
-            this.animationMixer.uncacheClip(clip);
-          } catch {
-          }
+        try {
+          mixer.uncacheAction(clip);
+        } catch {
+        }
+        try {
+          mixer.uncacheClip(clip);
+        } catch {
         }
         this.clipActions.delete(clip.name);
         this.animationActions.delete(clip.name);
@@ -1816,7 +2099,7 @@ var BakedAnimationController = class {
         const clamped = Math.max(0, Math.min(clip.duration, t));
         action.time = clamped;
         try {
-          this.animationMixer?.update(0);
+          mixer.update(0);
         } catch {
         }
         this.syncClipMonitorTime(monitor, clamped, true);
@@ -1849,16 +2132,16 @@ var BakedAnimationController = class {
     return this.playClip(clip, { ...options, source: options?.source ?? "clip" });
   }
   cleanupSnippet(name) {
-    if (!this.animationMixer || !this.host.getModel()) return;
+    if (!this.host.getModel()) return;
     for (const [clipName, action] of Array.from(this.clipActions.entries())) {
       if (clipName === name || clipName.startsWith(`${name}_`)) {
         const actionId = this.getActionId(action);
         try {
           action.stop();
           const clip = action.getClip();
-          if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
+          if (clip && this.clipAnimationMixer) {
+            this.clipAnimationMixer.uncacheAction(clip);
+            this.clipAnimationMixer.uncacheClip(clip);
           }
         } catch {
         }
@@ -1886,7 +2169,10 @@ var BakedAnimationController = class {
       clipActions: Array.from(this.clipActions.entries()).map(([k, a]) => ({ name: k, actionId: this.getActionId(a) })),
       animationActions: Array.from(this.animationActions.entries()).map(([k, a]) => ({ name: k, actionId: this.getActionId(a) })),
       clipHandles: Array.from(this.clipHandles.entries()).map(([k, h]) => ({ name: k, actionId: h.actionId })),
-      mixerActions: (this.animationMixer?._actions || []).map((a) => ({ name: a?.getClip?.()?.name || "", actionId: this.getActionId(a) }))
+      mixerActions: [
+        ...this.animationMixer?._actions || [],
+        ...this.clipAnimationMixer?._actions || []
+      ].map((a) => ({ name: a?.getClip?.()?.name || "", actionId: this.getActionId(a) }))
     });
     console.log("[Loom3] updateClipParams start", debugSnapshot());
     const apply = (action) => {
@@ -2000,35 +2286,48 @@ var BakedAnimationController = class {
       this.animationMixer = new THREE2.AnimationMixer(model);
     }
     if (this.animationMixer && !this.mixerFinishedListenerAttached) {
-      this.animationMixer.addEventListener("finished", (event) => {
-        const action = event.action;
-        const actionId = this.getActionId(action);
-        if (actionId) {
-          const monitor = this.clipMonitors.get(actionId);
-          if (monitor) {
-            monitor.finishedPending = true;
-            return;
-          }
-        }
-        const clip = action.getClip();
-        const bakedRuntime = this.bakedRuntimeClipToSource.get(clip.name);
-        if (bakedRuntime) {
-          const group = this.bakedActionGroups.get(bakedRuntime.sourceClipName);
-          if (group && group.pendingFinishedChannels.delete(bakedRuntime.channel) && group.pendingFinishedChannels.size === 0) {
-            group.resolveFinished();
-          }
-          return;
-        }
-        const callback = this.animationFinishedCallbacks.get(clip.name);
-        if (callback) {
-          callback();
-          this.animationFinishedCallbacks.delete(clip.name);
-        }
-      });
+      this.animationMixer.addEventListener("finished", (event) => this.handleMixerFinished(event));
       this.mixerFinishedListenerAttached = true;
     }
     return this.animationMixer;
   }
+  ensureClipMixer() {
+    const model = this.host.getModel();
+    if (!model) return null;
+    if (!this.clipAnimationMixer) {
+      this.clipAnimationMixer = new THREE2.AnimationMixer(model);
+    }
+    if (this.clipAnimationMixer && !this.clipMixerFinishedListenerAttached) {
+      this.clipAnimationMixer.addEventListener("finished", (event) => this.handleMixerFinished(event));
+      this.clipMixerFinishedListenerAttached = true;
+    }
+    return this.clipAnimationMixer;
+  }
+  handleMixerFinished(event) {
+    const action = event.action;
+    const actionId = this.getActionId(action);
+    if (actionId) {
+      const monitor = this.clipMonitors.get(actionId);
+      if (monitor) {
+        monitor.finishedPending = true;
+        return;
+      }
+    }
+    const clip = action.getClip();
+    const bakedRuntime = this.bakedRuntimeClipToSource.get(clip.name);
+    if (bakedRuntime) {
+      const group = this.bakedActionGroups.get(bakedRuntime.sourceClipName);
+      if (group && group.pendingFinishedChannels.delete(bakedRuntime.channel) && group.pendingFinishedChannels.size === 0) {
+        group.resolveFinished();
+      }
+      return;
+    }
+    const callback = this.animationFinishedCallbacks.get(clip.name);
+    if (callback) {
+      callback();
+      this.animationFinishedCallbacks.delete(clip.name);
+    }
+  }
   createAnimationHandle(clipName, action, finishedPromise) {
     return {
       actionId: this.getActionId(action),
@@ -4992,7 +5291,8 @@ var _Loom3 = class _Loom3 {
       getCompositeRotations: () => this.compositeRotations,
       computeSideValues: (base, balance) => this.computeSideValues(base, balance),
       getAUMixWeight: (auId) => this.getAUMixWeight(auId),
-      isMixedAU: (auId) => this.isMixedAU(auId)
+      isMixedAU: (auId) => this.isMixedAU(auId),
+      reapplyProceduralState: () => this.reapplyProceduralStateAfterBakedUpdate()
     });
     this.hairPhysics = new HairPhysicsController({
       getMeshByName: (name) => this.meshByName.get(name),
@@ -5084,10 +5384,15 @@ var _Loom3 = class _Loom3 {
       };
       this.resolvedAUMorphTargets.set(auId, resolved);
     }
-    for (let i = 0; i < (this.config.visemeKeys || []).length; i += 1) {
-      const key = this.config.visemeKeys[i];
+    for (let i = 0; i < getProfileVisemeSlots(this.config).length; i += 1) {
       const visemeMeshNames = this.getMeshNamesForViseme();
-      const targets = typeof key === "number" ? this.resolveMorphTargetsByIndex(key, visemeMeshNames) : this.resolveMorphTargets(key, visemeMeshNames);
+      const targets = [];
+      for (const bindingTarget of getVisemeBindingTargets(this.config, i)) {
+        const resolved = typeof bindingTarget.morph === "number" ? this.resolveMorphTargetsByIndex(bindingTarget.morph, visemeMeshNames) : this.resolveMorphTargets(bindingTarget.morph, visemeMeshNames);
+        for (const target of resolved) {
+          targets.push({ ...target, weight: bindingTarget.weight });
+        }
+      }
       this.resolvedVisemeTargets[i] = targets;
     }
   }
@@ -5555,46 +5860,33 @@ var _Loom3 = class _Loom3 {
   // VISEME CONTROL
   // ============================================================================
   setViseme(visemeIndex, value, jawScale = 1) {
-    if (visemeIndex < 0 || visemeIndex >= this.config.visemeKeys.length) return;
+    if (visemeIndex < 0 || visemeIndex >= this.visemeValues.length) return;
     const val = clamp012(value);
     this.visemeValues[visemeIndex] = val;
     this.visemeJawScales[visemeIndex] = jawScale;
-    const targets = this.resolvedVisemeTargets[visemeIndex];
-    if (targets && targets.length > 0) {
-      this.applyMorphTargets(targets, val);
-    } else {
-      const morphKey = this.config.visemeKeys[visemeIndex];
-      const visemeMeshNames = this.getMeshNamesForViseme();
-      if (typeof morphKey === "number") {
-        this.setMorphInfluence(morphKey, val, visemeMeshNames);
-      } else if (typeof morphKey === "string") {
-        this.setMorph(morphKey, val, visemeMeshNames);
-      }
-    }
-    const jawAmount = this.getVisemeJawAmount(visemeIndex) * val * jawScale;
-    if (Math.abs(jawScale) > 1e-6 && Math.abs(jawAmount) > 1e-6) {
-      this.updateBoneRotation("JAW", "pitch", jawAmount);
-    }
+    this.applyVisemeRuntimeState();
   }
   transitionViseme(visemeIndex, to, durationMs = 80, jawScale = 1) {
-    if (visemeIndex < 0 || visemeIndex >= this.config.visemeKeys.length) {
+    if (visemeIndex < 0 || visemeIndex >= this.visemeValues.length) {
       return { promise: Promise.resolve(), pause: () => {
       }, resume: () => {
       }, cancel: () => {
       } };
     }
-    const morphKey = this.config.visemeKeys[visemeIndex];
     const target = clamp012(to);
-    this.visemeValues[visemeIndex] = target;
+    const from = this.visemeValues[visemeIndex] ?? 0;
     this.visemeJawScales[visemeIndex] = jawScale;
-    const visemeMeshNames = this.getMeshNamesForViseme();
-    const morphHandle = typeof morphKey === "number" ? this.transitionMorphInfluence(morphKey, target, durationMs, visemeMeshNames) : this.transitionMorph(morphKey, target, durationMs, visemeMeshNames);
-    const jawAmount = this.getVisemeJawAmount(visemeIndex) * target * jawScale;
-    if (Math.abs(jawScale) <= 1e-6 || Math.abs(jawAmount) <= 1e-6) {
-      return morphHandle;
-    }
-    const jawHandle = this.transitionBoneRotation("JAW", "pitch", jawAmount, durationMs);
-    return this.combineHandles([morphHandle, jawHandle]);
+    return this.animation.addTransition(
+      `viseme_value_${visemeIndex}`,
+      from,
+      target,
+      durationMs,
+      (value) => {
+        this.visemeValues[visemeIndex] = clamp012(value);
+        this.visemeJawScales[visemeIndex] = jawScale;
+        this.applyVisemeRuntimeState();
+      }
+    );
   }
   setVisemeById(slotId, value, jawScale = 1) {
     const index = getVisemeSlotIndex(this.config, slotId);
@@ -5658,8 +5950,9 @@ var _Loom3 = class _Loom3 {
   }
   resetToNeutral() {
     this.auValues = {};
-    this.visemeValues = new Array(this.config.visemeKeys.length).fill(0);
-    this.visemeJawScales = new Array(this.config.visemeKeys.length).fill(1);
+    const visemeCount = getProfileVisemeSlots(this.config).length;
+    this.visemeValues = new Array(visemeCount).fill(0);
+    this.visemeJawScales = new Array(visemeCount).fill(1);
     this.translations = {};
     this.initBoneRotations();
     this.clearTransitions();
@@ -5693,15 +5986,35 @@ var _Loom3 = class _Loom3 {
       if (Number.isNaN(auId)) continue;
       this.setAU(auId, value, this.auBalances[auId]);
     }
+    this.applyVisemeRuntimeState();
+    if (this.model) {
+      this.flushPendingComposites();
+      this.model.updateMatrixWorld(true);
+    }
+  }
+  reapplyProceduralStateAfterBakedUpdate() {
+    if (!this.model) {
+      return;
+    }
+    let hasActiveOverrides = false;
+    for (const [auIdStr, value] of Object.entries(this.auValues)) {
+      if (value <= 0) continue;
+      const auId = Number(auIdStr);
+      if (Number.isNaN(auId)) continue;
+      hasActiveOverrides = true;
+      this.setAU(auId, value, this.auBalances[auId]);
+    }
     for (let visemeIndex = 0; visemeIndex < this.visemeValues.length; visemeIndex += 1) {
       const value = this.visemeValues[visemeIndex] ?? 0;
       if (value <= 0) continue;
+      hasActiveOverrides = true;
       this.setViseme(visemeIndex, value, this.visemeJawScales[visemeIndex] ?? 1);
     }
-    if (this.model) {
-      this.flushPendingComposites();
-      this.model.updateMatrixWorld(true);
+    if (!hasActiveOverrides) {
+      return;
     }
+    this.flushPendingComposites();
+    this.model.updateMatrixWorld(true);
   }
   // ============================================================================
   // MESH CONTROL
@@ -6031,6 +6344,37 @@ var _Loom3 = class _Loom3 {
       target.infl[target.idx] = val;
     }
   }
+  applyVisemeRuntimeState() {
+    for (const targets of this.resolvedVisemeTargets) {
+      for (const target of targets || []) {
+        if (target.idx < target.infl.length) {
+          target.infl[target.idx] = 0;
+        }
+      }
+    }
+    for (let index = 0; index < this.visemeValues.length; index += 1) {
+      const value = clamp012(this.visemeValues[index] ?? 0);
+      if (value <= 1e-6) continue;
+      const targets = this.resolvedVisemeTargets[index] || [];
+      for (const target of targets) {
+        if (target.idx >= target.infl.length) continue;
+        const weighted = clamp012(value * target.weight);
+        target.infl[target.idx] = Math.max(target.infl[target.idx] ?? 0, weighted);
+      }
+    }
+    this.updateBoneRotation("JAW", "pitch", this.getActiveVisemeJawAmount());
+  }
+  getActiveVisemeJawAmount() {
+    let jawAmount = 0;
+    for (let index = 0; index < this.visemeValues.length; index += 1) {
+      const value = clamp012(this.visemeValues[index] ?? 0);
+      if (value <= 1e-6) continue;
+      const jawScale = this.visemeJawScales[index] ?? 1;
+      if (Math.abs(jawScale) <= 1e-6) continue;
+      jawAmount = Math.max(jawAmount, this.getVisemeJawAmount(index) * value * jawScale);
+    }
+    return jawAmount;
+  }
   getMorphValue(key) {
     if (this.faceMesh) {
       const dict = this.faceMesh.morphTargetDictionary;
@@ -6216,7 +6560,7 @@ var _Loom3 = class _Loom3 {
     return meshNames?.length ? `idx:${index}@${meshNames.join(",")}` : `idx:${index}`;
   }
   syncVisemeRuntimeState() {
-    const visemeCount = this.config.visemeKeys.length;
+    const visemeCount = getProfileVisemeSlots(this.config).length;
     this.visemeValues = Array.from(
       { length: visemeCount },
       (_, index) => this.visemeValues[index] ?? 0
@@ -8339,6 +8683,7 @@ exports.getModelForwardDirection = getModelForwardDirection;
 exports.getPreset = getPreset;
 exports.getPresetWithProfile = getPresetWithProfile;
 exports.getProfileVisemeSlots = getProfileVisemeSlots;
+exports.getVisemeBindingTargets = getVisemeBindingTargets;
 exports.getVisemeJawAmounts = getVisemeJawAmounts;
 exports.getVisemeSlotIndex = getVisemeSlotIndex;
 exports.hasLeftRightMorphs = hasLeftRightMorphs;