@lovelace_lol/loom3 1.0.42 → 1.0.44

package/dist/index.js

@@ -1,5 +1,5 @@
 import * as THREE2 from 'three';
-import { Vector3, Clock, Box3, BufferAttribute, Quaternion, AdditiveAnimationBlendMode, NormalAnimationBlendMode, LoopPingPong, LoopOnce, LoopRepeat, QuaternionKeyframeTrack, NumberKeyframeTrack, AnimationClip, AnimationMixer, Mesh, PropertyBinding } from 'three';
+import { Vector3, Clock, Box3, BufferAttribute, Quaternion, PropertyBinding, NumberKeyframeTrack, QuaternionKeyframeTrack, VectorKeyframeTrack, AnimationClip, AnimationUtils, AdditiveAnimationBlendMode, NormalAnimationBlendMode, LoopPingPong, LoopOnce, LoopRepeat, AnimationMixer, Mesh } from 'three';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -53,6 +53,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));
@@ -78,6 +81,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;
@@ -489,14 +509,19 @@ var Y_AXIS = new Vector3(0, 1, 0);
 var Z_AXIS = new 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());
@@ -521,6 +546,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) ?? 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 NumberKeyframeTrack(track.name, [0], values);
+    }
+    if (track.ValueTypeName === "quaternion") {
+      return new QuaternionKeyframeTrack(track.name, [0], values);
+    }
+    if (track.ValueTypeName === "vector") {
+      return new 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 = PropertyBinding.parseTrackName(trackName);
+    } catch {
+      return null;
+    }
+    const target = this.resolveTrackTarget(model, parsed);
+    if (parsed.propertyName === "morphTargetInfluences") {
+      return new 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 AnimationClip(
+      `${runtimeClip.name}${ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX}`,
+      runtimeClip.duration,
+      additiveTracks
+    );
+    if (additiveTracks.length > 0) {
+      const referenceClip = new AnimationClip(
+        `${runtimeClip.name}${ADDITIVE_BAKED_RUNTIME_CLIP_SUFFIX}_reference`,
+        0,
+        referenceTracks
+      );
+      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;
@@ -806,21 +998,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;
   }
@@ -838,7 +1037,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);
       }
@@ -877,13 +1084,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;
@@ -902,16 +1135,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();
@@ -934,6 +1178,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 {
@@ -945,6 +1191,7 @@ var BakedAnimationController = class {
         }
       }
     }
+    this.clearAllBakedAdditiveRuntimeClips();
     for (const clipName of this.bakedSourceClips.keys()) {
       this.playbackState.delete(clipName);
       this.clipSources.delete(clipName);
@@ -985,6 +1232,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 {
@@ -993,7 +1242,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) {
@@ -1002,6 +1250,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);
@@ -1062,12 +1314,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 {
         }
@@ -1089,11 +1341,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 {
@@ -1297,8 +1549,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);
@@ -1313,6 +1580,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()) {
@@ -1320,6 +1591,10 @@ var BakedAnimationController = class {
       }
       try {
         this.animationMixer?.update(0);
+        this.clipAnimationMixer?.update(0);
+        if (state.blendMode === "additive") {
+          this.host.reapplyProceduralState?.();
+        }
       } catch {
       }
       return;
@@ -1329,7 +1604,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 {
     }
   }
@@ -1337,6 +1616,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);
@@ -1452,12 +1734,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;
@@ -1495,11 +1778,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);
@@ -1542,7 +1827,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"];
@@ -1550,7 +1835,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);
@@ -1666,8 +1951,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;
     }
@@ -1685,7 +1970,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);
@@ -1746,15 +2031,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);
@@ -1795,7 +2078,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);
@@ -1828,16 +2111,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 {
         }
@@ -1865,7 +2148,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) => {
@@ -1979,35 +2265,48 @@ var BakedAnimationController = class {
       this.animationMixer = new 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 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),
@@ -4971,7 +5270,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),
@@ -5063,10 +5363,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;
     }
   }
@@ -5534,46 +5839,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);
@@ -5637,8 +5929,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();
@@ -5672,15 +5965,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
@@ -6010,6 +6323,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;
@@ -6195,7 +6539,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
@@ -8268,6 +8612,6 @@ async function analyzeModel(options) {
   };
 }
 
-export { AU_INFO, AU_MAPPING_CONFIG, AU_MIX_DEFAULTS, AU_TO_MORPHS, AnimationThree, BETTA_FISH_PRESET, BLENDING_MODES, BONE_AU_TO_BINDINGS, CC4_BONE_NODES, CC4_BONE_PREFIX, CC4_EYE_MESH_NODES, CC4_MAPPING_SECTIONS, CC4_MESHES, CC4_PRESET, CC4_SUFFIX_PATTERN, CC4_VISEME_SLOTS, CC4_VISEME_SYSTEM_ID, COMPOSITE_ROTATIONS, CONTINUUM_LABELS, CONTINUUM_PAIRS_MAP, DEFAULT_HAIR_PHYSICS_CONFIG, FISH_AU_MAPPING_CONFIG, HairPhysics, Loom3, Loom3 as Loom3Three, Loom3 as LoomLargeThree, MORPH_TO_MESH, VISEME_JAW_AMOUNTS, VISEME_KEYS, analyzeModel, applyCharacterProfileToPreset, buildMappingEditorModel, collectMorphMeshes, compileVisemeKeys, computeCameraRelativeGazeOffset, detectFacingDirection, extendCharacterConfigWithPreset, extendPresetWithProfile, extractFromGLTF, extractModelData, extractProfileOverrides, findFaceCenter, fuzzyNameMatch, generateMappingCorrections, getMeshNamesForAUProfile, getMeshNamesForVisemeProfile, getModelForwardDirection, getPreset, getPresetWithProfile, getProfileVisemeSlots, getVisemeJawAmounts, getVisemeSlotIndex, hasLeftRightMorphs, isMixedAU, isPresetCompatible, mapProviderVisemeToSlot, mergeRegionsByName as mergeCharacterRegionsByName, resolveBoneName, resolveBoneNames, resolveFaceCenter, resolvePreset, resolvePresetWithOverrides, resolveVisemeMeshCategory, suggestBestPreset, validateMappingConfig, validateMappings };
+export { AU_INFO, AU_MAPPING_CONFIG, AU_MIX_DEFAULTS, AU_TO_MORPHS, AnimationThree, BETTA_FISH_PRESET, BLENDING_MODES, BONE_AU_TO_BINDINGS, CC4_BONE_NODES, CC4_BONE_PREFIX, CC4_EYE_MESH_NODES, CC4_MAPPING_SECTIONS, CC4_MESHES, CC4_PRESET, CC4_SUFFIX_PATTERN, CC4_VISEME_SLOTS, CC4_VISEME_SYSTEM_ID, COMPOSITE_ROTATIONS, CONTINUUM_LABELS, CONTINUUM_PAIRS_MAP, DEFAULT_HAIR_PHYSICS_CONFIG, FISH_AU_MAPPING_CONFIG, HairPhysics, Loom3, Loom3 as Loom3Three, Loom3 as LoomLargeThree, MORPH_TO_MESH, VISEME_JAW_AMOUNTS, VISEME_KEYS, analyzeModel, applyCharacterProfileToPreset, buildMappingEditorModel, collectMorphMeshes, compileVisemeKeys, computeCameraRelativeGazeOffset, detectFacingDirection, extendCharacterConfigWithPreset, extendPresetWithProfile, extractFromGLTF, extractModelData, extractProfileOverrides, findFaceCenter, fuzzyNameMatch, generateMappingCorrections, getMeshNamesForAUProfile, getMeshNamesForVisemeProfile, getModelForwardDirection, getPreset, getPresetWithProfile, getProfileVisemeSlots, getVisemeBindingTargets, getVisemeJawAmounts, getVisemeSlotIndex, hasLeftRightMorphs, isMixedAU, isPresetCompatible, mapProviderVisemeToSlot, mergeRegionsByName as mergeCharacterRegionsByName, resolveBoneName, resolveBoneNames, resolveFaceCenter, resolvePreset, resolvePresetWithOverrides, resolveVisemeMeshCategory, suggestBestPreset, validateMappingConfig, validateMappings };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map