@lovelace_lol/loom3 1.0.36 → 1.0.38

package/dist/index.js

@@ -1,4 +1,4 @@
-import * as THREE from 'three';
+import * as THREE2 from 'three';
 import { Vector3, Clock, Box3, Quaternion, AdditiveAnimationBlendMode, NormalAnimationBlendMode, LoopPingPong, LoopOnce, LoopRepeat, QuaternionKeyframeTrack, NumberKeyframeTrack, AnimationClip, AnimationMixer, Mesh, PropertyBinding } from 'three';
 
 var __defProp = Object.defineProperty;
@@ -270,6 +270,8 @@ var makeActionId = () => `act_${Math.random().toString(36).slice(2, 8)}_${Date.n
 var X_AXIS = new Vector3(1, 0, 0);
 var Y_AXIS = new Vector3(0, 1, 0);
 var Z_AXIS = new Vector3(0, 0, 1);
+var CLIP_EVENT_METADATA_KEY = "__loom3ClipEvents";
+var CLIP_EVENT_EPSILON = 1e-4;
 var BakedAnimationController = class {
   constructor(host) {
     __publicField(this, "host");
@@ -288,6 +290,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) {
@@ -301,6 +304,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;
@@ -512,7 +670,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() {
@@ -532,6 +711,7 @@ var BakedAnimationController = class {
     this.clipHandles.clear();
     this.clipSources.clear();
     this.playbackState.clear();
+    this.clipMonitors.clear();
   }
   loadAnimationClips(clips) {
     const model = this.host.getModel();
@@ -670,6 +850,7 @@ var BakedAnimationController = class {
     }
     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) {
@@ -692,9 +873,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) {
@@ -707,6 +890,7 @@ var BakedAnimationController = class {
       } catch {
       }
       this.clipActions.delete(clipName);
+      if (actionId) this.cleanupClipMonitor(actionId);
     }
     if (this.clipActions.get(clipName) === action) {
       this.clipActions.delete(clipName);
@@ -1268,6 +1452,7 @@ var BakedAnimationController = class {
       return null;
     }
     const clip = new 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;
   }
@@ -1299,28 +1484,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);
@@ -1338,6 +1533,7 @@ var BakedAnimationController = class {
           })
         );
         action.play();
+        this.resetClipMonitor(monitor, action.time);
       },
       stop: () => {
         action.stop();
@@ -1355,8 +1551,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;
@@ -1374,6 +1569,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) => {
@@ -1382,6 +1579,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) => {
@@ -1391,9 +1589,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);
@@ -1417,6 +1622,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();
@@ -1431,6 +1637,7 @@ var BakedAnimationController = class {
         this.clipHandles.delete(clipName);
         this.animationFinishedCallbacks.delete(clipName);
         this.playbackState.delete(clipName);
+        if (actionId) this.cleanupClipMonitor(actionId);
       }
     }
   }
@@ -1454,6 +1661,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 {
@@ -1472,6 +1681,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) {
@@ -1479,6 +1692,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);
@@ -1558,6 +1772,14 @@ 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) {
@@ -4264,9 +4486,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;
@@ -5985,10 +6209,11 @@ function extractProfileOverrides(config) {
     if (key === "annotationRegions") {
       const topLevelAnnotationRegions = Array.isArray(topLevelConfig.annotationRegions) ? topLevelConfig.annotationRegions : void 0;
       const legacyAnnotationRegions = Array.isArray(legacyNestedOverrides.annotationRegions) ? legacyNestedOverrides.annotationRegions : void 0;
-      const presetOverrideRegions = mergeRegionsByName(legacyAnnotationRegions, topLevelAnnotationRegions);
+      const legacyRegionFallback = Array.isArray(config.regions) && config.regions.length > 0 ? config.regions : void 0;
+      const legacyProfileRegions = mergeRegionsByName(legacyRegionFallback, legacyAnnotationRegions);
       const regions = mergeRegionsByName(
-        presetOverrideRegions,
-        Array.isArray(config.regions) && config.regions.length > 0 ? config.regions : void 0
+        legacyProfileRegions,
+        topLevelAnnotationRegions
       );
       if (regions) {
         overrides.annotationRegions = regions.map((region) => cloneRegion(region));
@@ -6004,6 +6229,13 @@ function extractProfileOverrides(config) {
   }
   return overrides;
 }
+function hasCanonicalAnnotationRegionOverrides(config) {
+  const topLevelConfig = config;
+  if (Array.isArray(topLevelConfig.annotationRegions)) {
+    return true;
+  }
+  return isPlainObject2(config.profile) && Array.isArray(config.profile.annotationRegions);
+}
 function applyCharacterProfileToPreset(config) {
   const presetType = config.auPresetType;
   if (!presetType) {
@@ -6041,7 +6273,7 @@ function extendCharacterConfigWithPreset(config) {
     return config;
   }
   const presetRegions = extendedPresetProfile.annotationRegions;
-  const mergedRegions = mergeRegionsByName(presetRegions, config.regions);
+  const mergedRegions = hasCanonicalAnnotationRegionOverrides(config) ? mergeRegionsByName(config.regions, presetRegions) : mergeRegionsByName(presetRegions, config.regions);
   const normalizedRegions = normalizeRegionTree(
     mergedRegions,
     profileOverrides.disabledRegions
@@ -6056,6 +6288,43 @@ function extendCharacterConfigWithPreset(config) {
     regions: extendedRegions ?? config.regions
   };
 }
+var DEFAULT_EPSILON = 1e-4;
+var DEFAULT_YAW_WEIGHT = 0.35;
+var DEFAULT_PITCH_WEIGHT = 0.2;
+var ZERO_OFFSET = { x: 0, y: 0 };
+function clampOffset(value) {
+  return THREE2.MathUtils.clamp(value, -1, 1);
+}
+function toModelLocalDirection(model, worldDirection) {
+  const localDirection = worldDirection.clone();
+  model.updateWorldMatrix(true, false);
+  const worldQuaternion = new THREE2.Quaternion();
+  model.getWorldQuaternion(worldQuaternion);
+  localDirection.applyQuaternion(worldQuaternion.invert());
+  return localDirection.normalize();
+}
+function computeCameraRelativeGazeOffset(model, cameraPosition, targetPosition, options = {}) {
+  if (!model) {
+    return ZERO_OFFSET;
+  }
+  const epsilon = options.epsilon ?? DEFAULT_EPSILON;
+  const yawWeight = options.yawWeight ?? DEFAULT_YAW_WEIGHT;
+  const pitchWeight = options.pitchWeight ?? DEFAULT_PITCH_WEIGHT;
+  const worldOffset = new THREE2.Vector3().subVectors(cameraPosition, targetPosition);
+  if (worldOffset.lengthSq() < epsilon) {
+    return ZERO_OFFSET;
+  }
+  const localDirection = toModelLocalDirection(model, worldOffset.normalize());
+  const yawAngle = Math.atan2(localDirection.x, localDirection.z);
+  const pitchAngle = Math.atan2(
+    localDirection.y,
+    Math.max(Math.hypot(localDirection.x, localDirection.z), epsilon)
+  );
+  return {
+    x: clampOffset(yawAngle / (Math.PI / 2)) * yawWeight,
+    y: clampOffset(pitchAngle / (Math.PI / 3)) * pitchWeight
+  };
+}
 var DEFAULT_HEAD_BONE_NAMES = ["CC_Base_Head", "Head", "head", "Bip01_Head"];
 var DEFAULT_REFERENCE_HEIGHT = 1.8;
 var DEFAULT_FORWARD_OFFSET = 0.08;
@@ -6071,8 +6340,8 @@ function findFaceCenter(model, options = {}) {
     referenceHeight = DEFAULT_REFERENCE_HEIGHT
   } = options;
   const debugInfo = [];
-  const boundingBox = new THREE.Box3().setFromObject(model);
-  const modelSize = new THREE.Vector3();
+  const boundingBox = new THREE2.Box3().setFromObject(model);
+  const modelSize = new THREE2.Vector3();
   boundingBox.getSize(modelSize);
   const scale = modelSize.y / referenceHeight;
   debugInfo.push(`Model height: ${modelSize.y.toFixed(2)}m, scale factor: ${scale.toFixed(2)}`);
@@ -6083,7 +6352,7 @@ function findFaceCenter(model, options = {}) {
       const objName = obj.name.toLowerCase();
       for (const boneName of headBoneNames) {
         if (objName === boneName.toLowerCase() || objName.includes(boneName.toLowerCase())) {
-          headPos2 = new THREE.Vector3();
+          headPos2 = new THREE2.Vector3();
           obj.getWorldPosition(headPos2);
           debugInfo.push(`Found head bone "${obj.name}" at (${headPos2.x.toFixed(3)}, ${headPos2.y.toFixed(3)}, ${headPos2.z.toFixed(3)})`);
           return;
@@ -6102,7 +6371,7 @@ function findFaceCenter(model, options = {}) {
       if (!eyes2.left) {
         for (const name of EYE_BONE_NAMES.left) {
           if (objName.includes(name)) {
-            eyes2.left = new THREE.Vector3();
+            eyes2.left = new THREE2.Vector3();
             obj.getWorldPosition(eyes2.left);
             debugInfo.push(`Found left eye "${obj.name}" at (${eyes2.left.x.toFixed(3)}, ${eyes2.left.y.toFixed(3)}, ${eyes2.left.z.toFixed(3)})`);
             break;
@@ -6112,7 +6381,7 @@ function findFaceCenter(model, options = {}) {
       if (!eyes2.right) {
         for (const name of EYE_BONE_NAMES.right) {
           if (objName.includes(name)) {
-            eyes2.right = new THREE.Vector3();
+            eyes2.right = new THREE2.Vector3();
             obj.getWorldPosition(eyes2.right);
             debugInfo.push(`Found right eye "${obj.name}" at (${eyes2.right.x.toFixed(3)}, ${eyes2.right.y.toFixed(3)}, ${eyes2.right.z.toFixed(3)})`);
             break;
@@ -6124,7 +6393,7 @@ function findFaceCenter(model, options = {}) {
   };
   if (faceMeshNames && faceMeshNames.length > 0) {
     debugInfo.push(`Looking for face meshes: ${faceMeshNames.join(", ")}`);
-    const meshBox = new THREE.Box3();
+    const meshBox = new THREE2.Box3();
     let foundMesh = false;
     model.traverse((obj) => {
       const isMesh = obj.isMesh;
@@ -6132,7 +6401,7 @@ function findFaceCenter(model, options = {}) {
       for (const meshName of faceMeshNames) {
         if (obj.name === meshName || obj.name.includes(meshName)) {
           const mesh = obj;
-          const tempBox = new THREE.Box3().setFromObject(mesh);
+          const tempBox = new THREE2.Box3().setFromObject(mesh);
           meshBox.union(tempBox);
           foundMesh = true;
           debugInfo.push(`Found mesh: "${obj.name}"`);
@@ -6141,11 +6410,11 @@ function findFaceCenter(model, options = {}) {
       }
     });
     if (foundMesh && !meshBox.isEmpty()) {
-      const meshBoundsSize = new THREE.Vector3();
+      const meshBoundsSize = new THREE2.Vector3();
       meshBox.getSize(meshBoundsSize);
       const isFullBodyMesh = meshBoundsSize.y > modelSize.y * 0.7;
       if (!isFullBodyMesh) {
-        const meshCenter = new THREE.Vector3();
+        const meshCenter = new THREE2.Vector3();
         meshBox.getCenter(meshCenter);
         debugInfo.push(`Using face mesh center: (${meshCenter.x.toFixed(3)}, ${meshCenter.y.toFixed(3)}, ${meshCenter.z.toFixed(3)})`);
         return {
@@ -6159,7 +6428,7 @@ function findFaceCenter(model, options = {}) {
   }
   const eyes = findEyes();
   if (eyes.left && eyes.right) {
-    const eyeCenter = new THREE.Vector3().addVectors(eyes.left, eyes.right).multiplyScalar(0.5);
+    const eyeCenter = new THREE2.Vector3().addVectors(eyes.left, eyes.right).multiplyScalar(0.5);
     debugInfo.push(`Eye center (face position): (${eyeCenter.x.toFixed(3)}, ${eyeCenter.y.toFixed(3)}, ${eyeCenter.z.toFixed(3)})`);
     const headPos2 = findHeadBone();
     return {
@@ -6184,10 +6453,10 @@ function findFaceCenter(model, options = {}) {
     };
   }
   debugInfo.push("No head bone found, using model center fallback");
-  const modelCenter = new THREE.Vector3();
+  const modelCenter = new THREE2.Vector3();
   boundingBox.getCenter(modelCenter);
   const headHeight = boundingBox.min.y + modelSize.y * 0.9;
-  const fallbackCenter = new THREE.Vector3(modelCenter.x, headHeight, modelCenter.z);
+  const fallbackCenter = new THREE2.Vector3(modelCenter.x, headHeight, modelCenter.z);
   debugInfo.push(`Fallback center: (${fallbackCenter.x.toFixed(3)}, ${fallbackCenter.y.toFixed(3)}, ${fallbackCenter.z.toFixed(3)})`);
   return {
     center: fallbackCenter,
@@ -6196,7 +6465,7 @@ function findFaceCenter(model, options = {}) {
   };
 }
 function getModelForwardDirection(model) {
-  const forward = new THREE.Vector3(0, 0, 1);
+  const forward = new THREE2.Vector3(0, 0, 1);
   forward.applyQuaternion(model.quaternion);
   return forward.normalize();
 }
@@ -6213,7 +6482,7 @@ function detectFacingDirection(model, eyeBoneNames = {
     if (!eyes.left) {
       for (const name of eyeBoneNames.left) {
         if (objName.includes(name)) {
-          eyes.left = new THREE.Vector3();
+          eyes.left = new THREE2.Vector3();
           obj.getWorldPosition(eyes.left);
           break;
         }
@@ -6222,7 +6491,7 @@ function detectFacingDirection(model, eyeBoneNames = {
     if (!eyes.right) {
       for (const name of eyeBoneNames.right) {
         if (objName.includes(name)) {
-          eyes.right = new THREE.Vector3();
+          eyes.right = new THREE2.Vector3();
           obj.getWorldPosition(eyes.right);
           break;
         }
@@ -7138,19 +7407,19 @@ function extractBones(root) {
   const bones = [];
   const boneDepths = /* @__PURE__ */ new Map();
   root.traverse((obj) => {
-    if (obj instanceof THREE.Bone || obj.type === "Bone") {
-      const worldPos = new THREE.Vector3();
+    if (obj instanceof THREE2.Bone || obj.type === "Bone") {
+      const worldPos = new THREE2.Vector3();
       obj.getWorldPosition(worldPos);
       let depth = 0;
       let parent = obj.parent;
       while (parent) {
-        if (parent instanceof THREE.Bone || parent.type === "Bone") {
+        if (parent instanceof THREE2.Bone || parent.type === "Bone") {
           depth++;
         }
         parent = parent.parent;
       }
       boneDepths.set(obj.name, depth);
-      const parentBone = obj.parent instanceof THREE.Bone || obj.parent?.type === "Bone" ? obj.parent.name : null;
+      const parentBone = obj.parent instanceof THREE2.Bone || obj.parent?.type === "Bone" ? obj.parent.name : null;
       bones.push({
         name: obj.name,
         parent: parentBone,
@@ -7374,6 +7643,6 @@ async function analyzeModel(options) {
   };
 }
 
-export { AU_INFO, AU_MAPPING_CONFIG, AU_MIX_DEFAULTS, AU_TO_MORPHS, AnimationThree, BETTA_FISH_PRESET, BLENDING_MODES, BONE_AU_TO_BINDINGS, CC4_BONE_NODES, CC4_BONE_PREFIX, CC4_EYE_MESH_NODES, CC4_MESHES, CC4_PRESET, CC4_SUFFIX_PATTERN, COMPOSITE_ROTATIONS, CONTINUUM_LABELS, CONTINUUM_PAIRS_MAP, DEFAULT_HAIR_PHYSICS_CONFIG, FISH_AU_MAPPING_CONFIG, HairPhysics, Loom3, Loom3 as Loom3Three, Loom3 as LoomLargeThree, MORPH_TO_MESH, VISEME_JAW_AMOUNTS, VISEME_KEYS, analyzeModel, applyCharacterProfileToPreset, collectMorphMeshes, detectFacingDirection, extendCharacterConfigWithPreset, extendPresetWithProfile, extractFromGLTF, extractModelData, extractProfileOverrides, findFaceCenter, fuzzyNameMatch, generateMappingCorrections, getModelForwardDirection, getPreset, getPresetWithProfile, hasLeftRightMorphs, isMixedAU, isPresetCompatible, mergeRegionsByName as mergeCharacterRegionsByName, resolveBoneName, resolveBoneNames, resolveFaceCenter, suggestBestPreset, validateMappingConfig, validateMappings };
+export { AU_INFO, AU_MAPPING_CONFIG, AU_MIX_DEFAULTS, AU_TO_MORPHS, AnimationThree, BETTA_FISH_PRESET, BLENDING_MODES, BONE_AU_TO_BINDINGS, CC4_BONE_NODES, CC4_BONE_PREFIX, CC4_EYE_MESH_NODES, CC4_MESHES, CC4_PRESET, CC4_SUFFIX_PATTERN, COMPOSITE_ROTATIONS, CONTINUUM_LABELS, CONTINUUM_PAIRS_MAP, DEFAULT_HAIR_PHYSICS_CONFIG, FISH_AU_MAPPING_CONFIG, HairPhysics, Loom3, Loom3 as Loom3Three, Loom3 as LoomLargeThree, MORPH_TO_MESH, VISEME_JAW_AMOUNTS, VISEME_KEYS, analyzeModel, applyCharacterProfileToPreset, collectMorphMeshes, computeCameraRelativeGazeOffset, detectFacingDirection, extendCharacterConfigWithPreset, extendPresetWithProfile, extractFromGLTF, extractModelData, extractProfileOverrides, findFaceCenter, fuzzyNameMatch, generateMappingCorrections, getModelForwardDirection, getPreset, getPresetWithProfile, hasLeftRightMorphs, isMixedAU, isPresetCompatible, mergeRegionsByName as mergeCharacterRegionsByName, resolveBoneName, resolveBoneNames, resolveFaceCenter, resolvePreset, resolvePresetWithOverrides, suggestBestPreset, validateMappingConfig, validateMappings };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map