@lovelace_lol/loom3 1.0.15 → 1.0.16

package/dist/index.cjs

@@ -188,6 +188,8 @@ var BakedAnimationController = class {
     __publicField(this, "animationFinishedCallbacks", /* @__PURE__ */ new Map());
     __publicField(this, "clipActions", /* @__PURE__ */ new Map());
     __publicField(this, "clipHandles", /* @__PURE__ */ new Map());
+    __publicField(this, "clipSources", /* @__PURE__ */ new Map());
+    __publicField(this, "playbackState", /* @__PURE__ */ new Map());
     __publicField(this, "actionIds", /* @__PURE__ */ new WeakMap());
     __publicField(this, "actionIdToClip", /* @__PURE__ */ new Map());
     this.host = host;
@@ -203,6 +205,117 @@ var BakedAnimationController = class {
     action.__actionId = actionId;
     return actionId;
   }
+  normalizePlaybackOptions(options, defaults) {
+    const clipOptions = options;
+    const rawRate = options?.playbackRate ?? options?.speed ?? 1;
+    const playbackRate = Number.isFinite(rawRate) ? Math.max(0, Math.abs(rawRate)) : 1;
+    const rawWeight = options?.weight ?? options?.intensity ?? clipOptions?.mixerWeight ?? 1;
+    const weight = Number.isFinite(rawWeight) ? Math.max(0, rawWeight) : 1;
+    const loopMode = options?.loopMode ?? (typeof options?.loop === "boolean" ? options.loop ? "repeat" : "once" : defaults.loop ? "repeat" : "once");
+    return {
+      source: options?.source ?? defaults.source,
+      loop: loopMode !== "once",
+      loopMode,
+      repeatCount: options?.repeatCount,
+      reverse: !!options?.reverse,
+      playbackRate,
+      weight,
+      balance: Number.isFinite(options?.balance) ? options?.balance ?? 0 : 0,
+      blendMode: options?.blendMode ?? (clipOptions?.mixerAdditive ? "additive" : "replace"),
+      easing: options?.easing ?? "linear"
+    };
+  }
+  applyPlaybackState(action, state) {
+    const signedRate = state.reverse ? -state.playbackRate : state.playbackRate;
+    action.setEffectiveTimeScale(signedRate);
+    action.setEffectiveWeight(state.weight);
+    action.blendMode = state.blendMode === "additive" ? THREE.AdditiveAnimationBlendMode : THREE.NormalAnimationBlendMode;
+    const reps = state.repeatCount ?? Infinity;
+    if (state.loopMode === "pingpong") {
+      action.setLoop(THREE.LoopPingPong, reps);
+    } else if (state.loopMode === "once") {
+      action.setLoop(THREE.LoopOnce, 1);
+    } else {
+      action.setLoop(THREE.LoopRepeat, reps);
+    }
+    action.clampWhenFinished = state.loopMode === "once";
+  }
+  setPlaybackState(clipName, state) {
+    this.playbackState.set(clipName, state);
+    this.clipSources.set(clipName, state.source);
+  }
+  getPlaybackStateSnapshot(clipName, defaults) {
+    const existing = this.playbackState.get(clipName);
+    if (existing) {
+      return { ...existing };
+    }
+    return this.normalizePlaybackOptions(void 0, defaults);
+  }
+  mergePlaybackOptions(current, options) {
+    if (!options) {
+      return current;
+    }
+    const next = { ...current };
+    const clipOptions = options;
+    const loopMode = options.loopMode ?? (typeof options.loop === "boolean" ? options.loop ? "repeat" : "once" : void 0);
+    if (options.source) next.source = options.source;
+    if (loopMode) {
+      next.loopMode = loopMode;
+      next.loop = loopMode !== "once";
+    }
+    if (options.repeatCount !== void 0) {
+      next.repeatCount = Number.isFinite(options.repeatCount) ? Math.max(0, options.repeatCount ?? 0) : void 0;
+    }
+    if (typeof options.reverse === "boolean") {
+      next.reverse = options.reverse;
+    }
+    const rate = options.playbackRate ?? options.speed;
+    if (rate !== void 0) {
+      next.playbackRate = Number.isFinite(rate) ? Math.max(0, Math.abs(rate)) : current.playbackRate;
+    }
+    const weight = options.weight ?? options.intensity ?? clipOptions?.mixerWeight;
+    if (weight !== void 0) {
+      next.weight = Number.isFinite(weight) ? Math.max(0, weight) : current.weight;
+    }
+    if (typeof options.balance === "number" && Number.isFinite(options.balance)) {
+      next.balance = Math.max(-1, Math.min(1, options.balance));
+    }
+    if (options.blendMode) {
+      next.blendMode = options.blendMode;
+    } else if (typeof clipOptions?.mixerAdditive === "boolean") {
+      next.blendMode = clipOptions.mixerAdditive ? "additive" : "replace";
+    }
+    if (options.easing) {
+      next.easing = options.easing;
+    }
+    return next;
+  }
+  resolveStartTime(duration, state, explicitStartTime) {
+    if (typeof explicitStartTime === "number" && Number.isFinite(explicitStartTime)) {
+      return Math.max(0, Math.min(duration, explicitStartTime));
+    }
+    if (state.reverse && state.loopMode === "once") {
+      return duration;
+    }
+    return 0;
+  }
+  getOrCreateBakedAction(clipName) {
+    const existing = this.animationActions.get(clipName);
+    if (existing) {
+      return existing;
+    }
+    this.ensureMixer();
+    if (!this.animationMixer) {
+      return null;
+    }
+    const clip = this.animationClips.find((entry) => entry.name === clipName);
+    if (!clip || (this.clipSources.get(clipName) ?? "baked") !== "baked") {
+      return null;
+    }
+    const action = this.animationMixer.clipAction(clip);
+    this.animationActions.set(clipName, action);
+    return action;
+  }
   getMeshNamesForAU(auId, config, explicitMeshNames) {
     if (explicitMeshNames && explicitMeshNames.length > 0) {
       return explicitMeshNames;
@@ -245,6 +358,8 @@ var BakedAnimationController = class {
     this.animationFinishedCallbacks.clear();
     this.clipActions.clear();
     this.clipHandles.clear();
+    this.clipSources.clear();
+    this.playbackState.clear();
   }
   loadAnimationClips(clips) {
     if (!this.host.getModel()) {
@@ -254,6 +369,7 @@ var BakedAnimationController = class {
     this.ensureMixer();
     this.animationClips = clips;
     for (const clip of this.animationClips) {
+      this.clipSources.set(clip.name, "baked");
       if (!this.animationActions.has(clip.name) && this.animationMixer) {
         const action = this.animationMixer.clipAction(clip);
         this.animationActions.set(clip.name, action);
@@ -264,53 +380,43 @@ var BakedAnimationController = class {
     return this.animationClips.map((clip) => ({
       name: clip.name,
       duration: clip.duration,
-      trackCount: clip.tracks.length
+      trackCount: clip.tracks.length,
+      source: this.clipSources.get(clip.name) ?? "baked"
     }));
   }
   playAnimation(clipName, options = {}) {
-    const action = this.animationActions.get(clipName);
+    const action = this.getOrCreateBakedAction(clipName);
     if (!action) {
       console.warn(`Loom3: Animation clip "${clipName}" not found`);
       return null;
     }
-    const {
-      speed = 1,
-      intensity = 1,
-      loop = true,
-      loopMode = "repeat",
-      repeatCount,
-      crossfadeDuration = 0,
-      clampWhenFinished = true,
-      startTime = 0
-    } = options;
-    action.setEffectiveTimeScale(speed);
-    action.setEffectiveWeight(intensity);
-    action.clampWhenFinished = clampWhenFinished;
-    const reps = repeatCount ?? Infinity;
-    if (!loop || loopMode === "once") {
-      action.setLoop(THREE.LoopOnce, 1);
-    } else if (loopMode === "pingpong") {
-      action.setLoop(THREE.LoopPingPong, reps);
-    } else {
-      action.setLoop(THREE.LoopRepeat, reps);
-    }
-    if (startTime > 0) {
-      action.time = startTime;
+    if (!this.getActionId(action)) {
+      this.setActionId(action, clipName);
     }
+    const playbackState = this.mergePlaybackOptions(
+      this.getPlaybackStateSnapshot(clipName, { loop: true, source: "baked" }),
+      options
+    );
+    const crossfadeDuration = options.crossfadeDuration ?? 0;
+    const clampWhenFinished = options.clampWhenFinished ?? playbackState.loopMode === "once";
+    const startTime = this.resolveStartTime(action.getClip().duration, playbackState, options.startTime);
+    this.applyPlaybackState(action, playbackState);
+    action.clampWhenFinished = clampWhenFinished;
     if (crossfadeDuration > 0) {
       action.reset();
       action.fadeIn(crossfadeDuration);
     } else {
       action.reset();
     }
+    action.time = startTime;
     action.play();
     this.animationActions.set(clipName, action);
-    this.clipActions.set(clipName, action);
+    this.setPlaybackState(clipName, playbackState);
     let resolveFinished;
     const finishedPromise = new Promise((resolve) => {
       resolveFinished = resolve;
     });
-    if (!loop || loopMode === "once") {
+    if (playbackState.loopMode === "once") {
       this.animationFinishedCallbacks.set(clipName, () => resolveFinished());
     }
     return this.createAnimationHandle(clipName, action, finishedPromise);
@@ -318,8 +424,9 @@ var BakedAnimationController = class {
   stopAnimation(clipName) {
     const action = this.animationActions.get(clipName);
     if (action) {
+      const isBaked = (this.clipSources.get(clipName) ?? "baked") === "baked";
       action.stop();
-      if (this.animationMixer) {
+      if (!isBaked && this.animationMixer) {
         try {
           const clip = action.getClip();
           if (clip) {
@@ -329,7 +436,15 @@ var BakedAnimationController = class {
         } catch {
         }
       }
-      this.animationActions.delete(clipName);
+      if (!isBaked) {
+        this.animationActions.delete(clipName);
+        this.playbackState.delete(clipName);
+      } else {
+        try {
+          action.paused = false;
+        } catch {
+        }
+      }
       this.animationFinishedCallbacks.delete(clipName);
     }
     const clipAction = this.clipActions.get(clipName);
@@ -347,44 +462,18 @@ var BakedAnimationController = class {
       }
       this.clipActions.delete(clipName);
     }
+    if (this.clipActions.get(clipName) === action) {
+      this.clipActions.delete(clipName);
+    }
     this.clipHandles.delete(clipName);
   }
   stopAllAnimations() {
-    for (const [name, action] of this.animationActions) {
-      try {
-        action.stop();
-        if (this.animationMixer) {
-          const clip = action.getClip();
-          if (clip) {
-            this.animationMixer.uncacheAction(clip);
-            this.animationMixer.uncacheClip(clip);
-          }
-        }
-      } catch {
-      }
-      try {
-        this.animationFinishedCallbacks.delete(name);
-      } catch {
-      }
-    }
-    for (const [name, action] of this.clipActions) {
-      if (!this.animationActions.has(name)) {
-        try {
-          action.stop();
-          if (this.animationMixer) {
-            const clip = action.getClip();
-            if (clip) {
-              this.animationMixer.uncacheAction(clip);
-              this.animationMixer.uncacheClip(clip);
-            }
-          }
-        } catch {
-        }
-      }
+    for (const clipName of /* @__PURE__ */ new Set([
+      ...this.animationActions.keys(),
+      ...this.clipActions.keys()
+    ])) {
+      this.stopAnimation(clipName);
     }
-    this.animationActions.clear();
-    this.clipActions.clear();
-    this.clipHandles.clear();
   }
   pauseAnimation(clipName) {
     const action = this.animationActions.get(clipName);
@@ -413,15 +502,82 @@ var BakedAnimationController = class {
     }
   }
   setAnimationSpeed(clipName, speed) {
-    const action = this.animationActions.get(clipName);
+    const action = this.getOrCreateBakedAction(clipName);
     if (action) {
-      action.setEffectiveTimeScale(speed);
+      const next = this.getPlaybackStateSnapshot(clipName, {
+        loop: true,
+        source: this.clipSources.get(clipName) ?? "baked"
+      });
+      next.playbackRate = Number.isFinite(speed) ? Math.max(0, Math.abs(speed)) : 1;
+      this.applyPlaybackState(action, next);
+      this.setPlaybackState(clipName, next);
     }
   }
   setAnimationIntensity(clipName, intensity) {
-    const action = this.animationActions.get(clipName);
+    const action = this.getOrCreateBakedAction(clipName);
     if (action) {
-      action.setEffectiveWeight(Math.max(0, Math.min(1, intensity)));
+      const next = this.getPlaybackStateSnapshot(clipName, {
+        loop: true,
+        source: this.clipSources.get(clipName) ?? "baked"
+      });
+      next.weight = Number.isFinite(intensity) ? Math.max(0, intensity) : 1;
+      action.setEffectiveWeight(next.weight);
+      this.setPlaybackState(clipName, next);
+    }
+  }
+  setAnimationLoopMode(clipName, loopMode) {
+    const action = this.getOrCreateBakedAction(clipName);
+    if (!action) return;
+    const next = this.getPlaybackStateSnapshot(clipName, {
+      loop: true,
+      source: this.clipSources.get(clipName) ?? "baked"
+    });
+    next.loopMode = loopMode;
+    next.loop = loopMode !== "once";
+    this.applyPlaybackState(action, next);
+    this.setPlaybackState(clipName, next);
+  }
+  setAnimationRepeatCount(clipName, repeatCount) {
+    const action = this.getOrCreateBakedAction(clipName);
+    if (!action) return;
+    const next = this.getPlaybackStateSnapshot(clipName, {
+      loop: true,
+      source: this.clipSources.get(clipName) ?? "baked"
+    });
+    next.repeatCount = typeof repeatCount === "number" && Number.isFinite(repeatCount) ? Math.max(0, repeatCount) : void 0;
+    this.applyPlaybackState(action, next);
+    this.setPlaybackState(clipName, next);
+  }
+  setAnimationReverse(clipName, reverse) {
+    const action = this.getOrCreateBakedAction(clipName);
+    if (!action) return;
+    const next = this.getPlaybackStateSnapshot(clipName, {
+      loop: true,
+      source: this.clipSources.get(clipName) ?? "baked"
+    });
+    next.reverse = !!reverse;
+    this.applyPlaybackState(action, next);
+    this.setPlaybackState(clipName, next);
+  }
+  setAnimationBlendMode(clipName, blendMode) {
+    const action = this.getOrCreateBakedAction(clipName);
+    if (!action) return;
+    const next = this.getPlaybackStateSnapshot(clipName, {
+      loop: true,
+      source: this.clipSources.get(clipName) ?? "baked"
+    });
+    next.blendMode = blendMode;
+    this.applyPlaybackState(action, next);
+    this.setPlaybackState(clipName, next);
+  }
+  seekAnimation(clipName, time) {
+    const action = this.getOrCreateBakedAction(clipName) ?? this.animationActions.get(clipName);
+    if (!action) return;
+    const duration = action.getClip().duration;
+    action.time = Math.max(0, Math.min(duration, Number.isFinite(time) ? time : 0));
+    try {
+      this.animationMixer?.update(0);
+    } catch {
     }
   }
   setAnimationTimeScale(timeScale) {
@@ -433,15 +589,29 @@ var BakedAnimationController = class {
     const action = this.animationActions.get(clipName);
     if (!action) return null;
     const clip = action.getClip();
+    const state = this.playbackState.get(clipName);
+    const loopMode = state?.loopMode ?? (action.loop === THREE.LoopPingPong ? "pingpong" : action.loop === THREE.LoopOnce ? "once" : "repeat");
+    const playbackRate = state?.playbackRate ?? Math.abs(action.getEffectiveTimeScale());
+    const reverse = state?.reverse ?? action.getEffectiveTimeScale() < 0;
     return {
       name: clip.name,
+      actionId: this.getActionId(action),
+      source: state?.source ?? this.clipSources.get(clip.name) ?? "baked",
       isPlaying: action.isRunning() && !action.paused,
       isPaused: action.paused,
       time: action.time,
       duration: clip.duration,
-      speed: action.getEffectiveTimeScale(),
-      weight: action.getEffectiveWeight(),
-      isLooping: action.loop !== THREE.LoopOnce
+      speed: playbackRate,
+      playbackRate,
+      reverse,
+      weight: state?.weight ?? action.getEffectiveWeight(),
+      balance: state?.balance ?? 0,
+      blendMode: state?.blendMode ?? "replace",
+      easing: state?.easing ?? "linear",
+      loop: loopMode !== "once",
+      loopMode,
+      repeatCount: state?.repeatCount,
+      isLooping: loopMode !== "once"
     };
   }
   getPlayingAnimations() {
@@ -698,14 +868,14 @@ var BakedAnimationController = class {
       console.warn("[Loom3] playClip: No model loaded, cannot create mixer");
       return null;
     }
-    const {
-      loop = false,
-      loopMode,
-      repeatCount,
-      reverse = false,
-      playbackRate = 1,
-      mixerWeight
-    } = options || {};
+    const playbackState = this.mergePlaybackOptions(
+      this.getPlaybackStateSnapshot(clip.name, {
+        loop: false,
+        source: options?.source ?? "clip"
+      }),
+      options
+    );
+    const startTime = this.resolveStartTime(clip.duration, playbackState, options?.startTime);
     let action = this.clipActions.get(clip.name);
     let actionId = this.getActionId(action);
     if (action && !actionId) {
@@ -719,20 +889,7 @@ var BakedAnimationController = class {
     if (!existingClip) {
       this.animationClips.push(clip);
     }
-    const timeScale = reverse ? -playbackRate : playbackRate;
-    action.setEffectiveTimeScale(timeScale);
-    const weight = typeof mixerWeight === "number" ? mixerWeight : 1;
-    action.setEffectiveWeight(weight);
-    const mode = loopMode || (loop ? "repeat" : "once");
-    action.clampWhenFinished = mode === "once";
-    const reps = repeatCount ?? Infinity;
-    if (mode === "pingpong") {
-      action.setLoop(THREE.LoopPingPong, reps);
-    } else if (mode === "once") {
-      action.setLoop(THREE.LoopOnce, 1);
-    } else {
-      action.setLoop(THREE.LoopRepeat, reps);
-    }
+    this.applyPlaybackState(action, playbackState);
     let resolveFinished;
     const finishedPromise = new Promise((resolve) => {
       resolveFinished = resolve;
@@ -753,15 +910,24 @@ var BakedAnimationController = class {
     });
     finishedPromise.catch(() => cleanup());
     action.reset();
+    action.time = startTime;
     action.play();
     this.clipActions.set(clip.name, action);
     this.animationActions.set(clip.name, action);
-    console.log(`[Loom3] playClip: Playing "${clip.name}" (rate: ${playbackRate}, loop: ${loop}, actionId: ${actionId})`);
+    this.setPlaybackState(clip.name, playbackState);
+    console.log(`[Loom3] playClip: Playing "${clip.name}" (rate: ${playbackState.playbackRate}, loop: ${playbackState.loop}, actionId: ${actionId})`);
     const handle = {
       clipName: clip.name,
       actionId,
       play: () => {
         action.reset();
+        action.time = this.resolveStartTime(
+          clip.duration,
+          this.getPlaybackStateSnapshot(clip.name, {
+            loop: false,
+            source: this.clipSources.get(clip.name) ?? playbackState.source
+          })
+        );
         action.play();
       },
       stop: () => {
@@ -779,6 +945,7 @@ var BakedAnimationController = class {
         this.clipActions.delete(clip.name);
         this.animationActions.delete(clip.name);
         this.animationFinishedCallbacks.delete(clip.name);
+        this.playbackState.delete(clip.name);
         resolveFinished();
         cleanup();
       },
@@ -789,21 +956,24 @@ var BakedAnimationController = class {
         action.paused = false;
       },
       setWeight: (w) => {
-        action.setEffectiveWeight(typeof w === "number" && Number.isFinite(w) ? w : 1);
+        const next = this.playbackState.get(clip.name) ?? playbackState;
+        next.weight = typeof w === "number" && Number.isFinite(w) ? Math.max(0, w) : 1;
+        action.setEffectiveWeight(next.weight);
+        this.setPlaybackState(clip.name, next);
       },
       setPlaybackRate: (r) => {
-        const rate = Number.isFinite(r) ? r : 1;
-        action.setEffectiveTimeScale(rate);
+        const next = this.playbackState.get(clip.name) ?? playbackState;
+        next.playbackRate = Number.isFinite(r) ? Math.max(0, Math.abs(r)) : 1;
+        this.applyPlaybackState(action, next);
+        this.setPlaybackState(clip.name, next);
       },
-      setLoop: (mode2, repeatCount2) => {
-        const reps2 = repeatCount2 ?? Infinity;
-        if (mode2 === "pingpong") {
-          action.setLoop(THREE.LoopPingPong, reps2);
-        } else if (mode2 === "once") {
-          action.setLoop(THREE.LoopOnce, 1);
-        } else {
-          action.setLoop(THREE.LoopRepeat, reps2);
-        }
+      setLoop: (mode, repeatCount) => {
+        const next = this.playbackState.get(clip.name) ?? playbackState;
+        next.loopMode = mode;
+        next.loop = mode !== "once";
+        next.repeatCount = repeatCount;
+        this.applyPlaybackState(action, next);
+        this.setPlaybackState(clip.name, next);
       },
       setTime: (t) => {
         const clamped = Math.max(0, Math.min(clip.duration, t));
@@ -825,14 +995,14 @@ var BakedAnimationController = class {
     if (!clip) {
       return null;
     }
-    return this.playClip(clip, options);
+    return this.playClip(clip, { ...options, source: options?.source ?? "snippet" });
   }
   buildClip(clipName, curves, options) {
     const clip = this.snippetToClip(clipName, curves, options);
     if (!clip) {
       return null;
     }
-    return this.playClip(clip, options);
+    return this.playClip(clip, { ...options, source: options?.source ?? "clip" });
   }
   cleanupSnippet(name) {
     if (!this.animationMixer || !this.host.getModel()) return;
@@ -851,6 +1021,7 @@ var BakedAnimationController = class {
         this.animationActions.delete(clipName);
         this.clipHandles.delete(clipName);
         this.animationFinishedCallbacks.delete(clipName);
+        this.playbackState.delete(clipName);
       }
     }
   }
@@ -874,31 +1045,34 @@ var BakedAnimationController = class {
     console.log("[Loom3] updateClipParams start", debugSnapshot());
     const apply = (action) => {
       if (!action) return;
+      const clipName = action.getClip().name;
+      const next = this.playbackState.get(clipName) ?? this.normalizePlaybackOptions(void 0, { loop: false, source: this.clipSources.get(clipName) ?? "clip" });
       try {
         action.paused = false;
       } catch {
       }
       if (typeof params.weight === "number" && Number.isFinite(params.weight)) {
         action.setEffectiveWeight(params.weight);
+        next.weight = Math.max(0, params.weight);
         updated = true;
       }
       if (typeof params.rate === "number" && Number.isFinite(params.rate)) {
-        const signedRate = params.reverse ? -params.rate : params.rate;
+        next.playbackRate = Math.max(0, Math.abs(params.rate));
+        if (typeof params.reverse === "boolean") {
+          next.reverse = params.reverse;
+        }
+        const signedRate = next.reverse ? -next.playbackRate : next.playbackRate;
         action.setEffectiveTimeScale(signedRate);
         updated = true;
       }
       if (typeof params.loop === "boolean" || params.loopMode || params.repeatCount !== void 0) {
-        const mode = params.loopMode || (params.loop ? "repeat" : "once");
-        const reps = params.repeatCount ?? Infinity;
-        if (mode === "pingpong") {
-          action.setLoop(THREE.LoopPingPong, reps);
-        } else if (mode === "once") {
-          action.setLoop(THREE.LoopOnce, 1);
-        } else {
-          action.setLoop(THREE.LoopRepeat, reps);
-        }
+        next.loopMode = params.loopMode || (params.loop ? "repeat" : "once");
+        next.loop = next.loopMode !== "once";
+        next.repeatCount = params.repeatCount;
+        this.applyPlaybackState(action, next);
         updated = true;
       }
+      this.setPlaybackState(clipName, next);
     };
     for (const [clipName, action] of this.clipActions.entries()) {
       if (matches(clipName, action)) {
@@ -988,14 +1162,13 @@ var BakedAnimationController = class {
   }
   createAnimationHandle(clipName, action, finishedPromise) {
     return {
+      actionId: this.getActionId(action),
       stop: () => this.stopAnimation(clipName),
       pause: () => this.pauseAnimation(clipName),
       resume: () => this.resumeAnimation(clipName),
       setSpeed: (speed) => this.setAnimationSpeed(clipName, speed),
       setWeight: (weight) => this.setAnimationIntensity(clipName, weight),
-      seekTo: (time) => {
-        action.time = Math.max(0, Math.min(time, action.getClip().duration));
-      },
+      seekTo: (time) => this.seekAnimation(clipName, time),
       getState: () => this.getAnimationState(clipName),
       crossfadeTo: (targetClip, dur) => this.crossfadeTo(targetClip, dur),
       finished: finishedPromise
@@ -3619,12 +3792,6 @@ var _Loom3 = class _Loom3 {
     this.animation = animation || new AnimationThree();
     this.compositeRotations = this.config.compositeRotations || COMPOSITE_ROTATIONS;
     this.auToCompositeMap = buildAUToCompositeMap(this.compositeRotations);
-    this.hairPhysics = new HairPhysicsController({
-      getMeshByName: (name) => this.meshByName.get(name),
-      getSelectedHairMeshNames: () => this.config.morphToMesh?.hair || [],
-      buildClip: (clipName, curves, options) => this.buildClip(clipName, curves, options),
-      cleanupSnippet: (name) => this.cleanupSnippet(name)
-    });
     this.bakedAnimations = new BakedAnimationController({
       getModel: () => this.model,
       getMeshes: () => this.meshes,
@@ -3638,6 +3805,13 @@ var _Loom3 = class _Loom3 {
       getAUMixWeight: (auId) => this.getAUMixWeight(auId),
       isMixedAU: (auId) => this.isMixedAU(auId)
     });
+    this.hairPhysics = new HairPhysicsController({
+      getMeshByName: (name) => this.meshByName.get(name),
+      getSelectedHairMeshNames: () => this.config.morphToMesh?.hair || [],
+      // Hair physics needs clip construction, but mixer ownership still lives in BakedAnimationController.
+      buildClip: (clipName, curves, options) => this.bakedAnimations.buildClip(clipName, curves, options),
+      cleanupSnippet: (name) => this.bakedAnimations.cleanupSnippet(name)
+    });
     this.applyHairPhysicsProfileConfig();
   }
   // ============================================================================
@@ -4870,8 +5044,8 @@ var _Loom3 = class _Loom3 {
       }
     });
   }
-  // ===========wha=================================================================
-  // BAKED ANIMATION CONTROL (Three.js AnimationMixer)
+  // ============================================================================
+  // MIXER / CLIP CONTROL
   // ============================================================================
   loadAnimationClips(clips) {
     this.bakedAnimations.loadAnimationClips(clips);
@@ -4906,6 +5080,21 @@ var _Loom3 = class _Loom3 {
   setAnimationIntensity(clipName, intensity) {
     this.bakedAnimations.setAnimationIntensity(clipName, intensity);
   }
+  setAnimationLoopMode(clipName, loopMode) {
+    this.bakedAnimations.setAnimationLoopMode(clipName, loopMode);
+  }
+  setAnimationRepeatCount(clipName, repeatCount) {
+    this.bakedAnimations.setAnimationRepeatCount(clipName, repeatCount);
+  }
+  setAnimationReverse(clipName, reverse) {
+    this.bakedAnimations.setAnimationReverse(clipName, reverse);
+  }
+  setAnimationBlendMode(clipName, blendMode) {
+    this.bakedAnimations.setAnimationBlendMode(clipName, blendMode);
+  }
+  seekAnimation(clipName, time) {
+    this.bakedAnimations.seekAnimation(clipName, time);
+  }
   setAnimationTimeScale(timeScale) {
     this.bakedAnimations.setAnimationTimeScale(timeScale);
   }