@lovelace_lol/loom3 1.0.34 → 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
@@ -3937,7 +4352,8 @@ var _Loom3 = class _Loom3 {
     __publicField(this, "bones", {});
     __publicField(this, "mixWeights", {});
     // Viseme state
-    __publicField(this, "visemeValues", new Array(15).fill(0));
+    __publicField(this, "visemeValues", []);
+    __publicField(this, "visemeJawScales", []);
     __publicField(this, "bakedAnimations");
     __publicField(this, "hairPhysics");
     // Internal animation loop
@@ -3950,6 +4366,7 @@ var _Loom3 = class _Loom3 {
     const basePreset = config.presetType ? getPreset(config.presetType) : CC4_PRESET;
     this.config = extendPresetWithProfile(basePreset, config.profile);
     this.mixWeights = { ...this.config.auMixDefaults };
+    this.syncVisemeRuntimeState();
     this.animation = animation || new AnimationThree();
     this.compositeRotations = this.config.compositeRotations || COMPOSITE_ROTATIONS;
     this.auToCompositeMap = buildAUToCompositeMap(this.compositeRotations);
@@ -4482,6 +4899,7 @@ var _Loom3 = class _Loom3 {
     if (visemeIndex < 0 || visemeIndex >= this.config.visemeKeys.length) return;
     const val = clamp012(value);
     this.visemeValues[visemeIndex] = val;
+    this.visemeJawScales[visemeIndex] = jawScale;
     const targets = this.resolvedVisemeTargets[visemeIndex];
     if (targets && targets.length > 0) {
       this.applyMorphTargets(targets, val);
@@ -4494,7 +4912,7 @@ var _Loom3 = class _Loom3 {
         this.setMorph(morphKey, val, visemeMeshNames);
       }
     }
-    const jawAmount = _Loom3.VISEME_JAW_AMOUNTS[visemeIndex] * val * jawScale;
+    const jawAmount = this.getVisemeJawAmount(visemeIndex) * val * jawScale;
     if (Math.abs(jawScale) > 1e-6 && Math.abs(jawAmount) > 1e-6) {
       this.updateBoneRotation("JAW", "pitch", jawAmount);
     }
@@ -4509,9 +4927,10 @@ var _Loom3 = class _Loom3 {
     const morphKey = this.config.visemeKeys[visemeIndex];
     const target = clamp012(to);
     this.visemeValues[visemeIndex] = target;
+    this.visemeJawScales[visemeIndex] = jawScale;
     const visemeMeshNames = this.getMeshNamesForViseme();
     const morphHandle = typeof morphKey === "number" ? this.transitionMorphInfluence(morphKey, target, durationMs, visemeMeshNames) : this.transitionMorph(morphKey, target, durationMs, visemeMeshNames);
-    const jawAmount = _Loom3.VISEME_JAW_AMOUNTS[visemeIndex] * target * jawScale;
+    const jawAmount = this.getVisemeJawAmount(visemeIndex) * target * jawScale;
     if (Math.abs(jawScale) <= 1e-6 || Math.abs(jawAmount) <= 1e-6) {
       return morphHandle;
     }
@@ -4565,6 +4984,9 @@ var _Loom3 = class _Loom3 {
   }
   resetToNeutral() {
     this.auValues = {};
+    this.visemeValues = new Array(this.config.visemeKeys.length).fill(0);
+    this.visemeJawScales = new Array(this.config.visemeKeys.length).fill(1);
+    this.translations = {};
     this.initBoneRotations();
     this.clearTransitions();
     for (const m of this.meshes) {
@@ -4580,6 +5002,33 @@ var _Loom3 = class _Loom3 {
       entry.obj.quaternion.copy(entry.baseQuat);
     });
   }
+  reinitializeRuntimeStateFromCurrentControls(staleMorphTargets = []) {
+    this.clearTransitions();
+    this.resetMorphTargetHandles(staleMorphTargets);
+    this.translations = {};
+    this.initBoneRotations();
+    Object.values(this.bones).forEach((entry) => {
+      if (!entry) return;
+      entry.obj.position.copy(entry.basePos);
+      entry.obj.quaternion.copy(entry.baseQuat);
+      entry.obj.updateMatrixWorld(false);
+    });
+    for (const [auIdStr, value] of Object.entries(this.auValues)) {
+      if (value <= 0) continue;
+      const auId = Number(auIdStr);
+      if (Number.isNaN(auId)) continue;
+      this.setAU(auId, value, this.auBalances[auId]);
+    }
+    for (let visemeIndex = 0; visemeIndex < this.visemeValues.length; visemeIndex += 1) {
+      const value = this.visemeValues[visemeIndex] ?? 0;
+      if (value <= 0) continue;
+      this.setViseme(visemeIndex, value, this.visemeJawScales[visemeIndex] ?? 1);
+    }
+    if (this.model) {
+      this.flushPendingComposites();
+      this.model.updateMatrixWorld(true);
+    }
+  }
   // ============================================================================
   // MESH CONTROL
   // ============================================================================
@@ -4810,12 +5259,20 @@ var _Loom3 = class _Loom3 {
   }
   setProfile(profile) {
     this.config = profile;
+    this.compositeRotations = this.config.compositeRotations || COMPOSITE_ROTATIONS;
+    this.auToCompositeMap = buildAUToCompositeMap(this.compositeRotations);
     this.mixWeights = { ...profile.auMixDefaults };
+    this.syncVisemeRuntimeState();
+    let staleMorphTargets = [];
     if (this.model) {
+      staleMorphTargets = this.collectResolvedExpressionMorphTargets();
+      this.bones = this.resolveBones(this.model);
+      this.missingBoneWarnings.clear();
       this.rebuildMorphTargetsCache();
     }
     this.hairPhysics.refreshMeshSelection();
     this.applyHairPhysicsProfileConfig();
+    this.reinitializeRuntimeStateFromCurrentControls(staleMorphTargets);
   }
   getProfile() {
     return this.config;
@@ -4953,6 +5410,39 @@ var _Loom3 = class _Loom3 {
   getMorphIndexCacheKey(index, meshNames) {
     return meshNames?.length ? `idx:${index}@${meshNames.join(",")}` : `idx:${index}`;
   }
+  syncVisemeRuntimeState() {
+    const visemeCount = this.config.visemeKeys.length;
+    this.visemeValues = Array.from(
+      { length: visemeCount },
+      (_, index) => this.visemeValues[index] ?? 0
+    );
+    this.visemeJawScales = Array.from(
+      { length: visemeCount },
+      (_, index) => this.visemeJawScales[index] ?? 1
+    );
+  }
+  getVisemeJawAmount(visemeIndex) {
+    return this.config.visemeJawAmounts?.[visemeIndex] ?? _Loom3.VISEME_JAW_AMOUNTS[visemeIndex] ?? 0;
+  }
+  collectResolvedExpressionMorphTargets() {
+    const targets = [];
+    for (const resolved of this.resolvedAUMorphTargets.values()) {
+      targets.push(...resolved.left, ...resolved.right, ...resolved.center);
+    }
+    for (const resolved of this.resolvedVisemeTargets) {
+      if (resolved?.length) {
+        targets.push(...resolved);
+      }
+    }
+    return targets;
+  }
+  resetMorphTargetHandles(targets) {
+    for (const { infl, idx } of targets) {
+      if (idx < infl.length) {
+        infl[idx] = 0;
+      }
+    }
+  }
   isMixedAU(id) {
     const morphs = this.config.auToMorphs[id];
     const hasMorphs = !!(morphs?.left?.length || morphs?.right?.length || morphs?.center?.length);
@@ -5094,12 +5584,25 @@ var _Loom3 = class _Loom3 {
   }
   resolveBones(root) {
     const resolved = {};
+    const previousBones = this.bones;
     const snapshot = (obj) => ({
       obj,
       basePos: { x: obj.position.x, y: obj.position.y, z: obj.position.z },
       baseQuat: obj.quaternion.clone(),
       baseEuler: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z, order: obj.rotation.order }
     });
+    const snapshotPreservingBasePose = (obj) => {
+      const existing = Object.values(previousBones).find((entry) => entry?.obj === obj);
+      if (!existing) {
+        return snapshot(obj);
+      }
+      return {
+        obj,
+        basePos: { ...existing.basePos },
+        baseQuat: existing.baseQuat.clone(),
+        baseEuler: { ...existing.baseEuler }
+      };
+    };
     const prefix = this.config.bonePrefix || "";
     const suffix = this.config.boneSuffix || "";
     const suffixRegex = this.config.suffixPattern ? new RegExp(this.config.suffixPattern) : null;
@@ -5130,19 +5633,19 @@ var _Loom3 = class _Loom3 {
     for (const [key, nodeName] of Object.entries(this.config.boneNodes)) {
       const node = findNode(nodeName);
       if (node) {
-        resolved[key] = snapshot(node);
+        resolved[key] = snapshotPreservingBasePose(node);
       }
     }
     if (!resolved.EYE_L && this.config.eyeMeshNodes) {
       const node = findNode(this.config.eyeMeshNodes.LEFT);
       if (node) {
-        resolved.EYE_L = snapshot(node);
+        resolved.EYE_L = snapshotPreservingBasePose(node);
       }
     }
     if (!resolved.EYE_R && this.config.eyeMeshNodes) {
       const node = findNode(this.config.eyeMeshNodes.RIGHT);
       if (node) {
-        resolved.EYE_R = snapshot(node);
+        resolved.EYE_R = snapshotPreservingBasePose(node);
       }
     }
     return resolved;