@lovelace_lol/loom3 1.0.35 → 1.0.36

package/dist/index.cjs

@@ -79,6 +79,119 @@ function resolveCurveBalance(curveId, globalBalance, balanceMap) {
   }
   return clampBalance(globalBalance);
 }
+var RUNTIME_CLIP_PREFIX = "__loom3_baked_partition__/";
+var FACE_SAFE_TARGET_RE = /(head|neck|jaw|eye|brow|lid|mouth|lip|face|cheek|nose|tongue|teeth)/i;
+var BODY_LIKE_TARGET_RE = /(root|armature|hips?|pelvis|spine|waist|chest|torso|shoulder|arm|forearm|hand|finger|leg|thigh|calf|knee|foot|toe|tail|wing|fin|body|abdomen|clavicle)/i;
+var SCENE_LIKE_TARGET_RE = /(camera|cam|scene|world|global|origin|pivot|cube)/i;
+var CHANNEL_ORDER = ["face", "body", "scene"];
+function getRuntimeClipName(sourceClipName, channel) {
+  return `${RUNTIME_CLIP_PREFIX}${sourceClipName}/${channel}`;
+}
+function parseTrackTarget(trackName, model) {
+  let parsed;
+  try {
+    parsed = THREE.PropertyBinding.parseTrackName(trackName);
+  } catch {
+    return null;
+  }
+  const targetKey = parsed.objectName === "bones" && parsed.objectIndex ? String(parsed.objectIndex) : parsed.nodeName;
+  const target = targetKey ? model.getObjectByProperty("uuid", targetKey) ?? THREE.PropertyBinding.findNode(model, targetKey) : null;
+  return {
+    propertyName: parsed.propertyName,
+    target,
+    targetName: target?.name ?? parsed.nodeName ?? ""
+  };
+}
+function isSceneTrackTarget(target, targetName) {
+  if (!target) return true;
+  if (target.isCamera) return true;
+  return SCENE_LIKE_TARGET_RE.test(targetName);
+}
+function isFaceSafeTransformTarget(target, targetName, safeTransformTargets) {
+  if (target && safeTransformTargets.has(target)) {
+    return true;
+  }
+  if (!targetName) {
+    return false;
+  }
+  if (BODY_LIKE_TARGET_RE.test(targetName) || SCENE_LIKE_TARGET_RE.test(targetName)) {
+    return false;
+  }
+  return FACE_SAFE_TARGET_RE.test(targetName);
+}
+function classifyBakedTrack(track, model, bones) {
+  const parsed = parseTrackTarget(track.name, model);
+  if (!parsed) {
+    return "scene";
+  }
+  if (parsed.propertyName === "morphTargetInfluences" || parsed.propertyName === "weights") {
+    return "face";
+  }
+  if (isSceneTrackTarget(parsed.target, parsed.targetName)) {
+    return "scene";
+  }
+  if (parsed.propertyName === "quaternion") {
+    const safeTransformTargets = new Set(
+      Object.values(bones).map((entry) => entry?.obj).filter((entry) => !!entry)
+    );
+    if (isFaceSafeTransformTarget(parsed.target, parsed.targetName, safeTransformTargets)) {
+      return "face";
+    }
+  }
+  return "body";
+}
+function resolveBakedChannelBlendMode(channel, requestedBlendMode) {
+  if (channel === "face") {
+    return requestedBlendMode === "additive" ? "additive" : "replace";
+  }
+  if (channel === "body") {
+    return "replace";
+  }
+  return void 0;
+}
+function resolveBakedAggregateBlendMode(channels, requestedBlendMode) {
+  if (requestedBlendMode !== "additive") {
+    return "replace";
+  }
+  return channels.some((channel) => channel.channel === "face" && channel.playable && channel.trackCount > 0) ? "additive" : "replace";
+}
+function partitionBakedClip(clip, model, bones) {
+  const tracksByChannel = new Map(
+    CHANNEL_ORDER.map((channel) => [channel, []])
+  );
+  for (const track of clip.tracks) {
+    const channel = classifyBakedTrack(track, model, bones);
+    tracksByChannel.get(channel)?.push(track.clone());
+  }
+  const runtimeClips = [];
+  const channels = [];
+  for (const channel of CHANNEL_ORDER) {
+    const tracks = tracksByChannel.get(channel) ?? [];
+    if (tracks.length === 0) {
+      continue;
+    }
+    const playable = channel !== "scene";
+    const blendMode = resolveBakedChannelBlendMode(channel, "additive");
+    channels.push({
+      channel,
+      trackCount: tracks.length,
+      playable,
+      blendMode
+    });
+    if (!playable) {
+      continue;
+    }
+    runtimeClips.push({
+      channel,
+      clip: new THREE.AnimationClip(getRuntimeClipName(clip.name, channel), clip.duration, tracks)
+    });
+  }
+  return {
+    sourceClip: clip,
+    channels,
+    runtimeClips
+  };
+}
 
 // src/engines/three/AnimationThree.ts
 var easeInOutQuad = (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
@@ -184,6 +297,10 @@ var BakedAnimationController = class {
     __publicField(this, "animationMixer", null);
     __publicField(this, "mixerFinishedListenerAttached", false);
     __publicField(this, "animationClips", []);
+    __publicField(this, "bakedSourceClips", /* @__PURE__ */ new Map());
+    __publicField(this, "bakedRuntimeActions", /* @__PURE__ */ new Map());
+    __publicField(this, "bakedActionGroups", /* @__PURE__ */ new Map());
+    __publicField(this, "bakedRuntimeClipToSource", /* @__PURE__ */ new Map());
     __publicField(this, "animationActions", /* @__PURE__ */ new Map());
     __publicField(this, "animationFinishedCallbacks", /* @__PURE__ */ new Map());
     __publicField(this, "clipActions", /* @__PURE__ */ new Map());
@@ -212,6 +329,7 @@ var BakedAnimationController = class {
     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");
+    const requestedBlendMode = options?.blendMode ?? (clipOptions?.mixerAdditive ? "additive" : "replace");
     return {
       source: options?.source ?? defaults.source,
       loop: loopMode !== "once",
@@ -221,7 +339,8 @@ var BakedAnimationController = class {
       playbackRate,
       weight,
       balance: Number.isFinite(options?.balance) ? options?.balance ?? 0 : 0,
-      blendMode: options?.blendMode ?? (clipOptions?.mixerAdditive ? "additive" : "replace"),
+      requestedBlendMode,
+      blendMode: requestedBlendMode,
       easing: options?.easing ?? "linear"
     };
   }
@@ -281,15 +400,49 @@ var BakedAnimationController = class {
       next.balance = Math.max(-1, Math.min(1, options.balance));
     }
     if (options.blendMode) {
-      next.blendMode = options.blendMode;
+      next.requestedBlendMode = options.blendMode;
     } else if (typeof clipOptions?.mixerAdditive === "boolean") {
-      next.blendMode = clipOptions.mixerAdditive ? "additive" : "replace";
+      next.requestedBlendMode = clipOptions.mixerAdditive ? "additive" : "replace";
     }
+    next.blendMode = next.requestedBlendMode;
     if (options.easing) {
       next.easing = options.easing;
     }
     return next;
   }
+  isBakedSourceClip(clipName) {
+    return this.bakedSourceClips.has(clipName);
+  }
+  getBakedSourceClip(clipName) {
+    return this.bakedSourceClips.get(clipName);
+  }
+  getBakedChannelInfo(clipName, playbackState) {
+    const bakedClip = this.getBakedSourceClip(clipName);
+    if (!bakedClip) {
+      return void 0;
+    }
+    const requestedBlendMode = playbackState?.requestedBlendMode ?? "replace";
+    return bakedClip.channels.map((channel) => ({
+      ...channel,
+      blendMode: resolveBakedChannelBlendMode(channel.channel, requestedBlendMode)
+    }));
+  }
+  getBakedAggregateBlendMode(clipName, playbackState) {
+    const channels = this.getBakedChannelInfo(clipName, playbackState);
+    if (!channels) {
+      return playbackState?.requestedBlendMode ?? playbackState?.blendMode ?? "replace";
+    }
+    return resolveBakedAggregateBlendMode(
+      channels,
+      playbackState?.requestedBlendMode ?? "replace"
+    );
+  }
+  applyPlaybackStateToBakedAction(action, state, channel) {
+    this.applyPlaybackState(action, {
+      ...state,
+      blendMode: resolveBakedChannelBlendMode(channel, state.requestedBlendMode) ?? "replace"
+    });
+  }
   resolveStartTime(duration, state, explicitStartTime) {
     if (typeof explicitStartTime === "number" && Number.isFinite(explicitStartTime)) {
       return Math.max(0, Math.min(duration, explicitStartTime));
@@ -299,8 +452,13 @@ var BakedAnimationController = class {
     }
     return 0;
   }
-  getOrCreateBakedAction(clipName) {
-    const existing = this.animationActions.get(clipName);
+  getOrCreateBakedRuntimeAction(sourceClipName, channel) {
+    const bakedClip = this.getBakedSourceClip(sourceClipName);
+    const runtimeClip = bakedClip?.runtimeClips.find((entry) => entry.channel === channel)?.clip;
+    if (!runtimeClip) {
+      return null;
+    }
+    const existing = this.bakedRuntimeActions.get(runtimeClip.name);
     if (existing) {
       return existing;
     }
@@ -308,13 +466,44 @@ var BakedAnimationController = class {
     if (!this.animationMixer) {
       return null;
     }
-    const clip = this.animationClips.find((entry) => entry.name === clipName);
-    if (!clip || (this.clipSources.get(clipName) ?? "baked") !== "baked") {
+    const action = this.animationMixer.clipAction(runtimeClip);
+    this.bakedRuntimeActions.set(runtimeClip.name, action);
+    return action;
+  }
+  getRepresentativeBakedAction(clipName) {
+    const group = this.bakedActionGroups.get(clipName);
+    if (!group) {
       return null;
     }
-    const action = this.animationMixer.clipAction(clip);
-    this.animationActions.set(clipName, action);
-    return action;
+    return group.channelActions.values().next().value ?? null;
+  }
+  createBakedActionGroup(clipName, playbackState) {
+    const bakedClip = this.getBakedSourceClip(clipName);
+    if (!bakedClip) {
+      return null;
+    }
+    const channelActions = /* @__PURE__ */ new Map();
+    for (const runtimeClip of bakedClip.runtimeClips) {
+      const action = this.getOrCreateBakedRuntimeAction(clipName, runtimeClip.channel);
+      if (action) {
+        channelActions.set(runtimeClip.channel, action);
+      }
+    }
+    if (channelActions.size === 0) {
+      return null;
+    }
+    let resolveFinished = () => {
+    };
+    const finishedPromise = new Promise((resolve) => {
+      resolveFinished = resolve;
+    });
+    return {
+      actionId: makeActionId(),
+      channelActions,
+      pendingFinishedChannels: playbackState.loopMode === "once" ? new Set(channelActions.keys()) : /* @__PURE__ */ new Set(),
+      finishedPromise,
+      resolveFinished
+    };
   }
   getMeshNamesForAU(auId, config, explicitMeshNames) {
     if (explicitMeshNames && explicitMeshNames.length > 0) {
@@ -354,6 +543,10 @@ var BakedAnimationController = class {
       this.animationMixer = null;
     }
     this.animationClips = [];
+    this.bakedSourceClips.clear();
+    this.bakedRuntimeActions.clear();
+    this.bakedActionGroups.clear();
+    this.bakedRuntimeClipToSource.clear();
     this.animationActions.clear();
     this.animationFinishedCallbacks.clear();
     this.clipActions.clear();
@@ -362,17 +555,47 @@ var BakedAnimationController = class {
     this.playbackState.clear();
   }
   loadAnimationClips(clips) {
-    if (!this.host.getModel()) {
+    const model = this.host.getModel();
+    if (!model) {
       console.warn("Loom3: Cannot load animation clips before calling onReady()");
       return;
     }
+    for (const clipName of this.bakedSourceClips.keys()) {
+      this.stopAnimation(clipName);
+    }
+    if (this.animationMixer) {
+      for (const bakedClip of this.bakedSourceClips.values()) {
+        for (const runtimeClip of bakedClip.runtimeClips) {
+          try {
+            this.animationMixer.uncacheAction(runtimeClip.clip);
+          } catch {
+          }
+          try {
+            this.animationMixer.uncacheClip(runtimeClip.clip);
+          } catch {
+          }
+        }
+      }
+    }
+    for (const clipName of this.bakedSourceClips.keys()) {
+      this.playbackState.delete(clipName);
+      this.clipSources.delete(clipName);
+    }
+    this.bakedSourceClips.clear();
+    this.bakedRuntimeActions.clear();
+    this.bakedActionGroups.clear();
+    this.bakedRuntimeClipToSource.clear();
     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);
+    const partitionedClips = clips.map((clip) => partitionBakedClip(clip, model, this.host.getBones()));
+    this.animationClips = partitionedClips.map((clip) => clip.sourceClip);
+    for (const bakedClip of partitionedClips) {
+      this.bakedSourceClips.set(bakedClip.sourceClip.name, bakedClip);
+      this.clipSources.set(bakedClip.sourceClip.name, "baked");
+      for (const runtimeClip of bakedClip.runtimeClips) {
+        this.bakedRuntimeClipToSource.set(runtimeClip.clip.name, {
+          sourceClipName: bakedClip.sourceClip.name,
+          channel: runtimeClip.channel
+        });
       }
     }
   }
@@ -381,84 +604,91 @@ var BakedAnimationController = class {
       name: clip.name,
       duration: clip.duration,
       trackCount: clip.tracks.length,
-      source: this.clipSources.get(clip.name) ?? "baked"
+      source: this.clipSources.get(clip.name) ?? "baked",
+      channels: this.getBakedSourceClip(clip.name)?.channels
     }));
   }
   removeAnimationClip(clipName) {
-    const clip = this.animationClips.find((entry) => entry.name === clipName);
-    if (!clip || (this.clipSources.get(clipName) ?? "baked") !== "baked") {
+    const bakedClip = this.getBakedSourceClip(clipName);
+    if (!bakedClip) {
       return false;
     }
-    const relatedActions = /* @__PURE__ */ new Set();
-    const bakedAction = this.animationActions.get(clipName);
-    const clipAction = this.clipActions.get(clipName);
-    if (bakedAction) relatedActions.add(bakedAction);
-    if (clipAction) relatedActions.add(clipAction);
     this.stopAnimation(clipName);
     if (this.animationMixer) {
-      for (const action of relatedActions) {
+      for (const runtimeClip of bakedClip.runtimeClips) {
+        const action = this.bakedRuntimeActions.get(runtimeClip.clip.name);
         try {
-          this.animationMixer.uncacheAction(clip);
+          this.animationMixer.uncacheAction(runtimeClip.clip);
         } catch {
         }
         try {
-          this.animationMixer.uncacheClip(clip);
+          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) {
+        if (actionId && action) {
           this.actionIdToClip.delete(actionId);
+          this.actionIds.delete(action);
         }
-        this.actionIds.delete(action);
       }
     }
     this.animationClips = this.animationClips.filter((entry) => entry.name !== clipName);
-    this.animationActions.delete(clipName);
-    this.clipActions.delete(clipName);
-    this.clipHandles.delete(clipName);
-    this.animationFinishedCallbacks.delete(clipName);
+    this.bakedSourceClips.delete(clipName);
+    this.bakedActionGroups.delete(clipName);
     this.playbackState.delete(clipName);
     this.clipSources.delete(clipName);
     return true;
   }
   playAnimation(clipName, options = {}) {
-    const action = this.getOrCreateBakedAction(clipName);
-    if (!action) {
+    const bakedClip = this.getBakedSourceClip(clipName);
+    if (!bakedClip) {
       console.warn(`Loom3: Animation clip "${clipName}" not found`);
       return null;
     }
-    if (!this.getActionId(action)) {
-      this.setActionId(action, clipName);
-    }
     const playbackState = this.mergePlaybackOptions(
       this.getPlaybackStateSnapshot(clipName, { loop: true, source: "baked" }),
       options
     );
+    playbackState.blendMode = this.getBakedAggregateBlendMode(clipName, playbackState);
+    const actionGroup = this.createBakedActionGroup(clipName, playbackState);
+    if (!actionGroup) {
+      console.warn(`Loom3: Animation clip "${clipName}" has no character-runtime channels to play`);
+      return null;
+    }
     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();
+    const startTime = this.resolveStartTime(bakedClip.sourceClip.duration, playbackState, options.startTime);
+    for (const [channel, action] of actionGroup.channelActions) {
+      this.applyPlaybackStateToBakedAction(action, playbackState, channel);
+      action.clampWhenFinished = clampWhenFinished;
+      if (crossfadeDuration > 0) {
+        action.reset();
+        action.fadeIn(crossfadeDuration);
+      } else {
+        action.reset();
+      }
+      action.time = startTime;
+      action.play();
     }
-    action.time = startTime;
-    action.play();
-    this.animationActions.set(clipName, action);
+    this.bakedActionGroups.set(clipName, actionGroup);
     this.setPlaybackState(clipName, playbackState);
-    let resolveFinished;
-    const finishedPromise = new Promise((resolve) => {
-      resolveFinished = resolve;
-    });
-    if (playbackState.loopMode === "once") {
-      this.animationFinishedCallbacks.set(clipName, () => resolveFinished());
-    }
-    return this.createAnimationHandle(clipName, action, finishedPromise);
+    return this.createBakedAnimationHandle(clipName, actionGroup);
   }
   stopAnimation(clipName) {
+    const bakedGroup = this.bakedActionGroups.get(clipName);
+    if (bakedGroup) {
+      for (const action2 of bakedGroup.channelActions.values()) {
+        action2.stop();
+        try {
+          action2.paused = false;
+        } catch {
+        }
+      }
+      this.bakedActionGroups.delete(clipName);
+      return;
+    }
     const action = this.animationActions.get(clipName);
     if (action) {
       const isBaked = (this.clipSources.get(clipName) ?? "baked") === "baked";
@@ -506,6 +736,7 @@ var BakedAnimationController = class {
   }
   stopAllAnimations() {
     for (const clipName of /* @__PURE__ */ new Set([
+      ...this.bakedActionGroups.keys(),
       ...this.animationActions.keys(),
       ...this.clipActions.keys()
     ])) {
@@ -513,18 +744,39 @@ var BakedAnimationController = class {
     }
   }
   pauseAnimation(clipName) {
+    const bakedGroup = this.bakedActionGroups.get(clipName);
+    if (bakedGroup) {
+      for (const action2 of bakedGroup.channelActions.values()) {
+        action2.paused = true;
+      }
+      return;
+    }
     const action = this.animationActions.get(clipName);
     if (action) {
       action.paused = true;
     }
   }
   resumeAnimation(clipName) {
+    const bakedGroup = this.bakedActionGroups.get(clipName);
+    if (bakedGroup) {
+      for (const action2 of bakedGroup.channelActions.values()) {
+        action2.paused = false;
+      }
+      return;
+    }
     const action = this.animationActions.get(clipName);
     if (action) {
       action.paused = false;
     }
   }
   pauseAllAnimations() {
+    for (const group of this.bakedActionGroups.values()) {
+      for (const action of group.channelActions.values()) {
+        if (action.isRunning()) {
+          action.paused = true;
+        }
+      }
+    }
     for (const action of this.animationActions.values()) {
       if (action.isRunning()) {
         action.paused = true;
@@ -532,6 +784,13 @@ var BakedAnimationController = class {
     }
   }
   resumeAllAnimations() {
+    for (const group of this.bakedActionGroups.values()) {
+      for (const action of group.channelActions.values()) {
+        if (action.paused) {
+          action.paused = false;
+        }
+      }
+    }
     for (const action of this.animationActions.values()) {
       if (action.paused) {
         action.paused = false;
@@ -539,76 +798,161 @@ var BakedAnimationController = class {
     }
   }
   setAnimationSpeed(clipName, speed) {
-    const action = this.getOrCreateBakedAction(clipName);
-    if (action) {
+    if (this.isBakedSourceClip(clipName)) {
       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;
+      const bakedGroup = this.bakedActionGroups.get(clipName);
+      if (bakedGroup) {
+        for (const [channel, action2] of bakedGroup.channelActions) {
+          this.applyPlaybackStateToBakedAction(action2, next, channel);
+        }
+      }
+      this.setPlaybackState(clipName, next);
+      return;
+    }
+    const action = this.animationActions.get(clipName);
+    if (action) {
+      const next = this.getPlaybackStateSnapshot(clipName, {
+        loop: true,
+        source: this.clipSources.get(clipName) ?? "clip"
+      });
+      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.getOrCreateBakedAction(clipName);
-    if (action) {
+    if (this.isBakedSourceClip(clipName)) {
       const next = this.getPlaybackStateSnapshot(clipName, {
         loop: true,
         source: this.clipSources.get(clipName) ?? "baked"
       });
       next.weight = Number.isFinite(intensity) ? Math.max(0, intensity) : 1;
+      const bakedGroup = this.bakedActionGroups.get(clipName);
+      if (bakedGroup) {
+        for (const [channel, action2] of bakedGroup.channelActions) {
+          this.applyPlaybackStateToBakedAction(action2, next, channel);
+        }
+      }
+      this.setPlaybackState(clipName, next);
+      return;
+    }
+    const action = this.animationActions.get(clipName);
+    if (action) {
+      const next = this.getPlaybackStateSnapshot(clipName, {
+        loop: true,
+        source: this.clipSources.get(clipName) ?? "clip"
+      });
+      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"
+      source: this.clipSources.get(clipName) ?? (this.isBakedSourceClip(clipName) ? "baked" : "clip")
     });
     next.loopMode = loopMode;
     next.loop = loopMode !== "once";
+    if (this.isBakedSourceClip(clipName)) {
+      const bakedGroup = this.bakedActionGroups.get(clipName);
+      if (bakedGroup) {
+        for (const [channel, action2] of bakedGroup.channelActions) {
+          this.applyPlaybackStateToBakedAction(action2, next, channel);
+        }
+      }
+      this.setPlaybackState(clipName, next);
+      return;
+    }
+    const action = this.animationActions.get(clipName);
+    if (!action) return;
     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"
+      source: this.clipSources.get(clipName) ?? (this.isBakedSourceClip(clipName) ? "baked" : "clip")
     });
     next.repeatCount = typeof repeatCount === "number" && Number.isFinite(repeatCount) ? Math.max(0, repeatCount) : void 0;
+    if (this.isBakedSourceClip(clipName)) {
+      const bakedGroup = this.bakedActionGroups.get(clipName);
+      if (bakedGroup) {
+        for (const [channel, action2] of bakedGroup.channelActions) {
+          this.applyPlaybackStateToBakedAction(action2, next, channel);
+        }
+      }
+      this.setPlaybackState(clipName, next);
+      return;
+    }
+    const action = this.animationActions.get(clipName);
+    if (!action) return;
     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"
+      source: this.clipSources.get(clipName) ?? (this.isBakedSourceClip(clipName) ? "baked" : "clip")
     });
     next.reverse = !!reverse;
+    if (this.isBakedSourceClip(clipName)) {
+      const bakedGroup = this.bakedActionGroups.get(clipName);
+      if (bakedGroup) {
+        for (const [channel, action2] of bakedGroup.channelActions) {
+          this.applyPlaybackStateToBakedAction(action2, next, channel);
+        }
+      }
+      this.setPlaybackState(clipName, next);
+      return;
+    }
+    const action = this.animationActions.get(clipName);
+    if (!action) return;
     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"
+      source: this.clipSources.get(clipName) ?? (this.isBakedSourceClip(clipName) ? "baked" : "clip")
     });
+    next.requestedBlendMode = blendMode;
+    if (this.isBakedSourceClip(clipName)) {
+      next.blendMode = this.getBakedAggregateBlendMode(clipName, next);
+      const bakedGroup = this.bakedActionGroups.get(clipName);
+      if (bakedGroup) {
+        for (const [channel, action2] of bakedGroup.channelActions) {
+          this.applyPlaybackStateToBakedAction(action2, next, channel);
+        }
+      }
+      this.setPlaybackState(clipName, next);
+      return;
+    }
     next.blendMode = blendMode;
+    const action = this.animationActions.get(clipName);
+    if (!action) return;
     this.applyPlaybackState(action, next);
     this.setPlaybackState(clipName, next);
   }
   seekAnimation(clipName, time) {
-    const action = this.getOrCreateBakedAction(clipName) ?? this.animationActions.get(clipName);
+    const bakedGroup = this.bakedActionGroups.get(clipName);
+    if (bakedGroup) {
+      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()) {
+        action2.time = clamped;
+      }
+      try {
+        this.animationMixer?.update(0);
+      } catch {
+      }
+      return;
+    }
+    const action = 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));
@@ -623,6 +967,40 @@ var BakedAnimationController = class {
     }
   }
   getAnimationState(clipName) {
+    const bakedClip = this.getBakedSourceClip(clipName);
+    if (bakedClip) {
+      const state2 = this.playbackState.get(clipName);
+      const action2 = this.getRepresentativeBakedAction(clipName);
+      if (!state2 && !action2) {
+        return null;
+      }
+      const loopMode2 = state2?.loopMode ?? (action2?.loop === THREE.LoopPingPong ? "pingpong" : action2?.loop === THREE.LoopOnce ? "once" : "repeat");
+      const playbackRate2 = state2?.playbackRate ?? Math.abs(action2?.getEffectiveTimeScale?.() ?? 1);
+      const reverse2 = state2?.reverse ?? (action2?.getEffectiveTimeScale?.() ?? 1) < 0;
+      const pausedValues = this.bakedActionGroups.get(clipName) ? Array.from(this.bakedActionGroups.get(clipName).channelActions.values()).map((entry) => entry.paused) : [];
+      return {
+        name: bakedClip.sourceClip.name,
+        actionId: this.bakedActionGroups.get(clipName)?.actionId,
+        source: state2?.source ?? this.clipSources.get(clipName) ?? "baked",
+        isPlaying: this.bakedActionGroups.get(clipName) ? Array.from(this.bakedActionGroups.get(clipName).channelActions.values()).some((entry) => entry.isRunning() && !entry.paused) : false,
+        isPaused: pausedValues.length > 0 ? pausedValues.every(Boolean) : false,
+        time: action2?.time ?? 0,
+        duration: bakedClip.sourceClip.duration,
+        speed: playbackRate2,
+        playbackRate: playbackRate2,
+        reverse: reverse2,
+        weight: state2?.weight ?? action2?.getEffectiveWeight?.() ?? 1,
+        balance: state2?.balance ?? 0,
+        requestedBlendMode: state2?.requestedBlendMode ?? "replace",
+        blendMode: this.getBakedAggregateBlendMode(clipName, state2),
+        channels: this.getBakedChannelInfo(clipName, state2),
+        easing: state2?.easing ?? "linear",
+        loop: loopMode2 !== "once",
+        loopMode: loopMode2,
+        repeatCount: state2?.repeatCount,
+        isLooping: loopMode2 !== "once"
+      };
+    }
     const action = this.animationActions.get(clipName);
     if (!action) return null;
     const clip = action.getClip();
@@ -643,7 +1021,9 @@ var BakedAnimationController = class {
       reverse,
       weight: state?.weight ?? action.getEffectiveWeight(),
       balance: state?.balance ?? 0,
+      requestedBlendMode: state?.requestedBlendMode ?? state?.blendMode ?? "replace",
       blendMode: state?.blendMode ?? "replace",
+      channels: state?.source === "baked" ? this.getBakedChannelInfo(clipName, state) : void 0,
       easing: state?.easing ?? "linear",
       loop: loopMode !== "once",
       loopMode,
@@ -653,6 +1033,12 @@ var BakedAnimationController = class {
   }
   getPlayingAnimations() {
     const playing = [];
+    for (const name of this.bakedActionGroups.keys()) {
+      const state = this.getAnimationState(name);
+      if (state?.isPlaying) {
+        playing.push(state);
+      }
+    }
     for (const [name, action] of this.animationActions) {
       if (action.isRunning()) {
         const state = this.getAnimationState(name);
@@ -662,6 +1048,13 @@ var BakedAnimationController = class {
     return playing;
   }
   crossfadeTo(clipName, duration = 0.3, options = {}) {
+    for (const group of this.bakedActionGroups.values()) {
+      for (const action of group.channelActions.values()) {
+        if (action.isRunning()) {
+          action.fadeOut(duration);
+        }
+      }
+    }
     for (const action of this.animationActions.values()) {
       if (action.isRunning()) {
         action.fadeOut(duration);
@@ -1187,6 +1580,14 @@ var BakedAnimationController = class {
       this.animationMixer.addEventListener("finished", (event) => {
         const action = event.action;
         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();
@@ -1211,6 +1612,20 @@ var BakedAnimationController = class {
       finished: finishedPromise
     };
   }
+  createBakedAnimationHandle(clipName, group) {
+    return {
+      actionId: group.actionId,
+      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) => this.seekAnimation(clipName, time),
+      getState: () => this.getAnimationState(clipName),
+      crossfadeTo: (targetClip, dur) => this.crossfadeTo(targetClip, dur),
+      finished: group.finishedPromise
+    };
+  }
 };
 
 // src/presets/cc4.ts