@lovelace_lol/loom3 1.0.42 → 1.0.43

package/dist/index.cjs

@@ -510,14 +510,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 +547,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 +999,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 +1038,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 +1085,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 +1136,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 +1179,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 +1192,7 @@ var BakedAnimationController = class {
         }
       }
     }
+    this.clearAllBakedAdditiveRuntimeClips();
     for (const clipName of this.bakedSourceClips.keys()) {
       this.playbackState.delete(clipName);
       this.clipSources.delete(clipName);
@@ -1006,6 +1233,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 +1243,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 +1251,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 +1315,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 +1342,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 +1550,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 +1581,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 +1592,10 @@ var BakedAnimationController = class {
       }
       try {
         this.animationMixer?.update(0);
+        this.clipAnimationMixer?.update(0);
+        if (state.blendMode === "additive") {
+          this.host.reapplyProceduralState?.();
+        }
       } catch {
       }
       return;
@@ -1350,7 +1605,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 +1617,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);
@@ -1687,8 +1949,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 +1968,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 +2029,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 +2076,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 +2109,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 +2146,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 +2263,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 +5268,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),
@@ -5703,6 +5980,30 @@ var _Loom3 = class _Loom3 {
       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 (!hasActiveOverrides) {
+      return;
+    }
+    this.flushPendingComposites();
+    this.model.updateMatrixWorld(true);
+  }
   // ============================================================================
   // MESH CONTROL
   // ============================================================================