@lovelace_lol/loom3 1.0.35 → 1.0.37

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;
@@ -178,12 +291,18 @@ var makeActionId = () => `act_${Math.random().toString(36).slice(2, 8)}_${Date.n
 var X_AXIS = new THREE.Vector3(1, 0, 0);
 var Y_AXIS = new THREE.Vector3(0, 1, 0);
 var Z_AXIS = new THREE.Vector3(0, 0, 1);
+var CLIP_EVENT_METADATA_KEY = "__loom3ClipEvents";
+var CLIP_EVENT_EPSILON = 1e-4;
 var BakedAnimationController = class {
   constructor(host) {
     __publicField(this, "host");
     __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());
@@ -192,6 +311,7 @@ var BakedAnimationController = class {
     __publicField(this, "playbackState", /* @__PURE__ */ new Map());
     __publicField(this, "actionIds", /* @__PURE__ */ new WeakMap());
     __publicField(this, "actionIdToClip", /* @__PURE__ */ new Map());
+    __publicField(this, "clipMonitors", /* @__PURE__ */ new Map());
     this.host = host;
   }
   getActionId(action) {
@@ -205,6 +325,161 @@ var BakedAnimationController = class {
     action.__actionId = actionId;
     return actionId;
   }
+  setClipEventMetadata(clip, metadata) {
+    const userData = clip.userData ?? (clip.userData = {});
+    userData[CLIP_EVENT_METADATA_KEY] = metadata;
+  }
+  getClipEventMetadata(clip) {
+    const userData = clip.userData;
+    const keyframeTimes = Array.isArray(userData?.[CLIP_EVENT_METADATA_KEY]?.keyframeTimes) ? userData[CLIP_EVENT_METADATA_KEY].keyframeTimes.filter((time) => Number.isFinite(time)) : [];
+    return { keyframeTimes };
+  }
+  getKeyframeIndex(times, currentTime) {
+    if (!times.length) return -1;
+    const target = Math.max(0, currentTime) + 1e-3;
+    let lo = 0;
+    let hi = times.length - 1;
+    let idx = 0;
+    while (lo <= hi) {
+      const mid = lo + hi >>> 1;
+      if (times[mid] <= target) {
+        idx = mid;
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return idx;
+  }
+  emitClipEvent(monitor, event) {
+    for (const listener of Array.from(monitor.listeners)) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error("[Loom3] clip event listener failed", error);
+      }
+    }
+  }
+  emitKeyframesForRange(monitor, startTime, endTime, direction, includeStart) {
+    if (!monitor.keyframeTimes.length) return;
+    const times = direction === 1 ? monitor.keyframeTimes : [...monitor.keyframeTimes].reverse();
+    for (const time of times) {
+      const matchesForward = direction === 1 && (includeStart ? time >= startTime - CLIP_EVENT_EPSILON : time > startTime + CLIP_EVENT_EPSILON) && time <= endTime + CLIP_EVENT_EPSILON;
+      const matchesReverse = direction === -1 && (includeStart ? time <= startTime + CLIP_EVENT_EPSILON : time < startTime - CLIP_EVENT_EPSILON) && time >= endTime - CLIP_EVENT_EPSILON;
+      if (!matchesForward && !matchesReverse) continue;
+      const keyframeIndex = monitor.keyframeTimes.indexOf(time);
+      monitor.lastKeyframeIndex = keyframeIndex;
+      this.emitClipEvent(monitor, {
+        type: "keyframe",
+        clipName: monitor.clipName,
+        keyframeIndex,
+        totalKeyframes: monitor.keyframeTimes.length,
+        currentTime: time,
+        duration: monitor.duration,
+        iteration: monitor.iteration
+      });
+    }
+  }
+  resetClipMonitor(monitor, currentTime) {
+    monitor.iteration = 0;
+    monitor.direction = monitor.initialDirection;
+    monitor.lastTime = currentTime;
+    monitor.lastKeyframeIndex = this.getKeyframeIndex(monitor.keyframeTimes, currentTime);
+    monitor.finishedPending = false;
+  }
+  syncClipMonitorTime(monitor, currentTime, emitSeek = false) {
+    const clamped = Math.max(0, Math.min(monitor.duration, currentTime));
+    monitor.lastTime = clamped;
+    monitor.lastKeyframeIndex = this.getKeyframeIndex(monitor.keyframeTimes, clamped);
+    if (emitSeek) {
+      this.emitClipEvent(monitor, {
+        type: "seek",
+        clipName: monitor.clipName,
+        currentTime: clamped,
+        duration: monitor.duration,
+        iteration: monitor.iteration
+      });
+    }
+  }
+  cleanupClipMonitor(actionId) {
+    const monitor = this.clipMonitors.get(actionId);
+    if (!monitor || monitor.cleanedUp) return;
+    monitor.cleanedUp = true;
+    try {
+      monitor.action.paused = true;
+    } catch {
+    }
+    monitor.resolveFinished();
+    monitor.listeners.clear();
+    this.clipMonitors.delete(actionId);
+    this.actionIdToClip.delete(actionId);
+  }
+  advanceClipMonitor(monitor, previousTime) {
+    if (monitor.cleanedUp || monitor.action.paused && !monitor.finishedPending) return;
+    const currentTime = Math.max(0, Math.min(monitor.duration, monitor.action.time));
+    const delta = currentTime - previousTime;
+    if (monitor.loopMode === "pingpong") {
+      const movingForward = monitor.direction === 1;
+      const bouncedAtEnd = movingForward && delta < -CLIP_EVENT_EPSILON;
+      const bouncedAtStart = !movingForward && delta > CLIP_EVENT_EPSILON;
+      if (bouncedAtEnd) {
+        this.emitKeyframesForRange(monitor, previousTime, monitor.duration, 1, false);
+        monitor.direction = -1;
+        this.emitKeyframesForRange(monitor, monitor.duration, currentTime, -1, false);
+      } else if (bouncedAtStart) {
+        this.emitKeyframesForRange(monitor, previousTime, 0, -1, false);
+        monitor.direction = 1;
+        monitor.iteration += 1;
+        this.emitClipEvent(monitor, {
+          type: "loop",
+          clipName: monitor.clipName,
+          iteration: monitor.iteration,
+          currentTime: 0,
+          duration: monitor.duration
+        });
+        this.emitKeyframesForRange(monitor, 0, currentTime, 1, false);
+      } else if (delta > CLIP_EVENT_EPSILON) {
+        this.emitKeyframesForRange(monitor, previousTime, currentTime, 1, false);
+        monitor.direction = 1;
+      } else if (delta < -CLIP_EVENT_EPSILON) {
+        this.emitKeyframesForRange(monitor, previousTime, currentTime, -1, false);
+        monitor.direction = -1;
+      }
+    } else if (monitor.direction === 1) {
+      const wrapped = currentTime + CLIP_EVENT_EPSILON < previousTime;
+      if (wrapped) {
+        this.emitKeyframesForRange(monitor, previousTime, monitor.duration, 1, false);
+        monitor.iteration += 1;
+        this.emitClipEvent(monitor, {
+          type: "loop",
+          clipName: monitor.clipName,
+          iteration: monitor.iteration,
+          currentTime: 0,
+          duration: monitor.duration
+        });
+        this.emitKeyframesForRange(monitor, 0, currentTime, 1, true);
+      } else if (delta > CLIP_EVENT_EPSILON) {
+        this.emitKeyframesForRange(monitor, previousTime, currentTime, 1, false);
+      }
+    } else {
+      const wrapped = currentTime > previousTime + CLIP_EVENT_EPSILON;
+      if (wrapped) {
+        this.emitKeyframesForRange(monitor, previousTime, 0, -1, false);
+        monitor.iteration += 1;
+        this.emitClipEvent(monitor, {
+          type: "loop",
+          clipName: monitor.clipName,
+          iteration: monitor.iteration,
+          currentTime: monitor.duration,
+          duration: monitor.duration
+        });
+        this.emitKeyframesForRange(monitor, monitor.duration, currentTime, -1, true);
+      } else if (delta < -CLIP_EVENT_EPSILON) {
+        this.emitKeyframesForRange(monitor, previousTime, currentTime, -1, false);
+      }
+    }
+    this.syncClipMonitorTime(monitor, currentTime);
+  }
   normalizePlaybackOptions(options, defaults) {
     const clipOptions = options;
     const rawRate = options?.playbackRate ?? options?.speed ?? 1;
@@ -212,6 +487,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 +497,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 +558,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 +610,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 +624,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) {
@@ -344,7 +691,28 @@ var BakedAnimationController = class {
   }
   update(dtSeconds) {
     if (this.animationMixer) {
+      const snapshots = Array.from(this.clipMonitors.values()).map((monitor) => ({
+        actionId: monitor.actionId,
+        previousTime: monitor.action.time
+      }));
       this.animationMixer.update(dtSeconds);
+      for (const { actionId, previousTime } of snapshots) {
+        const monitor = this.clipMonitors.get(actionId);
+        if (!monitor) continue;
+        this.advanceClipMonitor(monitor, previousTime);
+        if (monitor.finishedPending) {
+          const finalTime = Math.max(0, Math.min(monitor.duration, monitor.action.time));
+          this.syncClipMonitorTime(monitor, finalTime);
+          this.emitClipEvent(monitor, {
+            type: "completed",
+            clipName: monitor.clipName,
+            currentTime: finalTime,
+            duration: monitor.duration,
+            iteration: monitor.iteration
+          });
+          this.cleanupClipMonitor(actionId);
+        }
+      }
     }
   }
   dispose() {
@@ -354,25 +722,60 @@ 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();
     this.clipHandles.clear();
     this.clipSources.clear();
     this.playbackState.clear();
+    this.clipMonitors.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,86 +784,94 @@ 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 actionId = this.getActionId(action);
       const isBaked = (this.clipSources.get(clipName) ?? "baked") === "baked";
       action.stop();
       if (!isBaked && this.animationMixer) {
@@ -483,9 +894,11 @@ var BakedAnimationController = class {
         }
       }
       this.animationFinishedCallbacks.delete(clipName);
+      if (actionId) this.cleanupClipMonitor(actionId);
     }
     const clipAction = this.clipActions.get(clipName);
     if (clipAction && clipAction !== action) {
+      const actionId = this.getActionId(clipAction);
       try {
         clipAction.stop();
         if (this.animationMixer) {
@@ -498,6 +911,7 @@ var BakedAnimationController = class {
       } catch {
       }
       this.clipActions.delete(clipName);
+      if (actionId) this.cleanupClipMonitor(actionId);
     }
     if (this.clipActions.get(clipName) === action) {
       this.clipActions.delete(clipName);
@@ -506,6 +920,7 @@ var BakedAnimationController = class {
   }
   stopAllAnimations() {
     for (const clipName of /* @__PURE__ */ new Set([
+      ...this.bakedActionGroups.keys(),
       ...this.animationActions.keys(),
       ...this.clipActions.keys()
     ])) {
@@ -513,18 +928,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 +968,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 +982,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 +1151,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 +1205,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 +1217,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 +1232,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);
@@ -896,6 +1473,7 @@ var BakedAnimationController = class {
       return null;
     }
     const clip = new THREE.AnimationClip(clipName, maxTime, tracks);
+    this.setClipEventMetadata(clip, { keyframeTimes });
     console.log(`[Loom3] snippetToClip: Created clip "${clipName}" with ${tracks.length} tracks, duration ${maxTime.toFixed(2)}s`);
     return clip;
   }
@@ -927,28 +1505,38 @@ var BakedAnimationController = class {
       this.animationClips.push(clip);
     }
     this.applyPlaybackState(action, playbackState);
+    if (actionId) {
+      this.cleanupClipMonitor(actionId);
+    }
     let resolveFinished;
     const finishedPromise = new Promise((resolve) => {
       resolveFinished = resolve;
     });
-    const cleanup = () => {
-      try {
-        this.animationFinishedCallbacks.delete(clip.name);
-      } catch {
-      }
-      try {
-        action.paused = true;
-      } catch {
-      }
+    const keyframeTimes = this.getClipEventMetadata(clip).keyframeTimes;
+    const initialDirection = playbackState.reverse ? -1 : 1;
+    const monitor = {
+      action,
+      actionId,
+      clip,
+      clipName: clip.name,
+      duration: clip.duration,
+      keyframeTimes,
+      listeners: /* @__PURE__ */ new Set(),
+      initialDirection,
+      direction: initialDirection,
+      iteration: 0,
+      lastTime: Math.max(0, Math.min(clip.duration, action.time)),
+      lastKeyframeIndex: this.getKeyframeIndex(keyframeTimes, action.time),
+      loopMode: playbackState.loopMode,
+      finishedPending: false,
+      cleanedUp: false,
+      resolveFinished
     };
-    this.animationFinishedCallbacks.set(clip.name, () => {
-      resolveFinished();
-      cleanup();
-    });
-    finishedPromise.catch(() => cleanup());
+    this.clipMonitors.set(actionId, monitor);
     action.reset();
     action.time = startTime;
     action.play();
+    this.resetClipMonitor(monitor, action.time);
     this.clipActions.set(clip.name, action);
     this.animationActions.set(clip.name, action);
     this.setPlaybackState(clip.name, playbackState);
@@ -966,6 +1554,7 @@ var BakedAnimationController = class {
           })
         );
         action.play();
+        this.resetClipMonitor(monitor, action.time);
       },
       stop: () => {
         action.stop();
@@ -983,8 +1572,7 @@ var BakedAnimationController = class {
         this.animationActions.delete(clip.name);
         this.animationFinishedCallbacks.delete(clip.name);
         this.playbackState.delete(clip.name);
-        resolveFinished();
-        cleanup();
+        this.cleanupClipMonitor(actionId);
       },
       pause: () => {
         action.paused = true;
@@ -1002,6 +1590,8 @@ var BakedAnimationController = class {
         const next = this.playbackState.get(clip.name) ?? playbackState;
         next.playbackRate = Number.isFinite(r) ? Math.max(0, Math.abs(r)) : 1;
         this.applyPlaybackState(action, next);
+        monitor.direction = next.reverse ? -1 : 1;
+        monitor.initialDirection = monitor.direction;
         this.setPlaybackState(clip.name, next);
       },
       setLoop: (mode, repeatCount) => {
@@ -1010,6 +1600,7 @@ var BakedAnimationController = class {
         next.loop = mode !== "once";
         next.repeatCount = repeatCount;
         this.applyPlaybackState(action, next);
+        monitor.loopMode = mode;
         this.setPlaybackState(clip.name, next);
       },
       setTime: (t) => {
@@ -1019,9 +1610,16 @@ var BakedAnimationController = class {
           this.animationMixer?.update(0);
         } catch {
         }
+        this.syncClipMonitorTime(monitor, clamped, true);
       },
       getTime: () => action.time,
       getDuration: () => clip.duration,
+      subscribe: (listener) => {
+        monitor.listeners.add(listener);
+        return () => {
+          monitor.listeners.delete(listener);
+        };
+      },
       finished: finishedPromise
     };
     this.clipHandles.set(clip.name, handle);
@@ -1045,6 +1643,7 @@ var BakedAnimationController = class {
     if (!this.animationMixer || !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();
@@ -1059,6 +1658,7 @@ var BakedAnimationController = class {
         this.clipHandles.delete(clipName);
         this.animationFinishedCallbacks.delete(clipName);
         this.playbackState.delete(clipName);
+        if (actionId) this.cleanupClipMonitor(actionId);
       }
     }
   }
@@ -1082,6 +1682,8 @@ var BakedAnimationController = class {
     console.log("[Loom3] updateClipParams start", debugSnapshot());
     const apply = (action) => {
       if (!action) return;
+      const actionId = this.getActionId(action);
+      const monitor = actionId ? this.clipMonitors.get(actionId) : void 0;
       const clipName = action.getClip().name;
       const next = this.playbackState.get(clipName) ?? this.normalizePlaybackOptions(void 0, { loop: false, source: this.clipSources.get(clipName) ?? "clip" });
       try {
@@ -1100,6 +1702,10 @@ var BakedAnimationController = class {
         }
         const signedRate = next.reverse ? -next.playbackRate : next.playbackRate;
         action.setEffectiveTimeScale(signedRate);
+        if (monitor) {
+          monitor.direction = next.reverse ? -1 : 1;
+          monitor.initialDirection = monitor.direction;
+        }
         updated = true;
       }
       if (typeof params.loop === "boolean" || params.loopMode || params.repeatCount !== void 0) {
@@ -1107,6 +1713,7 @@ var BakedAnimationController = class {
         next.loop = next.loopMode !== "once";
         next.repeatCount = params.repeatCount;
         this.applyPlaybackState(action, next);
+        if (monitor) monitor.loopMode = next.loopMode;
         updated = true;
       }
       this.setPlaybackState(clipName, next);
@@ -1186,7 +1793,23 @@ var BakedAnimationController = class {
     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();
@@ -1211,6 +1834,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
@@ -3870,9 +4507,11 @@ function getPreset(presetType) {
       return CC4_PRESET;
   }
 }
+var resolvePreset = getPreset;
 function getPresetWithProfile(presetType, profile) {
   return extendPresetWithProfile(getPreset(presetType), profile);
 }
+var resolvePresetWithOverrides = getPresetWithProfile;
 
 // src/engines/three/Loom3.ts
 var deg2rad = (d) => d * Math.PI / 180;
@@ -7028,6 +7667,8 @@ exports.mergeCharacterRegionsByName = mergeRegionsByName;
 exports.resolveBoneName = resolveBoneName;
 exports.resolveBoneNames = resolveBoneNames;
 exports.resolveFaceCenter = resolveFaceCenter;
+exports.resolvePreset = resolvePreset;
+exports.resolvePresetWithOverrides = resolvePresetWithOverrides;
 exports.suggestBestPreset = suggestBestPreset;
 exports.validateMappingConfig = validateMappingConfig;
 exports.validateMappings = validateMappings;