@lovelace_lol/embody 0.0.8 → 0.0.9

package/dist/three.js

@@ -1,6 +1,7 @@
 import * as THREE3 from 'three';
-import { NoBlending, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NormalBlending, Vector3, Box3, Matrix4, Quaternion, MathUtils, Mesh, PlaneGeometry, ShadowMaterial, HemisphereLight, DirectionalLight, SRGBColorSpace, ACESFilmicToneMapping, WebGLRenderer, Scene, Color, PerspectiveCamera, PCFShadowMap, PCFSoftShadowMap, InterpolateDiscrete, NumberKeyframeTrack, QuaternionKeyframeTrack, VectorKeyframeTrack, AnimationClip, PMREMGenerator, FloatType, Float32BufferAttribute, Euler, PropertyBinding, BufferAttribute, WebGPUCoordinateSystem, WebGLCoordinateSystem } from 'three';
-import { initEmbodyCore, requireInitializedEmbodyCore } from '@lovelace_lol/embody/wasm';
+import { NoBlending, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NormalBlending, Vector3, Box3, Timer, Matrix4, AnimationMixer, AdditiveAnimationBlendMode, NormalAnimationBlendMode, LoopOnce, LoopRepeat, LoopPingPong, PropertyBinding, Quaternion, AnimationUtils, InterpolateDiscrete, InterpolateLinear, MathUtils, Mesh, PlaneGeometry, ShadowMaterial, HemisphereLight, DirectionalLight, SRGBColorSpace, ACESFilmicToneMapping, WebGLRenderer, Scene, Color, PerspectiveCamera, PCFShadowMap, PCFSoftShadowMap, NumberKeyframeTrack, QuaternionKeyframeTrack, VectorKeyframeTrack, AnimationClip, PMREMGenerator, FloatType, Float32BufferAttribute, Euler, BufferAttribute, WebGPUCoordinateSystem, WebGLCoordinateSystem } from 'three';
+import { CC4_HUMANOID_SKELETON_TEMPLATE, HUMANOID_SKELETON_TEMPLATES, DEFAULT_HAIR_COLOR_APPEARANCE, initEmbodyCore, requireInitializedEmbodyCore } from '@lovelace_lol/embody/wasm';
+export { CC4_HUMANOID_SKELETON_TEMPLATE, DEFAULT_AXIS_TO_CHANNEL, DEFAULT_BONE_MAX_DEGREES, DEFAULT_HAIR_COLOR_APPEARANCE, HAIR_COLOR_PRESETS, HUMANOID_SKELETON_TEMPLATES, JOINT_CONTROL_SECTION, VISEME_KEYS } from '@lovelace_lol/embody/wasm';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
@@ -449,6 +450,59 @@ function drawModelForRender(renderer, scene, camera, model) {
     if (globalShadow && renderer.shadowMap.enabled) globalShadow.needsUpdate = true;
   };
 }
+var bindings = /* @__PURE__ */ new WeakMap();
+function bindPlaybackRendering(model, mixer, afterFrame) {
+  const binding = { mixer, enabled: true, afterFrame };
+  const entries = bindings.get(model) ?? /* @__PURE__ */ new Set();
+  entries.add(binding);
+  bindings.set(model, entries);
+  return {
+    setEnabled(enabled) {
+      binding.enabled = enabled;
+    },
+    dispose() {
+      entries.delete(binding);
+      if (!entries.size) bindings.delete(model);
+    }
+  };
+}
+function renderScenePlayback(scene, timer) {
+  const mixers = /* @__PURE__ */ new Set();
+  const active = [];
+  scene.traverse((object) => {
+    for (const binding of bindings.get(object) ?? []) {
+      if (binding.enabled) {
+        active.push(binding);
+        mixers.add(binding.mixer);
+      }
+    }
+  });
+  for (const mixer of mixers) mixer.update(timer.getDelta());
+  for (const binding of active) binding.afterFrame();
+}
+function createScenePlaybackFrame(scene, document2) {
+  const timer = new Timer();
+  if (document2) timer.connect(document2);
+  let disposed = false;
+  let initialized = false;
+  return {
+    onFrame(timestamp) {
+      if (disposed) return;
+      timer.update(timestamp);
+      if (!initialized) {
+        initialized = true;
+        return;
+      }
+      renderScenePlayback(scene, timer);
+    },
+    dispose() {
+      if (!disposed) {
+        disposed = true;
+        timer.dispose();
+      }
+    }
+  };
+}
 
 // three/annotations/DOMControls.ts
 var RUNTIME_ANNOTATION_REGION_PREFIX = "runtime:annotation:";
@@ -1111,8 +1165,8 @@ function getAnnotationRegionLabel(region) {
   const trimmed = label.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
-function isFiniteClipPoint(point3) {
-  return Number.isFinite(point3.x) && Number.isFinite(point3.y) && Number.isFinite(point3.z) && Number.isFinite(point3.w);
+function isFiniteClipPoint(point2) {
+  return Number.isFinite(point2.x) && Number.isFinite(point2.y) && Number.isFinite(point2.z) && Number.isFinite(point2.w);
 }
 function resolveViewportSafeBounds(params) {
   return requireAnnotationCameraCore().resolveViewportSafeBounds(params);
@@ -3913,9 +3967,9 @@ function resolveRuntimeAnnotationAUBoneTargets(auId, candidates, targetSide) {
   const boneTargets = [];
   for (const candidate of candidates) {
     if (!isPlainRecord(candidate.auToBones)) continue;
-    const bindings = candidate.auToBones[auId];
-    if (!Array.isArray(bindings)) continue;
-    for (const binding of bindings) {
+    const bindings2 = candidate.auToBones[auId];
+    if (!Array.isArray(bindings2)) continue;
+    for (const binding of bindings2) {
       const target = readRuntimeAnnotationBoneTarget(binding);
       if (!target || seen.has(target.boneName)) continue;
       seen.add(target.boneName);
@@ -4079,6 +4133,7 @@ var DPthreeCameraController = class {
     __publicField(this, "domElement");
     // Renderer and render loop (when controller manages the render loop)
     __publicField(this, "renderer", null);
+    __publicField(this, "playbackTimer", new THREE3.Timer());
     __publicField(this, "renderFrame");
     __publicField(this, "resizeRenderer");
     __publicField(this, "onRenderError");
@@ -4189,15 +4244,25 @@ var DPthreeCameraController = class {
   startRenderLoop(propagateFailure = false) {
     if (!this.renderer) return;
     const renderer = this.renderer;
+    this.playbackTimer.disconnect();
+    const ownerDocument = renderer.domElement?.ownerDocument;
+    if (ownerDocument) this.playbackTimer.connect(ownerDocument);
+    this.playbackTimer.reset();
+    let playbackStarted = false;
     try {
-      const started = renderer.setAnimationLoop(() => {
-        if (this.disposed || this.renderFailed || this.renderingSuspended || this.framePending || renderer !== this.renderer) return;
+      const started = renderer.setAnimationLoop((timestamp) => {
+        if (this.disposed || renderer !== this.renderer) return;
+        this.playbackTimer.update(timestamp);
+        const samplePlayback = playbackStarted;
+        playbackStarted = true;
+        if (this.renderFailed || this.renderingSuspended || this.framePending) return;
         try {
           const preparationDraw = this.modelPreparation?.draw;
           if (preparationDraw) {
             preparationDraw();
             return;
           }
+          if (samplePlayback) renderScenePlayback(this.scene, this.playbackTimer);
           this.update();
           const frame = this.renderFrame ? this.renderFrame(this.renderer, this.scene, this.camera) : this.renderer.render(this.scene, this.camera);
           if (frame) {
@@ -4246,6 +4311,7 @@ var DPthreeCameraController = class {
    * Stop the render loop
    */
   stopRenderLoop() {
+    this.playbackTimer.reset();
     try {
       const stopped = this.renderer?.setAnimationLoop(null);
       if (stopped) void stopped.catch((error) => console.error("Character camera render loop stop failed.", error));
@@ -4331,18 +4397,18 @@ var DPthreeCameraController = class {
       resolve = yes;
       reject = no;
     });
-    const request2 = {
+    const request3 = {
       promise,
       draw: null,
       cancel: (reason) => {
         cancelled ?? (cancelled = reason);
         invalidatePreparedShadows?.();
-        request2.draw = null;
+        request3.draw = null;
         rejectDraw?.(cancelled);
       }
     };
-    this.modelPreparation = request2;
-    const abort = () => request2.cancel(renderPreparationAborted());
+    this.modelPreparation = request3;
+    const abort = () => request3.cancel(renderPreparationAborted());
     options.signal?.addEventListener("abort", abort, { once: true });
     const checkCancelled = () => {
       if (cancelled) throw cancelled;
@@ -4361,8 +4427,8 @@ var DPthreeCameraController = class {
         checkCancelled();
         await new Promise((done, failed) => {
           rejectDraw = failed;
-          request2.draw = () => {
-            request2.draw = null;
+          request3.draw = () => {
+            request3.draw = null;
             try {
               checkCancelled();
               invalidatePreparedShadows = drawModelForRender(renderer, this.scene, this.camera, model);
@@ -4377,7 +4443,7 @@ var DPthreeCameraController = class {
         checkCancelled();
       } finally {
         options.signal?.removeEventListener("abort", abort);
-        if (this.modelPreparation === request2) this.modelPreparation = null;
+        if (this.modelPreparation === request3) this.modelPreparation = null;
       }
     })().then(resolve, reject);
     return promise;
@@ -4416,10 +4482,10 @@ var DPthreeCameraController = class {
    */
   async loadRegions(config) {
     if (this.disposed) return;
-    const request2 = ++this.regionLoadGeneration;
+    const request3 = ++this.regionLoadGeneration;
     const model = this.model;
     const runtimeConfig = await this.resolveCharacterConfig(config);
-    if (!this.isRegionLoadCurrent(request2, model)) return;
+    if (!this.isRegionLoadCurrent(request3, model)) return;
     await this.prepareRegionsAndMarkersForReveal(runtimeConfig);
   }
   /**
@@ -4439,12 +4505,12 @@ var DPthreeCameraController = class {
   async prepareRegionsAndMarkersForReveal(config, beforeReveal) {
     if (this.disposed) return;
     this.prepareRegionState(config);
-    const request2 = this.regionLoadGeneration;
+    const request3 = this.regionLoadGeneration;
     const model = this.model;
     await this.loadMarkersForCurrentRegions(true);
-    if (!this.isRegionLoadCurrent(request2, model) || this.characterConfig !== config) return;
+    if (!this.isRegionLoadCurrent(request3, model) || this.characterConfig !== config) return;
     if (beforeReveal && !await beforeReveal()) return;
-    if (this.isRegionLoadCurrent(request2, model) && this.characterConfig === config) {
+    if (this.isRegionLoadCurrent(request3, model) && this.characterConfig === config) {
       this.startPreparedCameraTransition(config);
     }
   }
@@ -4479,14 +4545,14 @@ var DPthreeCameraController = class {
       return;
     }
     const characterConfig = this.characterConfig;
-    const request2 = this.regionLoadGeneration;
+    const request3 = this.regionLoadGeneration;
     const model = this.model;
     this.ensureMarkersForCurrentStyle();
     const markers = this.markers;
     if (!markers) return;
     markers.setVisible(this.markersVisible);
     await markers.loadRegions(characterConfig, { sliceSurfaceQueries });
-    if (!this.isRegionLoadCurrent(request2, model) || markers !== this.markers || characterConfig !== this.characterConfig) {
+    if (!this.isRegionLoadCurrent(request3, model) || markers !== this.markers || characterConfig !== this.characterConfig) {
       return;
     }
     if (this.currentRegion) {
@@ -4656,8 +4722,8 @@ var DPthreeCameraController = class {
    * @param zoomDuration - Duration of the final zoom in ms (default: 1500)
    */
   async playIntroAnimation(orbitDuration = 3e3, zoomDuration = 1500) {
-    const request2 = await this.beginCameraRequest();
-    if (request2 === null) return;
+    const request3 = await this.beginCameraRequest();
+    if (request3 === null) return;
     if (!this.model) {
       return;
     }
@@ -4672,12 +4738,12 @@ var DPthreeCameraController = class {
     const orbitRadius = Math.max(horizontalExtent, verticalExtent) * 1.8;
     const orbitHeight = center.y;
     await this.animateOrbit(center, orbitRadius, orbitHeight, orbitDuration);
-    if (!this.isCameraRequestCurrent(request2)) return;
+    if (!this.isCameraRequestCurrent(request3)) return;
     const leftEyeRegion = this.findIntroLeftEyeRegion();
     const leftEyeFocus = leftEyeRegion ? this.calculateIntroLeftEyeFocusPosition(leftEyeRegion) : null;
     if (leftEyeFocus && leftEyeRegion) {
       await this.animateCamera(leftEyeFocus.position, leftEyeFocus.target, zoomDuration);
-      if (!this.isCameraRequestCurrent(request2)) return;
+      if (!this.isCameraRequestCurrent(request3)) return;
       this.currentRegion = leftEyeRegion.name;
       this.notifyRegionChange(leftEyeRegion.name);
       return;
@@ -4686,7 +4752,7 @@ var DPthreeCameraController = class {
     const fullBodyRegion = this.regions.find((region) => this.isFullBodyRegion(region));
     const focusPos = this.calculateFullBodyFocusPosition(fullBodyRegion?.paddingFactor, finalAngle, "world");
     await this.animateCamera(focusPos.position, focusPos.target, zoomDuration);
-    if (!this.isCameraRequestCurrent(request2)) return;
+    if (!this.isCameraRequestCurrent(request3)) return;
     if (fullBodyRegion) {
       this.currentRegion = fullBodyRegion.name;
       this.notifyRegionChange(fullBodyRegion.name);
@@ -5390,6 +5456,7 @@ var DPthreeCameraController = class {
     this.regionLoadGeneration += 1;
     this.cameraRequestGeneration += 1;
     this.stopRenderLoop();
+    this.playbackTimer.dispose();
     const renderingSettled = this.unbindRendering?.();
     this.unbindRendering = null;
     this.cleanupResizeHandling();
@@ -5703,19 +5770,19 @@ var DPthreeCameraController = class {
     this.laterality = detectAnnotationLaterality(this.model, this.regions, boneResolutionProfile(this.characterConfig));
   }
   /** Resolver and paint continuations belong to one model/configuration load. */
-  isRegionLoadCurrent(request2, model) {
-    return !this.disposed && request2 === this.regionLoadGeneration && model === this.model;
+  isRegionLoadCurrent(request3, model) {
+    return !this.disposed && request3 === this.regionLoadGeneration && model === this.model;
   }
   /** Await Wasm once per request and abandon requests superseded during initialization. */
   async beginCameraRequest() {
-    const request2 = ++this.cameraRequestGeneration;
+    const request3 = ++this.cameraRequestGeneration;
     this.cancelCameraAnimation();
     if (this.disposed) return null;
     await getAnnotationCameraCore();
-    return this.isCameraRequestCurrent(request2) ? request2 : null;
+    return this.isCameraRequestCurrent(request3) ? request3 : null;
   }
-  isCameraRequestCurrent(request2) {
-    return !this.disposed && request2 === this.cameraRequestGeneration;
+  isCameraRequestCurrent(request3) {
+    return !this.disposed && request3 === this.cameraRequestGeneration;
   }
   cancelCameraAnimation() {
     this.timerAnimationFallbackToken += 1;
@@ -6448,6 +6515,99 @@ function pickContinuumAnnotationAuId(value, negId, posId, stickyId) {
   if (value > 0) return posId;
   return negId;
 }
+var json = (value) => JSON.stringify(value ?? {});
+function request2(op, payload = {}) {
+  return JSON.parse(requireInitializedEmbodyCore().embody_request(json({ op, payload })));
+}
+var getPreset = (id) => request2("preset.get", { id });
+var extendCharacterConfigWithPreset = (config) => request2("profile.extendConfig", { config });
+var extractProfileOverrides = (config) => request2("profile.extractOverrides", { config });
+var mergeCharacterRegionsByName = (base, override) => request2("profile.mergeRegions", { base, override });
+var getMeshNamesForAUProfile = (profile, auId) => request2("profile.getMeshNamesForAU", { profile, auId });
+var getHumanoidSpecification = () => request2("humanoid.getSpecification");
+var setAUMorphTargets = (profile, auId, side, targets) => request2("profile.setAUMorphTargets", { profile, auId, side, targets });
+var setHumanoidRoleBinding = (profile, role, boneName) => request2("profile.setHumanoidRoleBinding", { profile, role, boneName });
+var resolveHumanoidCharacterization = (profile) => request2("profile.resolveHumanoidCharacterization", { profile });
+var hasLeftRightMorphs = (profile, auId) => request2("profile.hasLeftRightMorphs", { profile, auId });
+var isMixedAU = (profile, auId) => request2("profile.isMixedAU", { profile, auId });
+var resolveVisemeProfile = (profile) => request2("profile.resolveVisemes", { profile });
+var isMaxDegreesOnlyAxisBindingUpdate = (update) => request2("bone.isMaxDegreesOnlyUpdate", { update });
+var findNodeKeyForBone = (boneName, profile) => profile ? request2("bone.findNodeKey", { profile, boneName }) : null;
+var ensureBoneNodeKey = (profile, boneName) => request2("bone.ensureNodeKey", { profile, boneName });
+var ensureBilateralBoneNodeKeys = (profile, leftBoneName, rightBoneName) => request2("bone.ensureBilateralNodeKeys", { profile, leftBoneName, rightBoneName });
+var resolveBoneNameForNodeKey = (profile, nodeKey) => request2("bone.resolveBoneName", { profile, nodeKey });
+var stripConfiguredBoneAffixes = (profile, boneName) => request2("bone.stripAffixes", { profile: profile ?? {}, boneName });
+var inferChiralBoneNamePair = (boneNames, selectedBoneName) => request2("bone.inferChiralPair", { boneNames, selectedBoneName });
+var formatAxisLabel = (axis) => request2("bone.formatAxisLabel", { axis });
+var formatAxisDirectionLabel = (axis, direction) => request2("bone.formatDirectionLabel", { axis, direction });
+var getAxisFromChannel = (channel) => channel ? request2("bone.getAxisFromChannel", { channel }) : null;
+var getBoneAxisBindingState = (profile, boneName, axis) => request2("bone.getAxisState", { profile, boneName, axis });
+var resolveBoneAxisChannel = (profile, boneName, axis) => request2("bone.resolveAxisChannel", { profile, boneName, axis });
+var getBilateralAxisBindingState = (profile, boneName, axis) => request2("bone.getBilateralAxisState", { profile, boneName, axis });
+var getAUBoneBindingState = (profile, auId) => request2("bone.getAUBindingState", { profile, auId });
+var inferEyeControlScope = (profile, binding) => request2("bone.inferEyeScope", { profile, binding });
+var inferEyeControlFamily = (binding) => request2("bone.inferEyeFamily", { binding });
+var applyBoneAxisBindingUpdate = (profile, boneName, axis, update) => request2("bone.applyAxisUpdate", { profile, boneName, axis, update });
+var applyBilateralAxisBindingUpdate = (profile, boneName, axis, scope, update) => request2("bone.applyBilateralAxisUpdate", { profile, boneName, axis, scope, update });
+var applyAUBoneBindingUpdate = (profile, auId, update) => request2("bone.applyAUBindingUpdate", { profile, auId, update });
+var createBoneAxisAu = (profile, boneName, axis, direction, options = {}) => request2("bone.createAxisAU", { profile, boneName, axis, direction, name: options.name });
+var createBilateralBoneAxisAu = (profile, boneName, axis, scope, direction, options = {}) => request2("bone.createBilateralAxisAU", { profile, boneName, axis, scope, direction, name: options.name });
+var buildBoneAuOptions = (profile) => request2("bone.buildAUOptions", { profile });
+var isJointControlAuInfo = (info) => request2("bone.isJointControlInfo", { info });
+var classifyAuAsJointControl = (profile, auId, options = {}) => request2("bone.classifyJointControl", { profile, auId, boneName: options.boneName, nodeKey: options.nodeKey });
+var resolveContinuumDisplayLabel = (profile, negativeAuId, positiveAuId) => request2("bone.resolveContinuumLabel", { profile, negativeAuId, positiveAuId }) ?? `AU ${negativeAuId} <-> AU ${positiveAuId}`;
+function inspectModel(model, meshes, profile) {
+  return new ThreeModelInspector().inspectModel(model, { meshes, profile });
+}
+function getBodyControls(profile, model) {
+  return request2("profile.getBodyControls", { profile, ...model ? { model: inspectModel(model, void 0, profile).descriptor } : {} });
+}
+function extractModelData(model, meshes, animations = []) {
+  const inspection = inspectModel(model, meshes);
+  return JSON.parse(requireInitializedEmbodyCore().extract_model_data_json(json(inspection.descriptor), json(serializeAnimationClips(model, animations, inspection))));
+}
+async function analyzeModel(options) {
+  const source = options.source;
+  const model = source.type === "gltf" ? source.gltf.scene ?? source.gltf.scenes[0] : source.model;
+  const animations = source.type === "gltf" ? source.gltf.animations : source.animations ?? [];
+  const inspection = inspectModel(model, source.type === "runtime" ? source.meshes : void 0);
+  return JSON.parse(requireInitializedEmbodyCore().analyze_model_descriptor(json(inspection.descriptor), json(serializeAnimationClips(model, animations, inspection)), options.preset ? json(options.preset) : "", json({ suggestCorrections: Boolean(options.suggestCorrections) })));
+}
+function validateMappings(meshes, skeleton, profile, options = {}) {
+  let nextMorphId = 1;
+  const morphTargets = [];
+  const descriptorMeshes = (meshes ?? []).map((value, index) => {
+    const mesh = value;
+    const id = index + 1;
+    const morphTargetIds = Object.entries(mesh.morphTargetDictionary ?? mesh.geometry?.morphTargetDictionary ?? {}).map(([name, hostIndex]) => {
+      const morphId = nextMorphId++;
+      morphTargets.push({ id: morphId, meshId: id, name, hostIndex });
+      return morphId;
+    });
+    return { id, name: mesh.name ?? "", morphTargetIds, visible: true };
+  });
+  const bones = (skeleton?.bones ?? []).map((bone, index) => ({ id: index + 1, name: typeof bone === "string" ? bone : bone.name ?? "" }));
+  return JSON.parse(requireInitializedEmbodyCore().validate_profile_model(json(profile), json({ meshes: descriptorMeshes, morphTargets, bones, objects: [] }), json(options)));
+}
+function validateHumanoidCharacterization(model, profile) {
+  return JSON.parse(requireInitializedEmbodyCore().validate_humanoid_characterization(json(profile), json(inspectModel(model, void 0, profile).descriptor)));
+}
+function normalizeHairColorAppearance(value, fallback = DEFAULT_HAIR_COLOR_APPEARANCE) {
+  return JSON.parse(requireInitializedEmbodyCore().normalize_hair_color_appearance_json(json(value), json(fallback)));
+}
+var getHumanoidSkeletonTemplate = (id) => HUMANOID_SKELETON_TEMPLATES.find((template) => template.id === id) ?? null;
+function getHumanoidSkeletonTemplateBoneNames(template = CC4_HUMANOID_SKELETON_TEMPLATE) {
+  return JSON.parse(requireInitializedEmbodyCore().humanoid_skeleton_template_bone_names(json(template)));
+}
+function createValidationSkeletonFromHumanoidTemplate(template = CC4_HUMANOID_SKELETON_TEMPLATE) {
+  return JSON.parse(requireInitializedEmbodyCore().create_validation_skeleton_json(json(template)));
+}
+function computeHumanoidSkeletonTemplateRestBounds(template) {
+  return Array.from(requireInitializedEmbodyCore().compute_humanoid_skeleton_template_rest_bounds(json(template)));
+}
+function extractHumanoidSkeletonTemplateFromModel(model, options) {
+  return JSON.parse(requireInitializedEmbodyCore().extract_humanoid_skeleton_template_json(json(inspectModel(model).descriptor), json(options)));
+}
 var isBone = (object) => !!(object.isBone || object.type === "Bone");
 var finite = (values, description) => {
   if (!values.every(Number.isFinite)) {
@@ -6558,332 +6718,1635 @@ function extendModelReferencePose(model, previous) {
 }
 function bindModelReferencePose(model, referencePose) {
   if (referencePose.version !== 1) throw new Error("Unsupported model reference pose version");
-  const bindings = /* @__PURE__ */ new Map();
+  const bindings2 = /* @__PURE__ */ new Map();
   let index = 0;
   const bind = (object, path, parentPath) => {
     const node = referencePose.nodes[index++];
     if (!matchesNode(object, node, path, parentPath) || node.childCount !== object.children.length) {
       throw incompatible(object, path);
     }
-    bindings.set(object, node);
+    bindings2.set(object, node);
     object.children.forEach((child, childIndex) => bind(child, `${path}/${childIndex}`, path));
   };
   bind(model, "", null);
   if (index !== referencePose.nodes.length) throw new Error("Incompatible reference pose hierarchy: extra captured nodes");
-  return bindings;
-}
-var EPSILON = 1e-8;
-var finite2 = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
-var bounded = (value) => Math.max(-1, Math.min(1, finite2(value)));
-var contribution = (value) => Math.max(0, Math.min(1, finite2(value, 1)));
-var point2 = (value) => ({ x: value.x, y: value.y, z: value.z });
-var vector = (value) => new Vector3(finite2(value?.x), finite2(value?.y), finite2(value?.z));
-var axisVector = (channel) => channel === "rx" ? new Vector3(1, 0, 0) : channel === "ry" ? new Vector3(0, 1, 0) : channel === "rz" ? new Vector3(0, 0, 1) : void 0;
-var ThreeGazeFocus = class {
-  constructor(model, profile, options = {}) {
-    this.model = model;
-    this.profile = profile;
-    __publicField(this, "head");
-    __publicField(this, "eyes", []);
-    __publicField(this, "saved", /* @__PURE__ */ new Map());
-    __publicField(this, "references");
-    __publicField(this, "limits");
-    this.references = bindModelReferencePose(model, options.referencePose ?? captureModelReferencePose(model));
-    this.head = this.joint("HEAD", "head", [51, 52, 53, 54, 56, 55]);
-    this.eyes = [
-      this.joint("EYE_L", "leftEye", [61, 62, 63, 64]),
-      this.joint("EYE_R", "rightEye", [61, 62, 63, 64])
-    ].filter((value) => !!value);
-    this.limits = {
-      headYaw: this.capacity(51, 52),
-      headPitch: this.capacity(53, 54),
-      eyeYaw: this.capacity(61, 62),
-      eyePitch: this.capacity(63, 64)
-    };
+  return bindings2;
+}
+
+// three/clipBindings.ts
+function concreteTrackName(target, inspection) {
+  if (!target) return void 0;
+  if (target.kind === "morphTarget") {
+    const binding = inspection.morphBindings.get(Number(target.morphTargetId));
+    return binding && `${binding.mesh.uuid}.morphTargetInfluences[${binding.index}]`;
+  }
+  if (target.kind === "boneTransform" || target.kind === "objectTransform") {
+    const object = target.kind === "boneTransform" ? inspection.boneBindings.get(Number(target.boneId)) : inspection.objectBindings.get(Number(target.objectId));
+    const property = target.property ?? "rotation";
+    if (!object) return void 0;
+    if (property === "rotation" || property === "quaternion") return `${object.uuid}.quaternion`;
+    if (property === "position" || property === "scale") return `${object.uuid}.${property}`;
   }
-  name(node) {
-    const base = this.profile.boneNodes?.[node] ?? node;
-    const prefix = this.profile.bonePrefix ?? "";
-    const suffix = this.profile.boneSuffix ?? "";
-    return `${base.startsWith(prefix) ? "" : prefix}${base}${base.endsWith(suffix) ? "" : suffix}`;
-  }
-  binding(node, id) {
-    const binding = this.profile.auToBones?.[id]?.find((candidate) => this.name(candidate.node) === this.name(node));
-    const axis = binding && axisVector(binding.channel);
-    const radians = finite2(binding?.maxDegrees) * finite2(binding?.scale, 1) * Math.PI / 180;
-    return axis && Math.abs(radians) > EPSILON ? { axis, radians } : void 0;
-  }
-  capacity(positive, negative) {
-    const magnitude = (id) => {
-      const seen = /* @__PURE__ */ new Set();
-      const values = [];
-      for (const row of this.profile.auToBones?.[id] ?? []) {
-        const name = this.name(row.node);
-        if (!axisVector(row.channel) || seen.has(name)) continue;
-        seen.add(name);
-        values.push(Math.abs(finite2(row.maxDegrees) * finite2(row.scale, 1)));
+  if (target.kind === "meshVisibility") {
+    const mesh = inspection.meshBindings.get(Number(target.meshId));
+    return mesh && `${mesh.uuid}.visible`;
+  }
+  return void 0;
+}
+function cloneWithConcreteTrackNames(clip, tracks, inspection) {
+  const native = clip.clone();
+  for (let index = 0; index < tracks.length; index += 1) {
+    const name = concreteTrackName(tracks[index].target, inspection);
+    if (!name) throw new Error("Every native playback track must resolve on the bound model.");
+    native.tracks[index].name = name;
+  }
+  return native;
+}
+
+// three/nativePlayback.ts
+var sampleSize = (track) => track.getValueSize() / (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ? 3 : 1);
+var asError = (error) => error instanceof Error ? error : new Error(String(error));
+var blendMode = (mode) => mode === "additive" ? AdditiveAnimationBlendMode : NormalAnimationBlendMode;
+var loopMode = (mode) => mode === "once" ? LoopOnce : mode === "repeat" ? LoopRepeat : LoopPingPong;
+function validateBinding(binding) {
+  if (!binding.model?.isObject3D || binding.mixer && binding.mixer.getRoot() !== binding.model) {
+    throw new Error("Native playback requires a Three model and its render integration mixer.");
+  }
+  const objects = /* @__PURE__ */ new Set();
+  binding.model.traverse((object) => objects.add(object));
+  const { inspection } = binding;
+  for (const object of [
+    ...inspection.meshBindings.values(),
+    ...inspection.boneBindings.values(),
+    ...inspection.objectBindings.values(),
+    ...Array.from(inspection.morphBindings.values(), (entry) => entry.mesh)
+  ]) {
+    if (!objects.has(object)) throw new Error("Native playback inspection contains an object outside the bound model.");
+  }
+}
+var ThreeNativePlaybackConnector = class {
+  constructor(session, binding) {
+    this.session = session;
+    __publicField(this, "binding");
+    __publicField(this, "rendering");
+    __publicField(this, "renderingEnabled", true);
+    __publicField(this, "resources", /* @__PURE__ */ new Map());
+    __publicField(this, "actionHandles", /* @__PURE__ */ new Map());
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "pending", []);
+    __publicField(this, "notifications", []);
+    __publicField(this, "depth", 0);
+    __publicField(this, "flushingNotifications", false);
+    __publicField(this, "notificationScheduled", false);
+    __publicField(this, "sessionDisposed", false);
+    __publicField(this, "disposed", false);
+    __publicField(this, "onError");
+    __publicField(this, "onRelease");
+    __publicField(this, "finished", (event) => {
+      const handle = this.actionHandles.get(event.action);
+      if (!handle || this.disposed) return;
+      this.notifications.push({ type: this.resources.get(handle)?.fadingOut ? "cancelled" : "completed", handle });
+      if (this.notificationScheduled) return;
+      this.notificationScheduled = true;
+      queueMicrotask(() => {
+        this.notificationScheduled = false;
+        if (this.disposed) return;
+        try {
+          this.flushNotifications();
+        } catch (error) {
+          const failure = asError(error);
+          if (this.onError) this.onError(failure);
+          else throw failure;
+        }
+      });
+    });
+    validateBinding(binding);
+    this.binding = { ...binding, mixer: binding.mixer ?? new AnimationMixer(binding.model) };
+    this.onError = binding.onError;
+    this.onRelease = binding.onRelease;
+    this.binding.mixer.addEventListener("finished", this.finished);
+    this.rendering = bindPlaybackRendering(binding.model, this.binding.mixer, () => this.flushEvents());
+  }
+  /** Prepare bindings first; old actions are released before the new binding is exposed. */
+  rebind(modelKey, profileKey, binding = this.binding) {
+    validateBinding(binding);
+    this.beforeOperation();
+    this.dispatch(this.session.rebind(modelKey, profileKey), void 0, () => {
+      this.binding.mixer.removeEventListener("finished", this.finished);
+      this.rendering.dispose();
+      this.binding = { ...binding, mixer: binding.mixer ?? new AnimationMixer(binding.model) };
+      this.binding.mixer.addEventListener("finished", this.finished);
+      this.rendering = bindPlaybackRendering(binding.model, this.binding.mixer, () => this.flushEvents());
+      this.rendering.setEnabled(this.renderingEnabled);
+    });
+  }
+  play(clip, options = {}) {
+    this.beforeOperation();
+    const native = createAnimationClipFromClipIR(clip, this.binding.inspection);
+    if (native.tracks.length !== clip.tracks.length) {
+      throw new Error("Every playback track must resolve on the bound model.");
+    }
+    return this.dispatch(this.session.play(JSON.stringify(clip), JSON.stringify(options)), native).handle;
+  }
+  /**
+   * Validate native track bindings through the existing serializer, then retain
+   * the native clone's interpolants and authored/additive sample values. Concrete
+   * binding names match compiled tracks so Three shares their PropertyMixer.
+   */
+  playNativeClip(clip, options = {}) {
+    this.beforeOperation();
+    const [ir] = serializeAnimationClips(this.binding.model, [clip], this.binding.inspection);
+    if (ir.tracks.length !== clip.tracks.length) {
+      throw new Error("Every native playback track must serialize against the bound model.");
+    }
+    const native = cloneWithConcreteTrackNames(clip, ir.tracks, this.binding.inspection);
+    const settings = {
+      ...options,
+      blendMode: options.blendMode ?? (clip.blendMode === AdditiveAnimationBlendMode ? "additive" : "normal")
+    };
+    return this.dispatch(this.session.play(JSON.stringify(ir), JSON.stringify(settings)), native).handle;
+  }
+  control(handle, control) {
+    this.beforeOperation();
+    this.dispatch(this.session.control(handle, JSON.stringify(control)));
+  }
+  setRendering(enabled) {
+    this.beforeOperation();
+    if (enabled === this.renderingEnabled) return;
+    this.renderingEnabled = enabled;
+    this.rendering.setEnabled(enabled);
+    for (const resource of this.resources.values()) {
+      if (!resource.action) continue;
+      if (!enabled) {
+        resource.suspendedPaused = resource.action.paused;
+        this.pauseFade(resource);
+        resource.action.paused = true;
+      } else if (resource.suspendedPaused !== void 0) {
+        resource.action.paused = resource.suspendedPaused;
+        if (!resource.explicitlyPaused) this.resumeFade(resource);
+        resource.suspendedPaused = void 0;
+      }
+    }
+  }
+  setTimeScale(value) {
+    this.beforeOperation();
+    if (!Number.isFinite(value)) throw new Error("Native mixer speed must be finite.");
+    this.binding.mixer.timeScale = value;
+  }
+  fadeIn(handle, seconds) {
+    this.control(handle, { type: "fadeIn", seconds });
+  }
+  fadeOut(handle, seconds) {
+    this.control(handle, { type: "fadeOut", seconds });
+  }
+  /** Edit authored samples, retaining the native action and its loop/fade progress. */
+  replaceClip(handle, clip) {
+    this.beforeOperation();
+    const resource = this.resources.get(handle);
+    if (!resource) throw new Error("Unknown, foreign or stale playback handle.");
+    const [ir] = serializeAnimationClips(this.binding.model, [clip], this.binding.inspection);
+    if (ir.tracks.length !== clip.tracks.length) throw new Error("Every edited track must resolve on the bound model.");
+    const native = cloneWithConcreteTrackNames(clip, ir.tracks, this.binding.inspection);
+    if (native.tracks.length !== resource.clip.tracks.length || native.tracks.some((track, index) => {
+      const old = resource.clip.tracks[index];
+      return track.name !== old.name || track.ValueTypeName !== old.ValueTypeName || sampleSize(track) !== sampleSize(old);
+    })) throw new Error("Editing samples must preserve track bindings; play a new clip to change its bindings.");
+    const editable = resource.action;
+    if (!editable || !Array.isArray(editable._interpolants) || editable._interpolants.length !== native.tracks.length) {
+      throw new Error("This Three version does not support editing native action samples.");
+    }
+    this.dispatch(this.session.replace_clip(handle, JSON.stringify(ir)), native);
+  }
+  /** Native state for the owning adapter; never exposed through Polymer. */
+  getAction(handle) {
+    return this.resources.get(handle)?.action;
+  }
+  /** Deliver native completion after the borrowed mixer has finished sampling. */
+  flushEvents() {
+    if (this.disposed) return;
+    this.notificationScheduled = false;
+    for (const [handle, resource] of this.resources) {
+      if (resource.fadingOut && resource.action?.getEffectiveWeight() === 0) {
+        resource.fadingOut = false;
+        this.notifications.push({ type: "cancelled", handle });
       }
-      return values.length ? Math.min(...values) : 0;
+    }
+    this.flushNotifications();
+  }
+  subscribe(listener) {
+    if (this.disposed) throw new Error("Native playback connector is disposed.");
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
     };
-    return { positive: magnitude(positive), negative: magnitude(negative) };
   }
-  joint(node, calibration, ids) {
-    const object = this.model.getObjectByName(this.name(node));
-    if (!object) return void 0;
-    const yaw = { positive: this.binding(node, ids[0]), negative: this.binding(node, ids[1]) };
-    const pitch = { positive: this.binding(node, ids[2]), negative: this.binding(node, ids[3]) };
-    const roll = { positive: this.binding(node, ids[4]), negative: this.binding(node, ids[5]) };
-    const explicit = this.profile.gazeCalibration?.[calibration]?.opticalAxis;
-    let optical = explicit ? vector(explicit) : new Vector3();
-    if (optical.lengthSq() < EPSILON) {
-      const positiveAxis = (axis) => axis.positive ? axis.positive.axis.clone().multiplyScalar(Math.sign(axis.positive.radians)) : axis.negative?.axis.clone().multiplyScalar(-Math.sign(axis.negative.radians));
-      const yawAxis = positiveAxis(yaw);
-      const pitchAxis = positiveAxis(pitch);
-      if (yawAxis && pitchAxis) optical.crossVectors(yawAxis, pitchAxis);
-    }
-    if (optical.lengthSq() < EPSILON) return void 0;
-    const reference = this.references.get(object);
-    const ancestors = [];
-    for (let parent = object.parent; parent && parent !== this.model; parent = parent.parent) ancestors.push(parent);
-    const referenceParent = new Matrix4();
-    for (const parent of ancestors.reverse()) referenceParent.multiply(new Matrix4().fromArray(this.references.get(parent).localMatrix));
-    const rotation = reference.transform.rotation;
-    return {
-      object,
-      optical: optical.normalize(),
-      yaw,
-      pitch,
-      roll,
-      reference: new Quaternion(rotation.x, rotation.y, rotation.z, rotation.w),
-      referenceParent,
-      referenceScale: vector(reference.transform.scale)
+  dispose() {
+    if (this.disposed) return;
+    this.retryPending();
+    if (!this.sessionDisposed) {
+      const batch = this.session.dispose();
+      this.sessionDisposed = true;
+      this.dispatch(batch);
+    }
+    this.binding.mixer.removeEventListener("finished", this.finished);
+    this.rendering.dispose();
+    this.notifications.length = 0;
+    this.listeners.clear();
+    this.session.free();
+    this.disposed = true;
+  }
+  pauseFade(resource) {
+    const action = resource.action;
+    const fade = action?._weightInterpolant;
+    if (!action || !fade) return;
+    resource.pausedFade = {
+      seconds: Math.max(0, fade.parameterPositions[1] - resource.binding.mixer.time),
+      from: fade.evaluate(resource.binding.mixer.time)[0],
+      to: fade.sampleValues[1],
+      weight: action.weight
     };
+    action.stopFading();
+    action.setEffectiveWeight(resource.pausedFade.weight * resource.pausedFade.from);
+  }
+  resumeFade(resource) {
+    const action = resource.action;
+    const fade = resource.pausedFade;
+    if (!action || !fade) return;
+    resource.pausedFade = void 0;
+    action.setEffectiveWeight(fade.weight);
+    action.fadeIn(fade.seconds);
+    const interpolant = action._weightInterpolant;
+    interpolant.sampleValues[0] = fade.from;
+    interpolant.sampleValues[1] = fade.to;
+  }
+  beforeOperation() {
+    if (this.disposed || this.sessionDisposed) throw new Error("Native playback connector is disposed.");
+    this.retryPending();
+  }
+  retryPending() {
+    if (this.pending.length) this.drain();
+  }
+  dispatch(serialized, clip, afterCommands) {
+    const batch = JSON.parse(serialized);
+    this.pending.push({ batch, nextCommand: 0, clip, afterCommands });
+    this.drain();
+    return batch;
+  }
+  drain() {
+    const errors = [];
+    this.depth += 1;
+    try {
+      while (this.pending.length) {
+        const pending = this.pending[0];
+        while (pending.nextCommand < pending.batch.commands.length) {
+          const command = pending.batch.commands[pending.nextCommand];
+          try {
+            this.execute(command, pending.clip);
+          } catch (error) {
+            if (command.type === "release") throw asError(error);
+            const failure = asError(error);
+            errors.push(failure);
+            this.notifications.push({ type: "error", handle: command.handle, message: failure.message || "Native operation failed." });
+          }
+          pending.nextCommand += 1;
+        }
+        pending.afterCommands?.();
+        this.pending.shift();
+        for (const event of pending.batch.events) {
+          for (const listener of [...this.listeners]) {
+            try {
+              listener(event);
+            } catch (error) {
+              const failure = asError(error);
+              queueMicrotask(() => {
+                if (this.onError) this.onError(failure);
+                else throw failure;
+              });
+            }
+          }
+        }
+      }
+    } finally {
+      this.depth -= 1;
+    }
+    if (this.depth === 0 && !this.flushingNotifications) this.flushNotifications();
+    if (errors.length) throw errors[0];
+  }
+  execute(command, preparedClip) {
+    if (command.type === "release") {
+      const resource2 = this.resources.get(command.handle);
+      if (!resource2) return;
+      resource2.action?.stop();
+      resource2.binding.mixer.uncacheAction(resource2.clip, resource2.binding.model);
+      resource2.binding.mixer.uncacheClip(resource2.clip);
+      if (resource2.action) this.actionHandles.delete(resource2.action);
+      this.resources.delete(command.handle);
+      try {
+        this.onRelease?.(command.handle);
+      } catch (error) {
+        const failure = asError(error);
+        queueMicrotask(() => {
+          if (this.onError) this.onError(failure);
+          else throw failure;
+        });
+      }
+      return;
+    }
+    if (command.type === "replaceClip") {
+      const resource2 = this.resources.get(command.handle);
+      if (!resource2 || !preparedClip) throw new Error("Native clip edit has no owned resource.");
+      const action2 = resource2.action;
+      const tracks = preparedClip.tracks.map((track) => track.clone());
+      const interpolants = tracks.map((track, index) => {
+        const interpolant = track.createInterpolant(action2._interpolants[index].resultBuffer);
+        if (interpolant.settings) Object.assign(action2._interpolantSettings, interpolant.settings);
+        interpolant.settings = action2._interpolantSettings;
+        return interpolant;
+      });
+      resource2.clip.tracks = tracks;
+      action2._interpolants = interpolants;
+      return;
+    }
+    if (command.type === "play") {
+      if (!preparedClip) throw new Error("Native playback has no prepared clip.");
+      const resource2 = { clip: preparedClip, binding: this.binding };
+      this.resources.set(command.handle, resource2);
+      const settings = command.settings;
+      const action2 = this.binding.mixer.clipAction(preparedClip, this.binding.model, blendMode(settings.blendMode));
+      resource2.action = action2;
+      this.actionHandles.set(action2, command.handle);
+      action2.setLoop(loopMode(settings.loop.mode), settings.loop.count ?? Infinity);
+      action2.clampWhenFinished = settings.finalPose === "hold";
+      action2.setEffectiveTimeScale(settings.speed);
+      action2.setEffectiveWeight(settings.weight);
+      action2.time = settings.startSeconds;
+      if (!this.renderingEnabled) {
+        resource2.suspendedPaused = false;
+        action2.paused = true;
+      }
+      action2.play();
+      return;
+    }
+    const resource = this.resources.get(command.handle);
+    const action = resource?.action;
+    if (!resource || !action) throw new Error("Native playback action is unavailable.");
+    const control = command.control;
+    switch (control.type) {
+      case "pause":
+        resource.explicitlyPaused = true;
+        this.pauseFade(resource);
+        action.paused = true;
+        if (!this.renderingEnabled) this.resources.get(command.handle).suspendedPaused = true;
+        break;
+      case "resume":
+        resource.explicitlyPaused = false;
+        if (this.renderingEnabled) {
+          action.paused = false;
+          this.resumeFade(resource);
+        } else this.resources.get(command.handle).suspendedPaused = false;
+        break;
+      case "seek":
+        action.time = control.seconds;
+        break;
+      case "setSpeed":
+        action.setEffectiveTimeScale(control.speed);
+        break;
+      case "setWeight":
+        resource.pausedFade = void 0;
+        action.setEffectiveWeight(control.weight);
+        this.resources.get(command.handle).fadingOut = false;
+        break;
+      case "setBlendMode":
+        action.blendMode = blendMode(control.blendMode);
+        break;
+      case "setLoop":
+        action.setLoop(loopMode(control.loop.mode), control.loop.count ?? Infinity);
+        break;
+      case "setFinalPose":
+        action.clampWhenFinished = control.finalPose === "hold";
+        break;
+      case "fadeIn":
+        resource.pausedFade = void 0;
+        action.fadeIn(control.seconds);
+        resource.fadingOut = false;
+        if (resource.explicitlyPaused || !this.renderingEnabled) this.pauseFade(resource);
+        break;
+      case "fadeOut":
+        resource.pausedFade = void 0;
+        if (control.seconds === 0) this.notifications.push({ type: "cancelled", handle: command.handle });
+        else {
+          action.fadeOut(control.seconds);
+          resource.fadingOut = true;
+          if (resource.explicitlyPaused || !this.renderingEnabled) this.pauseFade(resource);
+        }
+        break;
+      case "stop":
+        throw new Error("Rust must translate stop into a resource release.");
+    }
   }
-  restore() {
-    for (const [object, value] of this.saved) {
-      const current = object.quaternion;
-      const norm = Math.sqrt(current.lengthSq() * value.applied.lengthSq());
-      if (norm > 0 && Number.isFinite(norm) && Math.abs(current.dot(value.applied)) / norm > 1 - 1e-12) {
-        current.copy(value.base);
+  flushNotifications() {
+    if (this.flushingNotifications || this.depth > 0 || this.disposed || this.notificationScheduled) return;
+    this.flushingNotifications = true;
+    try {
+      while (this.notifications.length) {
+        const event = this.notifications.shift();
+        this.dispatch(this.session.notify(JSON.stringify(event)));
       }
+    } finally {
+      this.flushingNotifications = false;
     }
-    this.saved.clear();
-    this.model.updateMatrixWorld(true);
   }
-  controlLimits() {
-    const combine = (head, eye) => ({
-      negative: head.negative + eye.negative,
-      positive: head.positive + eye.positive
+};
+
+// three/character.ts
+var json2 = (value) => JSON.stringify(value ?? {});
+var targetKey = (target) => JSON.stringify([target.kind, target.meshId, target.morphTargetId, target.boneId, target.objectId, target.property]);
+var copy = (value) => JSON.parse(JSON.stringify(value));
+var parse = (value) => JSON.parse(value);
+var finite2 = (value) => typeof value === "number" && Number.isFinite(value);
+var intensity = (options, fallback = 1) => {
+  const value = options.intensityScale ?? options.intensity ?? options.weight;
+  return finite2(value) ? Math.max(0, Math.min(2, value)) : fallback;
+};
+var presetId = (value) => value?.trim().toLowerCase() || "cc4";
+function supportsRustEmbodyPreset(value) {
+  return requireInitializedEmbodyCore().has_preset(presetId(value));
+}
+var Embody = class _Embody {
+  constructor(config = {}) {
+    this.config = config;
+    __publicField(this, "meshes", []);
+    __publicField(this, "meshByName", /* @__PURE__ */ new Map());
+    __publicField(this, "bones", {});
+    __publicField(this, "wasm", requireInitializedEmbodyCore());
+    __publicField(this, "core");
+    __publicField(this, "inspector", new ThreeModelInspector());
+    __publicField(this, "applier", new ThreeFrameApplier());
+    __publicField(this, "references", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "referenceBindings", /* @__PURE__ */ new Map());
+    __publicField(this, "boundModel");
+    __publicField(this, "inspection");
+    __publicField(this, "connector");
+    __publicField(this, "profile");
+    __publicField(this, "profileSource");
+    __publicField(this, "profileMode");
+    __publicField(this, "preset");
+    __publicField(this, "sources", /* @__PURE__ */ new Map());
+    __publicField(this, "playbacks", /* @__PURE__ */ new Map());
+    __publicField(this, "current", /* @__PURE__ */ new Map());
+    __publicField(this, "playDepth", 0);
+    __publicField(this, "pendingEvents", []);
+    __publicField(this, "bindingGeneration", 0);
+    __publicField(this, "disposed", false);
+    __publicField(this, "rendering", true);
+    __publicField(this, "timeScale", 1);
+    __publicField(this, "nextLiveTarget", 0);
+    __publicField(this, "liveTargets", /* @__PURE__ */ new Map());
+    __publicField(this, "hairObjects", /* @__PURE__ */ new Map());
+    __publicField(this, "hairConfig", {});
+    __publicField(this, "hairAppearance", {
+      hairColor: copy(DEFAULT_HAIR_COLOR_APPEARANCE),
+      eyebrowColor: copy(DEFAULT_HAIR_COLOR_APPEARANCE),
+      showOutline: false,
+      outlineColor: "#000000",
+      outlineOpacity: 1
     });
-    return { yaw: combine(this.limits.headYaw, this.limits.eyeYaw), pitch: combine(this.limits.headPitch, this.limits.eyePitch) };
-  }
-  angles(direction) {
-    const local = direction.clone().applyQuaternion(this.model.getWorldQuaternion(new Quaternion()).invert());
-    return {
-      yaw: Math.atan2(local.x, local.z) * 180 / Math.PI,
-      pitch: Math.atan2(local.y, Math.hypot(local.x, local.z)) * 180 / Math.PI
+    const mode = config.profileMode ?? "preset";
+    if (mode !== "profile" && mode !== "preset") throw new Error(`Unknown profile mode: ${mode}`);
+    if (mode === "profile" && !config.profile) throw new Error("Resolved profile mode requires a profile object.");
+    this.profileMode = mode;
+    this.preset = presetId(config.presetId ?? config.presetType);
+    if (mode === "preset" && !this.wasm.has_preset(this.preset)) throw new Error(`Unknown Embody preset: ${this.preset}`);
+    this.profileSource = this.validateProfile(config.profile ?? {});
+    this.profile = this.resolveProfile(this.profileSource);
+    this.core = new this.wasm.RuntimeCore(0);
+  }
+  get model() {
+    return this.boundModel;
+  }
+  static async create(config = {}) {
+    await initEmbodyCore();
+    return new _Embody(config);
+  }
+  assertAlive() {
+    if (this.disposed) throw new Error("Character is disposed.");
+  }
+  requireModel() {
+    this.assertAlive();
+    if (!this.boundModel) throw new Error("Bind a character model with onReady before using this operation.");
+    return this.boundModel;
+  }
+  requireConnector() {
+    this.requireModel();
+    if (!this.connector) throw new Error("Character playback is not bound.");
+    return this.connector;
+  }
+  validateProfile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Embody profile must be a JSON object.");
+    return copy(value);
+  }
+  resolveProfile(value) {
+    return this.profileMode === "profile" ? copy(value) : parse(this.wasm.merge_embedded_preset(this.preset, json2(value)));
+  }
+  onReady(options) {
+    this.assertAlive();
+    const model = options.model;
+    if (!model?.isObject3D) throw new Error("onReady requires a Three Object3D model.");
+    const reference = this.references.get(model) ?? options.referencePose ?? (!this.boundModel ? this.config.referencePose : void 0) ?? captureModelReferencePose(model);
+    const inspection = this.inspector.inspectModel(model, { meshes: options.meshes, profile: this.profile, referencePose: reference });
+    this.bind(model, reference, inspection, this.profileSource, this.profile);
+    if (options.animations) this.loadAnimationClips(options.animations);
+  }
+  bind(model, reference, inspection, source, profile, preserveLiveState = true) {
+    const referenceBindings = bindModelReferencePose(model, reference);
+    const runtimeDescriptor = {
+      ...inspection.descriptor,
+      morphTargets: inspection.descriptor.morphTargets.map((morph) => {
+        const binding = inspection.morphBindings.get(morph.id);
+        const baseline = binding && referenceBindings.get(binding.mesh)?.morphInfluences?.[binding.index];
+        return { ...morph, initialValue: baseline ?? morph.initialValue };
+      })
     };
+    const replacingModel = !!this.boundModel && this.boundModel !== model;
+    const core2 = new this.wasm.RuntimeCore(0);
+    try {
+      if (this.profileMode === "profile") core2.configure_with_profile(json2(source), json2(runtimeDescriptor));
+      else core2.configure_with_preset(this.preset, json2(source), json2(runtimeDescriptor));
+      if (preserveLiveState && this.boundModel) core2.copy_live_state_from(this.core);
+      for (const registered of replacingModel ? [] : this.sources.values()) {
+        if (registered.kind === "native") {
+          const [clip] = serializeAnimationClips(model, [registered.clip], inspection);
+          core2.register_animation_clip(json2(clip), "baked");
+        }
+      }
+    } catch (error) {
+      core2.free();
+      throw error;
+    }
+    try {
+      this.connector?.dispose();
+    } catch (error) {
+      core2.free();
+      throw error;
+    }
+    this.core.free();
+    this.core = core2;
+    if (replacingModel) this.sources.clear();
+    this.boundModel = model;
+    this.inspection = inspection;
+    this.referenceBindings = referenceBindings;
+    this.references.set(model, reference);
+    this.profileSource = source;
+    this.profile = profile;
+    this.bindingGeneration += 1;
+    this.playbacks.clear();
+    this.current.clear();
+    this.liveTargets.clear();
+    this.meshes.splice(0, this.meshes.length, ...inspection.morphMeshes.length ? inspection.morphMeshes : inspection.allMeshes);
+    this.meshByName = inspection.meshByName;
+    this.bones = inspection.bones;
+    this.applier.setBindings(inspection);
+    this.applier.applyMeshMaterialConfigs(model, profile.meshes ?? {});
+    const session = new this.wasm.NativePlaybackSession();
+    try {
+      this.connector = new ThreeNativePlaybackConnector(session, {
+        model,
+        inspection,
+        onRelease: (id) => {
+          const playback = this.playbacks.get(id);
+          if (playback?.terminal) this.forget(playback);
+        }
+      });
+    } catch (error) {
+      session.free();
+      throw error;
+    }
+    this.connector.rebind(model.uuid, String(this.bindingGeneration));
+    this.connector.setRendering(this.rendering);
+    this.connector.setTimeScale(this.timeScale);
+    this.connector.subscribe((event) => this.onPlaybackEvent(event));
+    this.hairConfig = parse(this.core.get_hair_config_json());
+    this.registerHairObjects(inspection.allMeshes.filter((mesh) => ["hair", "eyebrow"].includes(this.meshCategory(mesh))));
+    if (preserveLiveState) this.commitLive();
+  }
+  bindModel(meshes) {
+    const model = this.requireModel();
+    const reference = this.references.get(model);
+    const inspection = this.inspector.inspectModel(model, { meshes, profile: this.profile, referencePose: reference });
+    this.bind(model, reference, inspection, this.profileSource, this.profile);
+  }
+  extendReferencePose() {
+    const model = this.requireModel();
+    const reference = extendModelReferencePose(model, this.references.get(model));
+    const inspection = this.inspector.inspectModel(model, { profile: this.profile, referencePose: reference });
+    this.bind(model, reference, inspection, this.profileSource, this.profile);
+    return reference;
+  }
+  setProfile(value) {
+    this.assertAlive();
+    const source = this.validateProfile(value);
+    const profile = this.resolveProfile(source);
+    if (!this.boundModel) {
+      this.profileSource = source;
+      this.profile = profile;
+      return;
+    }
+    const reference = this.references.get(this.boundModel);
+    const inspection = this.inspector.inspectModel(this.boundModel, { profile, referencePose: reference });
+    this.bind(this.boundModel, reference, inspection, source, profile, false);
   }
-  ratio(degrees, limits) {
-    const capacity = degrees < 0 ? limits.negative : limits.positive;
-    return capacity > EPSILON ? bounded(degrees / capacity) : 0;
+  getProfile() {
+    return this.profile;
   }
-  degrees(control, limits) {
-    return bounded(control) * (control < 0 ? limits.negative : limits.positive);
+  getProfileMode() {
+    return this.profileMode;
   }
-  direction(yawDegrees, pitchDegrees) {
-    const yaw = yawDegrees * Math.PI / 180;
-    const pitch = pitchDegrees * Math.PI / 180;
-    return new Vector3(Math.sin(yaw) * Math.cos(pitch), Math.sin(pitch), Math.cos(yaw) * Math.cos(pitch)).applyQuaternion(this.model.getWorldQuaternion(new Quaternion())).normalize();
+  getPresetId() {
+    return this.profileMode === "preset" ? this.preset : null;
   }
-  ray(joint) {
-    return joint.optical.clone().transformDirection(joint.object.matrixWorld);
+  supportsPreset(value) {
+    return supportsRustEmbodyPreset(value);
   }
-  /** Seed motor clips from the rendered bearing when enabling pose constraints. */
-  readControlState(options = {}) {
-    this.model.updateMatrixWorld(true);
-    const active = this.controlLimits();
-    const gaze = new Vector3();
-    const eyeBases = /* @__PURE__ */ new Map();
-    const eyeGain = contribution(options.eyeIntensity);
-    for (const eye of this.eyes) {
-      const value = options.eyeBaseQuaternions?.[eye.object.name];
-      const base = value ? new Quaternion(finite2(value.x), finite2(value.y), finite2(value.z), finite2(value.w, 1)).normalize() : (this.saved.get(eye.object)?.base ?? eye.object.quaternion).clone();
-      const actual = this.ray(eye);
-      const excursion = this.solveJoint(eye, actual, 0, base);
-      gaze.add(this.jointPose(
-        eye,
-        base,
-        eyeGain > EPSILON ? bounded(excursion.yaw / eyeGain) : 0,
-        eyeGain > EPSILON ? bounded(excursion.pitch / eyeGain) : 0
-      ).direction);
-      eyeBases.set(eye, { base, actual });
-    }
-    if (gaze.lengthSq() < EPSILON) gaze.copy(this.head ? this.ray(this.head) : this.direction(0, 0));
-    const eyes = this.angles(gaze.normalize());
-    let head = this.angles(this.direction(0, 0));
-    let headSeedLimited = false;
-    if (this.head) {
-      const value = options.headBaseQuaternion;
-      const base = value ? new Quaternion(finite2(value.x), finite2(value.y), finite2(value.z), finite2(value.w, 1)).normalize() : (this.saved.get(this.head.object)?.base ?? this.head.object.quaternion).clone();
-      const actual = this.ray(this.head);
-      const excursion = this.solveJoint(this.head, actual, 0, base);
-      const gain = contribution(options.headIntensity);
-      const yaw = gain > EPSILON ? bounded(excursion.yaw / gain) : 0;
-      const pitch = gain > EPSILON ? bounded(excursion.pitch / gain) : 0;
-      const preferred = this.jointPose(
-        this.head,
-        this.head.reference,
-        yaw,
-        pitch,
-        0,
-        this.referenceParent(this.head),
-        this.head.referenceScale
-      );
-      head = this.angles(preferred.direction);
-      const represented = this.direction(
-        this.degrees(this.ratio(head.yaw, this.limits.headYaw), this.limits.headYaw),
-        this.degrees(this.ratio(head.pitch, this.limits.headPitch), this.limits.headPitch)
-      );
-      headSeedLimited = this.contributedPose(this.head, represented, 0, gain, true, base).direction.angleTo(actual) > 1e-3;
-    }
-    const destination = options.worldTarget ? this.angles(vector(options.worldTarget).sub(this.origin())) : void 0;
-    const eyeTarget = { x: -this.ratio(eyes.yaw, active.yaw), y: this.ratio(eyes.pitch, active.pitch), z: 0 };
-    const origin = this.origin();
-    const distance = options.worldTarget ? Math.max(EPSILON, vector(options.worldTarget).distanceTo(origin)) : 1;
-    const representedTarget = origin.clone().addScaledVector(this.direction(
-      this.degrees(-eyeTarget.x, active.yaw),
-      this.degrees(eyeTarget.y, active.pitch)
-    ), distance);
-    const eyeSeedLimited = this.eyes.some((eye) => {
-      const { base, actual } = eyeBases.get(eye);
-      const desired = representedTarget.clone().sub(eye.object.getWorldPosition(new Vector3())).normalize();
-      return this.contributedPose(eye, desired, 0, eyeGain, false, base).direction.angleTo(actual) > 1e-3;
-    });
+  onPlaybackEvent(event) {
+    if (this.playDepth) {
+      this.pendingEvents.push(event);
+      return;
+    }
+    const playback = this.playbacks.get(event.handle);
+    if (!playback) return;
+    playback.terminal = true;
+    if (!playback.connector.getAction(playback.id)) {
+      this.playbacks.delete(playback.id);
+      if (this.current.get(playback.source.name) === playback) this.current.delete(playback.source.name);
+    }
+    playback.notify({ ...event, actionId: event.handle, clipName: playback.source.name });
+  }
+  compile(source, options) {
+    const buildOptions = { ..."options" in source ? source.options : {}, ...options, intensityScale: intensity(options) };
+    switch (source.kind) {
+      case "curves":
+        return parse(this.core.build_clip(source.name, json2(source.input), json2(buildOptions)));
+      case "typed":
+        return parse(this.core.build_typed_clip(source.name, json2(source.input), json2(buildOptions)));
+      case "semantic":
+        return parse(this.core.build_semantic_clip(source.name, json2(source.input), json2(buildOptions)));
+      case "compiled":
+        return source.clip;
+      case "native":
+        throw new Error("Native animation sources do not require semantic compilation.");
+    }
+  }
+  restValues(track) {
+    const model = this.requireModel();
+    const parsed = PropertyBinding.parseTrackName(track.name);
+    let object = PropertyBinding.findNode(model, parsed.nodeName);
+    if (parsed.objectName === "bones" && object) {
+      const skeleton = object.skeleton;
+      object = skeleton?.bones.find((bone) => bone.name === String(parsed.objectIndex)) ?? skeleton?.bones[Number(parsed.objectIndex)];
+    }
+    if (!object) return void 0;
+    const reference = this.referenceBindings.get(object);
+    if (!reference) return void 0;
+    switch (parsed.propertyName) {
+      case "quaternion":
+        return Object.values(reference.transform.rotation);
+      case "position":
+        return Object.values(reference.transform.position);
+      case "scale":
+        return Object.values(reference.transform.scale);
+      case "morphTargetInfluences": {
+        const mesh = object;
+        const index = typeof parsed.propertyIndex === "string" && !/^\d+$/.test(parsed.propertyIndex) ? mesh.morphTargetDictionary?.[parsed.propertyIndex] : Number(parsed.propertyIndex);
+        return [reference.morphInfluences?.[index ?? -1] ?? 0];
+      }
+      default:
+        return void 0;
+    }
+  }
+  materialize(source, options, inheritedStarts = /* @__PURE__ */ new Map()) {
+    if (!this.inspection) throw new Error("Character has no model inspection.");
+    const nativeSource = source.kind === "native";
+    let ir;
+    if (!nativeSource) {
+      ir = this.compile(source, options);
+    }
+    const clip = nativeSource ? source.clip.clone() : createAnimationClipFromClipIR(ir, this.inspection);
+    if (ir) {
+      const predecessor = this.current.get(source.name);
+      const outgoing = predecessor?.connector.getAction(predecessor.id);
+      for (let index = 0; index < ir.tracks.length; index += 1) {
+        if (!ir.tracks[index].inheritStart) continue;
+        const track = clip.tracks[index];
+        if (!track) throw new Error("Every inherited track must bind to the character.");
+        const startKey = `${index}:${track.name}`;
+        let previous = inheritedStarts.get(startKey);
+        if (!previous && options.blendMode === "additive") {
+          const rest = this.restValues(track);
+          const candidates = outgoing?.getClip().tracks;
+          const oldTrack = candidates?.[index]?.name === track.name ? candidates[index] : candidates?.find((candidate) => candidate.name === track.name);
+          if (oldTrack && outgoing) {
+            previous = Array.from(oldTrack.createInterpolant().evaluate(outgoing.time));
+            if (outgoing.blendMode === AdditiveAnimationBlendMode && rest) {
+              previous = track.ValueTypeName === "quaternion" ? new Quaternion().fromArray(rest).multiply(new Quaternion().fromArray(previous)).toArray() : previous.map((value, axis) => value + rest[axis]);
+            }
+          } else if (rest) previous = rest;
+        }
+        if (previous) track.values.set(previous, 0);
+        inheritedStarts.set(startKey, previous ?? Array.from(track.values.subarray(0, track.getValueSize())));
+      }
+    }
+    const authoredAdditive = clip.blendMode === AdditiveAnimationBlendMode;
+    const scale = intensity(options);
+    const additive = options.blendMode === "additive" || options.blendMode === void 0 && authoredAdditive;
+    this.applyEasing(clip, options.easing ?? "linear", nativeSource && (scale !== 1 || additive !== authoredAdditive));
+    if (nativeSource && scale !== 1) {
+      for (const track of clip.tracks) {
+        const rest = authoredAdditive ? track.ValueTypeName === "quaternion" ? [0, 0, 0, 1] : Array(track.getValueSize()).fill(0) : this.restValues(track);
+        if (!rest) continue;
+        const stride = track.getValueSize();
+        const cubic = track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true;
+        const width = cubic ? stride / 3 : stride;
+        for (let offset = 0; offset < track.values.length; offset += stride) {
+          const sample = offset + (cubic ? width : 0);
+          if (track.ValueTypeName === "quaternion") {
+            const neutral = new Quaternion().fromArray(rest);
+            const value = new Quaternion().fromArray(track.values, sample);
+            neutral.slerp(value, scale).toArray(track.values, sample);
+          } else {
+            for (let axis = 0; axis < width; axis += 1) {
+              track.values[sample + axis] = rest[axis] + (track.values[sample + axis] - rest[axis]) * scale;
+              if (cubic) {
+                track.values[offset + axis] *= scale;
+                track.values[offset + 2 * width + axis] *= scale;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (additive && !authoredAdditive) {
+      const reference = clip.clone();
+      for (const track of reference.tracks) {
+        const rest = this.restValues(track);
+        if (!rest) continue;
+        const width = track.getValueSize();
+        for (let offset = 0; offset < track.values.length; offset += width) track.values.set(rest, offset);
+      }
+      const explicitReference = options.additiveReferenceTimeSec;
+      if (finite2(explicitReference)) AnimationUtils.makeClipAdditive(clip, explicitReference * 30, clip.clone(), 30);
+      else AnimationUtils.makeClipAdditive(clip, 0, reference, 30);
+    }
+    if (!additive && authoredAdditive) {
+      for (const track of clip.tracks) {
+        const rest = this.restValues(track);
+        if (!rest) continue;
+        const width = track.getValueSize();
+        for (let offset = 0; offset < track.values.length; offset += width) {
+          if (track.ValueTypeName === "quaternion") new Quaternion().fromArray(rest).multiply(new Quaternion().fromArray(track.values, offset)).toArray(track.values, offset);
+          else for (let axis = 0; axis < width; axis += 1) track.values[offset + axis] += rest[axis];
+        }
+      }
+    }
+    clip.blendMode = additive ? AdditiveAnimationBlendMode : NormalAnimationBlendMode;
+    return clip;
+  }
+  applyEasing(clip, easing, resampleCustom = false) {
+    if (easing === "linear" && !resampleCustom) return;
+    const curve = (progress2) => {
+      switch (easing) {
+        case "easeIn":
+          return progress2 * progress2;
+        case "easeOut":
+          return 1 - (1 - progress2) ** 2;
+        case "easeInOut":
+          return progress2 < 0.5 ? 2 * progress2 * progress2 : 1 - (-2 * progress2 + 2) ** 2 / 2;
+        case "easeInOutCubic":
+          return progress2 < 0.5 ? 4 * progress2 ** 3 : 1 - (-2 * progress2 + 2) ** 3 / 2;
+        default:
+          return progress2;
+      }
+    };
+    for (const track of clip.tracks) {
+      if (track.getInterpolation() === InterpolateDiscrete || track.times.length === 0) continue;
+      const customInterpolant = track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true;
+      if (track.times.length === 1) {
+        if (customInterpolant && resampleCustom) {
+          track.values = new Float32Array(track.createInterpolant().evaluate(track.times[0]));
+          track.setInterpolation(InterpolateLinear);
+        }
+        continue;
+      }
+      if ((customInterpolant || track.getInterpolation() !== InterpolateLinear) && easing === "linear" && !resampleCustom) continue;
+      const stride = track.getValueSize();
+      const width = customInterpolant ? stride / 3 : stride;
+      const interpolant = track.createInterpolant();
+      const times = [];
+      const values = [];
+      const append = (time, value) => {
+        times.push(time);
+        for (let axis = 0; axis < width; axis += 1) values.push(value[axis]);
+      };
+      for (let index = 0; index < track.times.length - 1; index += 1) {
+        const start = track.times[index];
+        const end = track.times[index + 1];
+        const offset = index * stride + (customInterpolant ? width : 0);
+        append(start, track.values.subarray(offset, offset + width));
+        if (end <= start) continue;
+        for (let part = 1; part < 16; part += 1) {
+          const progress2 = part / 16;
+          append(start + (end - start) * progress2, interpolant.evaluate(start + (end - start) * curve(progress2)));
+        }
+      }
+      const lastOffset = (track.times.length - 1) * stride + (customInterpolant ? width : 0);
+      append(track.times[track.times.length - 1], track.values.subarray(lastOffset, lastOffset + width));
+      track.times = new Float32Array(times);
+      track.values = new Float32Array(values);
+      if (customInterpolant || track.getInterpolation() !== InterpolateLinear) track.setInterpolation(InterpolateLinear);
+    }
+  }
+  nativeOptions(options, clip) {
+    const mode = clip.duration === 0 ? "once" : options.loopMode ?? (options.loop === true ? "repeat" : "once");
+    const count = finite2(options.repeatCount) && options.repeatCount > 0 ? options.repeatCount : null;
+    let speed = options.speed ?? options.playbackRate ?? options.rate ?? options.timeScale ?? 1;
+    if (options.reverse === true) speed = -Math.abs(speed);
     return {
-      target: destination ? { x: -this.ratio(destination.yaw, active.yaw), y: this.ratio(destination.pitch, active.pitch), z: 0 } : void 0,
-      eyeTarget,
-      headTarget: { x: -this.ratio(head.yaw, this.limits.headYaw), y: this.ratio(head.pitch, this.limits.headPitch), z: 0 },
-      headRoll: 0,
-      headSeedLimited,
-      eyeSeedLimited
+      startSeconds: finite2(options.time) ? options.time : finite2(options.offsetSec) ? options.offsetSec : speed < 0 ? clip.duration : 0,
+      speed,
+      weight: finite2(options.mixerWeight) ? options.mixerWeight : 1,
+      blendMode: clip.blendMode === AdditiveAnimationBlendMode ? "additive" : "normal",
+      loop: { mode: mode === "once" ? "once" : mode === "pingpong" || mode === "pingPong" ? "pingPong" : "repeat", count: mode === "once" ? 1 : count },
+      finalPose: options.finalPose === "release" || options.clampWhenFinished === false ? "release" : "hold"
     };
   }
-  origin() {
-    const origin = new Vector3();
-    for (const eye of this.eyes) origin.add(eye.object.getWorldPosition(new Vector3()));
-    if (this.eyes.length) origin.divideScalar(this.eyes.length);
-    else if (this.head) origin.copy(this.head.object.getWorldPosition(new Vector3()));
-    else origin.copy(this.model.getWorldPosition(new Vector3()));
-    return origin;
-  }
-  rotation(axis, value) {
-    const binding = value < 0 ? axis.negative : axis.positive;
-    return binding ? new Quaternion().setFromAxisAngle(binding.axis, Math.abs(bounded(value)) * binding.radians) : new Quaternion();
-  }
-  referenceParent(joint) {
-    return new Matrix4().multiplyMatrices(this.model.matrixWorld, joint.referenceParent);
-  }
-  jointPose(joint, base, yaw, pitch, roll = 0, parent = joint.object.parent?.matrixWorld ?? new Matrix4(), scale = joint.object.scale) {
-    const object = joint.object;
-    const quaternion = base.clone().multiply(this.rotation(joint.yaw, yaw)).multiply(this.rotation(joint.pitch, pitch)).multiply(this.rotation(joint.roll, roll));
-    const matrix = new Matrix4().multiplyMatrices(parent, new Matrix4().compose(object.position, quaternion, scale));
-    return { quaternion, direction: joint.optical.clone().transformDirection(matrix) };
-  }
-  solveJoint(joint, desired, roll = 0, base = joint.object.quaternion.clone(), parent = joint.object.parent?.matrixWorld ?? new Matrix4(), scale = joint.object.scale) {
-    const evaluate = (yaw2, pitch2) => this.jointPose(joint, base, yaw2, pitch2, roll, parent, scale);
-    let yaw = 0;
-    let pitch = 0;
-    let best = evaluate(yaw, pitch);
-    for (let iteration = 0; iteration < 24; iteration += 1) {
-      const error = desired.clone().sub(best.direction);
-      if (error.lengthSq() < 1e-14) break;
-      const derivative = (axis) => {
-        const value = axis === 0 ? yaw : pitch;
-        const lo = Math.max(-1, value - 1e-4);
-        const hi = Math.min(1, value + 1e-4);
-        return evaluate(axis === 0 ? hi : yaw, axis === 1 ? hi : pitch).direction.sub(evaluate(axis === 0 ? lo : yaw, axis === 1 ? lo : pitch).direction).divideScalar(hi - lo);
+  validateEasing(options) {
+    if (options.easing !== void 0 && !["linear", "easeIn", "easeOut", "easeInOut", "easeInOutCubic"].includes(options.easing)) throw new Error(`Unknown playback easing: ${options.easing}`);
+  }
+  handle(source, options, autoPlay) {
+    options = { ..."options" in source ? source.options : {}, ...options };
+    const listeners = /* @__PURE__ */ new Set();
+    const generation = this.bindingGeneration;
+    let current;
+    let resolvePromise = () => {
+    };
+    const result = { name: source.name };
+    Object.defineProperty(result, "finished", { get: () => result.promise, enumerable: true });
+    const newPromise = () => {
+      result.promise = new Promise((resolve) => {
+        resolvePromise = resolve;
+      });
+    };
+    newPromise();
+    result.subscribe = (listener) => {
+      const callback = typeof listener === "function" ? listener : (event) => listener.next(event);
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
       };
-      const a = derivative(0);
-      const b = derivative(1);
-      const aa = a.dot(a) + 1e-7;
-      const ab = a.dot(b);
-      const bb = b.dot(b) + 1e-7;
-      const determinant = aa * bb - ab * ab;
-      if (determinant < 1e-14) break;
-      const ay = a.dot(error);
-      const by = b.dot(error);
-      const dy = Math.max(-0.5, Math.min(0.5, (ay * bb - by * ab) / determinant));
-      const dp = Math.max(-0.5, Math.min(0.5, (by * aa - ay * ab) / determinant));
-      let improved = false;
-      for (const step of [1, 0.5, 0.25, 0.125]) {
-        const nextYaw = bounded(yaw + dy * step);
-        const nextPitch = bounded(pitch + dp * step);
-        const next = evaluate(nextYaw, nextPitch);
-        if (next.direction.distanceToSquared(desired) < error.lengthSq()) {
-          yaw = nextYaw;
-          pitch = nextPitch;
-          best = next;
-          improved = true;
-          break;
+    };
+    const start = () => {
+      if (generation !== this.bindingGeneration) throw new Error("Playback handle belongs to an obsolete model binding.");
+      this.validateEasing(options);
+      const connector = this.requireConnector();
+      const inheritedStarts = /* @__PURE__ */ new Map();
+      const clip = this.materialize(source, options, inheritedStarts);
+      const hairMotion = this.authoredHeadMotion(clip);
+      const previous = this.current.get(source.name);
+      const settings = this.nativeOptions(options, clip);
+      if (previous && connector.getAction(previous.id)) settings.replace = previous.id;
+      if (current) newPromise();
+      const resolve = resolvePromise;
+      let settled = false;
+      this.playDepth += 1;
+      let id;
+      try {
+        id = connector.playNativeClip(clip, settings);
+      } catch (error) {
+        this.playDepth -= 1;
+        while (!this.playDepth && this.pendingEvents.length) this.onPlaybackEvent(this.pendingEvents.shift());
+        throw error;
+      }
+      const playback = {
+        id,
+        source,
+        options: { ...options, intensityScale: intensity(options) },
+        connector,
+        terminal: false,
+        inheritedStarts,
+        replay: (next) => {
+          options = next;
+          return start();
+        },
+        notify: (event) => {
+          if (settled) return;
+          settled = true;
+          resolve(event);
+          for (const listener of [...listeners]) {
+            try {
+              listener(event);
+            } catch (error) {
+              queueMicrotask(() => {
+                throw error;
+              });
+            }
+          }
         }
+      };
+      current = playback;
+      result.actionId = id;
+      this.playbacks.set(id, playback);
+      this.current.set(source.name, playback);
+      const ensure = () => {
+        this.assertAlive();
+        if (this.connector !== connector || !connector.getAction(id)) throw new Error("Unknown, released or obsolete playback handle.");
+      };
+      const control = (command) => {
+        ensure();
+        connector.control(id, command);
+        if (command.type === "stop") this.forget(playback);
+        return result;
+      };
+      result.stop = result.cancel = () => {
+        if (this.connector !== connector || !connector.getAction(id)) return result;
+        ensure();
+        const seconds = finite2(playback.options.fadeOutSec) ? playback.options.fadeOutSec : 0;
+        if (seconds > 0 && !playback.terminal) connector.fadeOut(id, seconds);
+        else control({ type: "stop" });
+        return result;
+      };
+      result.pause = () => control({ type: "pause" });
+      result.resume = () => {
+        ensure();
+        if (playback.terminal) {
+          options = { ...playback.options, time: connector.getAction(id).time };
+          return start();
+        }
+        return control({ type: "resume" });
+      };
+      result.setSpeed = result.setPlaybackRate = (speed) => {
+        ensure();
+        this.updatePlayback(playback, { speed });
+        return result;
+      };
+      result.setTime = result.seek = (seconds) => control({ type: "seek", seconds });
+      result.setWeight = result.setIntensity = (value) => {
+        ensure();
+        this.updatePlayback(playback, { intensityScale: value });
+        return result;
+      };
+      result.updateParams = result.setParams = (value) => {
+        ensure();
+        this.updatePlayback(playback, value);
+        return result;
+      };
+      try {
+        const fade = options.fadeInSec ?? options.crossfadeDuration;
+        if (finite2(fade) && fade > 0) connector.fadeIn(id, fade);
+      } finally {
+        this.playDepth -= 1;
+        while (!this.playDepth && this.pendingEvents.length) this.onPlaybackEvent(this.pendingEvents.shift());
+      }
+      if (hairMotion && connector.getAction(id)) {
+        this.playHairImpulse(hairMotion.horizontal, hairMotion.vertical);
+        this.setHairGravity(hairMotion.pitch, clip.duration);
+      }
+      return result;
+    };
+    result.play = () => {
+      if (current) options = { ...current.options };
+      return start();
+    };
+    const beforePlay = () => {
+      throw new Error("Play this compiled clip before changing playback.");
+    };
+    result.stop = result.cancel = () => result;
+    result.pause = result.resume = beforePlay;
+    result.updateParams = result.setParams = (patch) => {
+      this.assertAlive();
+      this.validateEasing(patch);
+      options = { ...options, ...patch };
+      if ("finalPose" in patch && !("clampWhenFinished" in patch)) options.clampWhenFinished = patch.finalPose !== "release";
+      if ("clampWhenFinished" in patch && !("finalPose" in patch)) options.finalPose = patch.clampWhenFinished === false ? "release" : "hold";
+      if ("loop" in patch && !("loopMode" in patch)) options.loopMode = patch.loop ? "repeat" : "once";
+      if ("loopMode" in patch && !("repeatCount" in patch)) delete options.repeatCount;
+      if ("weight" in patch || "intensity" in patch || "intensityScale" in patch) options.intensityScale = intensity(patch);
+      if ("time" in patch || "offsetSec" in patch) options.time = patch.time ?? patch.offsetSec;
+      if ("speed" in patch || "playbackRate" in patch || "rate" in patch || "timeScale" in patch || "reverse" in patch) {
+        let speed = patch.speed ?? patch.playbackRate ?? patch.rate ?? patch.timeScale ?? options.speed ?? options.playbackRate ?? options.rate ?? options.timeScale ?? 1;
+        if ("reverse" in patch) speed = Math.abs(speed) * (patch.reverse ? -1 : 1);
+        options.speed = speed;
+        delete options.reverse;
+      }
+      return result;
+    };
+    result.setWeight = result.setIntensity = (value) => result.updateParams({ intensityScale: value });
+    result.setSpeed = result.setPlaybackRate = (speed) => result.updateParams({ speed });
+    result.setTime = result.seek = (time) => result.updateParams({ time });
+    return autoPlay ? start() : result;
+  }
+  forget(playback) {
+    this.playbacks.delete(playback.id);
+    if (this.current.get(playback.source.name) === playback) this.current.delete(playback.source.name);
+  }
+  updatePlayback(playback, patch) {
+    this.validateEasing(patch);
+    const connector = playback.connector;
+    const action = connector.getAction(playback.id);
+    if (connector !== this.connector || !action) throw new Error("Unknown, released or obsolete playback handle.");
+    const options = { ...playback.options, ...patch };
+    if ("finalPose" in patch && !("clampWhenFinished" in patch)) options.clampWhenFinished = patch.finalPose !== "release";
+    if ("clampWhenFinished" in patch && !("finalPose" in patch)) options.finalPose = patch.clampWhenFinished === false ? "release" : "hold";
+    if ("loop" in patch && !("loopMode" in patch)) options.loopMode = patch.loop ? "repeat" : "once";
+    if ("loopMode" in patch && !("repeatCount" in patch)) delete options.repeatCount;
+    if ("weight" in patch || "intensity" in patch || "intensityScale" in patch) options.intensityScale = intensity(patch);
+    if (["weight", "intensity", "intensityScale", "blendMode", "easing", "balance", "balanceMap", "mixWeights"].some((key) => key in patch)) {
+      const clip = this.materialize(playback.source, options, playback.inheritedStarts);
+      connector.replaceClip(playback.id, clip);
+      if ("blendMode" in patch) connector.control(playback.id, { type: "setBlendMode", blendMode: clip.blendMode === AdditiveAnimationBlendMode ? "additive" : "normal" });
+    }
+    if ("mixerWeight" in patch) connector.control(playback.id, { type: "setWeight", weight: patch.mixerWeight });
+    if ("speed" in patch || "playbackRate" in patch || "rate" in patch || "timeScale" in patch || "reverse" in patch) {
+      let speed = patch.speed ?? patch.playbackRate ?? patch.rate ?? patch.timeScale ?? action.timeScale;
+      if ("reverse" in patch) speed = Math.abs(speed) * (patch.reverse ? -1 : 1);
+      connector.control(playback.id, { type: "setSpeed", speed });
+      options.speed = speed;
+      delete options.reverse;
+    }
+    if ("time" in patch || "offsetSec" in patch) {
+      options.time = patch.time ?? patch.offsetSec;
+      connector.control(playback.id, { type: "seek", seconds: options.time });
+    }
+    if ("loopMode" in patch || "loop" in patch || "repeatCount" in patch) {
+      if (playback.terminal) {
+        playback.replay({ ...options, time: action.time });
+        return;
       }
-      if (!improved) break;
+      connector.control(playback.id, { type: "setLoop", loop: this.nativeOptions(options, action.getClip()).loop });
     }
-    return { ...best, limited: best.direction.angleTo(desired) > 1e-3, yaw, pitch };
+    if ("clampWhenFinished" in patch || "finalPose" in patch) connector.control(playback.id, { type: "setFinalPose", finalPose: this.nativeOptions(options, action.getClip()).finalPose });
+    playback.options = options;
+    if (!connector.getAction(playback.id)) this.forget(playback);
   }
-  contributedPose(joint, desired, roll, intensity, fromReference, base = joint.object.quaternion.clone()) {
-    const full = fromReference ? this.solveJoint(joint, desired, roll, joint.reference, this.referenceParent(joint), joint.referenceScale) : this.solveJoint(joint, desired, roll, base);
-    const gain = contribution(intensity);
-    const result = this.jointPose(joint, base, full.yaw * gain, full.pitch * gain, bounded(roll) * gain);
-    return { ...result, limited: result.direction.angleTo(desired) > 1e-3 };
+  registerAnimationClips(clips) {
+    const model = this.requireModel();
+    for (const clip of clips) {
+      if (this.sources.get(clip.name)?.kind === "native" && this.sources.get(clip.name).clip === clip) continue;
+      const [ir] = serializeAnimationClips(model, [clip], this.inspection);
+      this.core.register_animation_clip(json2(ir), "baked");
+      this.sources.set(clip.name, { name: clip.name, kind: "native", clip });
+    }
   }
-  solve(joint, desired, roll = 0, intensity = 1, fromReference = false) {
-    const result = this.contributedPose(joint, desired, roll, intensity, fromReference);
-    this.saved.set(joint.object, { base: joint.object.quaternion.clone(), applied: result.quaternion.clone() });
-    joint.object.quaternion.copy(result.quaternion);
-    joint.object.updateMatrixWorld(true);
-    return result;
+  loadAnimationClips(clips) {
+    this.stopAllAnimations();
+    for (const source of [...this.sources.values()]) if (source.kind === "native") {
+      this.sources.delete(source.name);
+      this.core.remove_animation_clip(source.name);
+    }
+    this.registerAnimationClips(clips ?? []);
+    this.restartHair();
   }
-  apply(request2, controls) {
-    this.restore();
-    const active = this.controlLimits();
-    const intendedWorldTarget = vector(request2.worldTarget);
-    const origin = this.origin();
-    const intendedOffset = intendedWorldTarget.clone().sub(origin);
-    const intendedBearing = this.angles(intendedOffset);
-    const remainingYaw = this.degrees(-finite2(controls.eyeYaw), active.yaw) - this.degrees(-finite2(request2.target?.x), active.yaw);
-    const remainingPitch = this.degrees(finite2(controls.eyePitch), active.pitch) - this.degrees(finite2(request2.target?.y), active.pitch);
-    const target = origin.clone().addScaledVector(
-      this.direction(intendedBearing.yaw + remainingYaw, intendedBearing.pitch + remainingPitch),
-      intendedOffset.length()
-    );
-    let headLimited = false;
-    const headControlsPresent = controls.headYaw !== void 0 || controls.headPitch !== void 0 || controls.headRoll !== void 0;
-    const eyeControlsPresent = controls.eyeYaw !== void 0 || controls.eyePitch !== void 0;
-    if (request2.headEnabled !== false && headControlsPresent && this.head) {
-      headLimited = this.solve(this.head, this.direction(
-        this.degrees(-finite2(controls.headYaw), this.limits.headYaw),
-        this.degrees(finite2(controls.headPitch), this.limits.headPitch)
-      ), finite2(controls.headRoll), contribution(controls.headIntensity ?? request2.headIntensity), true).limited;
-    }
-    const eyes = [];
-    for (const eye of this.eyes) {
-      const eyeOrigin = eye.object.getWorldPosition(new Vector3());
-      const desired = target.clone().sub(eyeOrigin).normalize();
-      const solved = request2.eyesEnabled !== false && eyeControlsPresent ? this.solve(eye, desired, 0, contribution(controls.eyeIntensity ?? request2.eyeIntensity)) : { limited: false };
-      const direction = this.ray(eye);
-      eyes.push({
-        name: eye.object.name,
-        origin: point2(eyeOrigin),
-        direction: point2(direction),
-        errorDegrees: direction.angleTo(desired) * 180 / Math.PI,
-        limited: solved.limited
+  removeAnimationClip(name) {
+    this.stopAnimation(name);
+    this.sources.delete(name);
+    return this.core.remove_animation_clip(name);
+  }
+  getAnimationClips() {
+    return parse(this.core.get_animation_clips());
+  }
+  playAnimation(name, options = {}) {
+    const source = this.sources.get(name);
+    if (!source) throw new Error(`Unknown animation clip: ${name}`);
+    return this.handle(source, options, true);
+  }
+  build(source, options, play) {
+    this.requireModel();
+    this.validateEasing(options);
+    this.compile(source, options);
+    this.sources.set(source.name, source);
+    return this.handle(source, options, play);
+  }
+  buildClip(name, curves, options = {}) {
+    return options.semanticAnimation ? this.semanticAnimationToClip(name, options.semanticAnimation, { ...options, faceCurves: curves }) : this.build({ name, kind: "curves", input: copy(curves), options: copy(options) }, options, false);
+  }
+  snippetToClip(name, curves, options = {}) {
+    return this.buildClip(name, curves, options);
+  }
+  buildTypedClip(name, channels, options = {}) {
+    return this.build({ name, kind: "typed", input: copy(channels), options: copy(options) }, options, false);
+  }
+  typedSnippetToClip(name, channels, options = {}) {
+    return this.buildTypedClip(name, channels, options);
+  }
+  semanticAnimationToClip(name, animation, options = {}) {
+    return this.build({ name, kind: "semantic", input: copy(animation), options: copy(options) }, options, false);
+  }
+  playSnippet(snippet, curvesOrOptions = {}, options = {}) {
+    return typeof snippet === "string" ? this.buildClip(snippet, curvesOrOptions, options).play() : this.buildClip(snippet.name, snippet.curves, curvesOrOptions).play();
+  }
+  playTypedSnippet(snippet, options = {}) {
+    return this.buildTypedClip(snippet.name, snippet.channels, options).play();
+  }
+  playClip(value) {
+    return typeof value === "string" ? this.playAnimation(value) : value.play();
+  }
+  supportsClipCurves() {
+    return true;
+  }
+  cleanupSnippet(name) {
+    this.stopAnimation(name);
+    this.sources.delete(name);
+    this.core.cleanup_snippet(name);
+  }
+  crossfadeTo(name, seconds, options = {}) {
+    const outgoing = [...this.current.values()].filter((playback) => !playback.source.name.startsWith("__embody_"));
+    const handle = this.playAnimation(name, { ...options, fadeInSec: seconds });
+    for (const playback of outgoing) if (playback.connector.getAction(playback.id)) playback.connector.fadeOut(playback.id, seconds);
+    return handle;
+  }
+  stopAnimation(name) {
+    const playback = this.current.get(name);
+    if (!playback) return;
+    if (playback.connector.getAction(playback.id)) playback.connector.control(playback.id, { type: "stop" });
+    this.forget(playback);
+  }
+  stopAllAnimations() {
+    for (const playback of [...this.playbacks.values()]) {
+      if (playback.source.kind === "compiled") continue;
+      if (playback.connector.getAction(playback.id)) playback.connector.control(playback.id, { type: "stop" });
+      this.forget(playback);
+    }
+  }
+  pauseAnimation(name) {
+    const p = this.current.get(name);
+    if (p) p.connector.control(p.id, { type: "pause" });
+  }
+  resumeAnimation(name) {
+    const p = this.current.get(name);
+    if (!p) return;
+    if (p.terminal) p.replay({ ...p.options, time: p.connector.getAction(p.id)?.time ?? 0 });
+    else p.connector.control(p.id, { type: "resume" });
+  }
+  pauseAllAnimations() {
+    for (const p of this.playbacks.values()) if (!p.terminal) p.connector.control(p.id, { type: "pause" });
+  }
+  resumeAllAnimations() {
+    for (const name of [...this.current.keys()]) this.resumeAnimation(name);
+  }
+  updateClipParams(name, options) {
+    const p = this.current.get(name);
+    if (p) this.updatePlayback(p, options);
+  }
+  setAnimationSpeed(name, value) {
+    this.updateClipParams(name, { speed: value });
+  }
+  setAnimationIntensity(name, value) {
+    this.updateClipParams(name, { intensityScale: value });
+  }
+  setAnimationLoop(name, value) {
+    this.updateClipParams(name, { loopMode: value ? "repeat" : "once" });
+  }
+  setAnimationLoopMode(name, value) {
+    this.updateClipParams(name, { loopMode: value });
+  }
+  setAnimationRepeatCount(name, value) {
+    this.updateClipParams(name, { loopMode: "repeat", repeatCount: value });
+  }
+  setAnimationReverse(name, value) {
+    this.updateClipParams(name, { reverse: value });
+  }
+  setAnimationBlendMode(name, value) {
+    this.updateClipParams(name, { blendMode: value });
+  }
+  setAnimationEasing(name, value) {
+    this.validateEasing({ easing: value });
+    this.updateClipParams(name, { easing: value });
+  }
+  seekAnimation(name, value) {
+    this.updateClipParams(name, { time: value });
+  }
+  setAnimationTime(name, value) {
+    this.seekAnimation(name, value);
+  }
+  setSnippetTime(name, value) {
+    this.seekAnimation(name, value);
+  }
+  seekSnippet(name, value) {
+    this.seekAnimation(name, value);
+  }
+  seek(name, value) {
+    this.seekAnimation(name, value);
+  }
+  setAnimationTimeScale(value) {
+    this.requireConnector().setTimeScale(value);
+    this.timeScale = value;
+  }
+  getAnimationState(name) {
+    const p = this.current.get(name);
+    const action = p?.connector.getAction(p.id);
+    if (!action || !p) {
+      if (p) this.forget(p);
+      return { name, playing: false, isPlaying: false };
+    }
+    const playing = action.isRunning();
+    return {
+      name,
+      actionId: p.id,
+      playing,
+      isPlaying: playing,
+      paused: action.paused,
+      completed: p.terminal,
+      time: action.time,
+      duration: action.getClip().duration,
+      speed: action.timeScale,
+      intensityScale: intensity(p.options),
+      mixerWeight: action.getEffectiveWeight(),
+      loopMode: action.loop === LoopOnce ? "once" : action.loop === LoopPingPong ? "pingpong" : "repeat",
+      repeatCount: Number.isFinite(action.repetitions) ? action.repetitions : null,
+      blendMode: action.blendMode === AdditiveAnimationBlendMode ? "additive" : "replace"
+    };
+  }
+  getPlayingAnimations() {
+    return [...this.current.keys()].filter((name) => this.getAnimationState(name).playing);
+  }
+  commitLive(durationMs = 0) {
+    const connector = this.requireConnector();
+    const duration = Math.max(0, durationMs) / 1e3;
+    const clip = parse(this.core.build_live_clip("__embody_live", duration));
+    const touched = new Set(parse(this.core.live_command_targets_json()).map(targetKey));
+    const tracks = new Map(clip.tracks.map((track) => [targetKey(track.target), track]));
+    const handles = [];
+    for (const [key, previous] of this.liveTargets) {
+      if (tracks.has(key)) continue;
+      if (previous.releasing && !touched.has(key)) continue;
+      const action = previous.handle.actionId && connector.getAction(previous.handle.actionId);
+      if (!action || duration === 0) {
+        previous.handle.stop();
+        this.liveTargets.delete(key);
+        continue;
+      }
+      const nativeTrack = action.getClip().tracks[0];
+      const sample = Array.from(nativeTrack.createInterpolant().evaluate(action.time));
+      const released = { ...previous.track, times: [0, duration], values: [...sample, ...sample], inheritStart: false };
+      const releaseClip = { ...clip, name: previous.handle.name, tracks: [released] };
+      const handle = this.handle(
+        { name: releaseClip.name, kind: "compiled", clip: releaseClip },
+        { loopMode: "once", finalPose: "release", mixerWeight: action.getEffectiveWeight() },
+        true
+      );
+      connector.fadeOut(handle.actionId, duration);
+      const record = { track: released, handle, releasing: true };
+      this.liveTargets.set(key, record);
+      void handle.promise.then(() => {
+        if (this.liveTargets.get(key) === record) this.liveTargets.delete(key);
       });
+      handles.push(handle);
+    }
+    for (const [key, track] of tracks) {
+      const previous = this.liveTargets.get(key);
+      const endpoint = (value) => value.values.slice(value.values.length / value.times.length * (value.times.length - 1));
+      if (previous && !previous.releasing && !touched.has(key) && json2(endpoint(previous.track)) === json2(endpoint(track))) continue;
+      const name = previous?.handle.name ?? `__embody_live_${this.nextLiveTarget++}`;
+      const outgoing = previous?.handle.actionId && connector.getAction(previous.handle.actionId);
+      let nativeTrack = track;
+      if (duration > 0 && outgoing) {
+        const start = Array.from(outgoing.getClip().tracks[0].createInterpolant().evaluate(outgoing.time));
+        nativeTrack = { ...track, values: [...start, ...endpoint(track)], inheritStart: false };
+      }
+      const targetClip = { ...clip, name, tracks: [nativeTrack] };
+      const handle = this.handle({ name, kind: "compiled", clip: targetClip }, { loopMode: "once", finalPose: "hold" }, true);
+      this.liveTargets.set(key, { track, handle, releasing: false });
+      handles.push(handle);
+    }
+    return handles;
+  }
+  mutateLive(mutate, durationMs = 0) {
+    this.requireModel();
+    this.core.begin_live_command();
+    mutate();
+    return this.commitLive(durationMs);
+  }
+  transition(handles) {
+    let settled = handles.length === 0;
+    const promise = Promise.all(handles.map((handle) => handle.promise)).then(() => {
+      settled = true;
+    });
+    const control = (command) => {
+      if (settled) return;
+      for (const handle of handles) {
+        const playback = handle.actionId && this.playbacks.get(handle.actionId);
+        if (!playback || !playback.connector.getAction(playback.id)) continue;
+        if (command === "cancel" || !playback.terminal) handle[command]();
+      }
+    };
+    return { promise, pause: () => control("pause"), resume: () => control("resume"), cancel: () => control("cancel") };
+  }
+  setAU(id, value, balance = this.core.get_au_balance(id)) {
+    this.mutateLive(() => this.core.set_au_signed(id, value, balance));
+  }
+  getAU(id) {
+    return this.core.get_au(id);
+  }
+  getAUBalance(id) {
+    return this.core.get_au_balance(id);
+  }
+  getBodyControls() {
+    return parse(this.core.get_body_controls_json());
+  }
+  getSemanticPoseCatalog() {
+    return parse(this.core.get_semantic_pose_catalog_json());
+  }
+  captureSemanticPose() {
+    return parse(this.core.capture_semantic_pose_json());
+  }
+  validateSemanticPose(pose) {
+    return parse(this.core.validate_semantic_pose_json(json2(pose)));
+  }
+  applySemanticPose(pose) {
+    this.mutateLive(() => this.core.apply_semantic_pose_json(json2(pose)));
+  }
+  validateSemanticAnimation(animation, options = {}) {
+    this.core.validate_semantic_animation_json(json2(animation), json2(options));
+  }
+  resetBodyControls() {
+    this.mutateLive(() => this.core.reset_body_controls());
+  }
+  setContinuum(negative, positive, value, balance = NaN) {
+    this.mutateLive(() => this.core.set_continuum(negative, positive, value, balance));
+  }
+  getContinuum(negative, positive) {
+    return this.core.get_continuum(negative, positive);
+  }
+  transitionAU(id, value, durationMs = 200, balance = this.core.get_au_balance(id)) {
+    return this.transition(this.mutateLive(() => this.core.set_au_signed(id, value, balance), durationMs));
+  }
+  setViseme(index, value, jawScale = 1) {
+    this.mutateLive(() => {
+      this.core.set_viseme(index, value);
+      this.core.set_viseme_jaw_scale(index, jawScale);
+    });
+  }
+  getViseme(index) {
+    return this.core.get_viseme(index);
+  }
+  getVisemeJawScale(index) {
+    return this.core.get_viseme_jaw_scale(index);
+  }
+  setVisemeById(id, value, jawScale = 1) {
+    const index = this.core.viseme_slot_index(id);
+    if (index < 0) throw new Error(`Unknown viseme: ${id}`);
+    this.setViseme(index, value, jawScale);
+  }
+  transitionViseme(index, value, durationMs = 80, jawScale = 1) {
+    return this.transition(this.mutateLive(() => {
+      this.core.set_viseme(index, value);
+      this.core.set_viseme_jaw_scale(index, jawScale);
+    }, durationMs));
+  }
+  transitionVisemeById(id, value, durationMs = 80, jawScale = 1) {
+    const index = this.core.viseme_slot_index(id);
+    if (index < 0) return this.transition([]);
+    return this.transitionViseme(index, value, durationMs, jawScale);
+  }
+  setAUMixWeight(id, value) {
+    var _a, _b;
+    const weight = Math.max(0, Math.min(1, value));
+    this.mutateLive(() => this.core.set_au_mix_weight(id, weight));
+    ((_a = this.profile).auMixDefaults ?? (_a.auMixDefaults = {}))[id] = weight;
+    ((_b = this.profileSource).auMixDefaults ?? (_b.auMixDefaults = {}))[id] = weight;
+  }
+  getAUMixWeight(id) {
+    return this.core.get_au_mix_weight(id);
+  }
+  hasLeftRightBones(id) {
+    return this.core.has_left_right_bones(id);
+  }
+  setMorph(key, value, meshNames = []) {
+    this.mutateLive(() => {
+      if (typeof key === "number") this.core.set_morph_index(key, value, json2(meshNames));
+      else this.core.set_morph(key, value, json2(meshNames));
+    });
+  }
+  setMorphOnMeshes(meshNames, key, value) {
+    this.setMorph(key, value, meshNames);
+  }
+  releaseMorph(key, meshNames = []) {
+    this.mutateLive(() => {
+      if (typeof key === "number") this.core.release_morph_index(key, json2(meshNames));
+      else this.core.release_morph(key, json2(meshNames));
+    });
+  }
+  transitionMorph(key, value, durationMs = 120, meshNames = []) {
+    return this.transition(this.mutateLive(() => {
+      if (typeof key === "number") this.core.set_morph_index(key, value, json2(meshNames));
+      else this.core.set_morph(key, value, json2(meshNames));
+    }, durationMs));
+  }
+  getMorphTargets() {
+    return Object.fromEntries(this.meshes.map((mesh) => [mesh.name, Object.keys(mesh.morphTargetDictionary ?? {}).sort()]));
+  }
+  getMorphTargetIndices() {
+    return Object.fromEntries(this.meshes.map((mesh) => [mesh.name, Object.entries(mesh.morphTargetDictionary ?? {}).map(([name, index]) => ({ name, index })).sort((a, b) => a.index - b.index)]));
+  }
+  addMorphTarget(target, options) {
+    const index = this.applier.addMorphTarget(this.requireModel(), target, options);
+    this.bindModel();
+    return index;
+  }
+  addMorphTargets(targets, options) {
+    const result = this.applier.addMorphTargets(this.requireModel(), targets, options);
+    this.bindModel();
+    return result;
+  }
+  meshCategory(mesh) {
+    return this.profile.meshes?.[mesh.name]?.category ?? "other";
+  }
+  getMeshList() {
+    return (this.inspection?.allMeshes ?? []).map((mesh) => ({ name: mesh.name, visible: mesh.visible, morphCount: mesh.morphTargetInfluences?.length ?? 0, category: this.meshCategory(mesh) }));
+  }
+  getBones() {
+    return this.bones;
+  }
+  meshProfile(name) {
+    var _a, _b;
+    return (_b = (_a = this.profile).meshes ?? (_a.meshes = {}))[name] ?? (_b[name] = { category: "other" });
+  }
+  setMeshVisible(name, visible) {
+    this.applier.setMeshVisible(this.requireModel(), name, visible);
+    this.meshProfile(name).visible = visible;
+  }
+  highlightMesh(name, color, value) {
+    this.applier.highlightMesh(this.requireModel(), name, color, value);
+  }
+  getMeshMaterialConfig(name) {
+    return this.applier.getMeshMaterialConfig(this.requireModel(), name);
+  }
+  setMeshMaterialConfig(name, value) {
+    this.applier.setMeshMaterialConfig(this.requireModel(), name, value);
+    const entry = this.meshProfile(name);
+    entry.material = { ...entry.material, ...value };
+  }
+  registerHairObjects(objects) {
+    this.hairObjects.clear();
+    for (const object of objects) if (object.isMesh) this.hairObjects.set(object.name, object);
+    for (const category of ["hair", "eyebrow"]) {
+      const mesh = [...this.hairObjects.values()].find((object) => this.meshCategory(object) === category);
+      const material = mesh && (Array.isArray(mesh.material) ? mesh.material[0] : mesh.material);
+      if (material) this.hairAppearance[`${category}Color`] = { ...this.hairAppearance[`${category}Color`], baseColor: material.color ? `#${material.color.getHexString()}` : "#000000", emissive: material.emissive ? `#${material.emissive.getHexString()}` : "#000000", emissiveIntensity: material.emissiveIntensity ?? 0 };
+    }
+    this.restartHair();
+    return [...this.hairObjects.values()].map((mesh) => ({ name: mesh.name, isMesh: true, isEyebrow: this.meshCategory(mesh) === "eyebrow" }));
+  }
+  getRegisteredHairObjects() {
+    return [...this.hairObjects.values()];
+  }
+  getHairMorphTargets(name) {
+    const meshes = name ? [this.hairObjects.get(name)] : [...this.hairObjects.values()];
+    return [...new Set(meshes.flatMap((mesh) => Object.keys(mesh?.morphTargetDictionary ?? {})))].sort();
+  }
+  getHairAppearance() {
+    return copy(this.hairAppearance);
+  }
+  setHairAppearance(category, value) {
+    const key = `${category}Color`;
+    const next = parse(this.wasm.normalize_hair_color_appearance_json(json2(value), json2(this.hairAppearance[key])));
+    this.hairAppearance[key] = next;
+    this.applier.applyHairAppearance([...this.hairObjects.values()].filter((mesh) => this.meshCategory(mesh) === category), next);
+  }
+  setHairColor(value) {
+    this.setHairAppearance("hair", value);
+  }
+  setEyebrowColor(value) {
+    this.setHairAppearance("eyebrow", value);
+  }
+  setHairBaseColor(value) {
+    this.setHairColor({ baseColor: value });
+  }
+  setEyebrowBaseColor(value) {
+    this.setEyebrowColor({ baseColor: value });
+  }
+  setHairGlow(color, value) {
+    this.setHairColor({ emissive: color, emissiveIntensity: value });
+  }
+  setEyebrowGlow(color, value) {
+    this.setEyebrowColor({ emissive: color, emissiveIntensity: value });
+  }
+  setHairOutline(value) {
+    Object.assign(this.hairAppearance, { showOutline: value.show }, value.color ? { outlineColor: value.color } : {}, value.opacity !== void 0 ? { outlineOpacity: value.opacity } : {});
+  }
+  restartHair() {
+    for (const name of [...this.current.keys()]) if (name.startsWith("__embody_hair")) this.stopAnimation(name);
+    if (!this.hairConfig.enabled || !this.hairObjects.size || !this.connector) return;
+    if (this.hairConfig.idleSwayAmount > 0 || this.hairConfig.windStrength > 0) {
+      const curves = parse(this.wasm.build_hair_idle_curves(json2(this.hairConfig), this.hairConfig.idleClipDuration));
+      if (Object.keys(curves).length) this.playSnippet("__embody_hair_idle", curves, { loopMode: "repeat", meshNames: [...this.hairObjects.keys()], source: "hair", blendMode: "additive" });
     }
-    return { target: point2(target), eyes, headLimited, missingHead: !this.head, missingEyes: this.eyes.length < 2 };
+  }
+  setHairPhysicsEnabled(value) {
+    this.setHairPhysicsConfig({ enabled: value });
+  }
+  isHairPhysicsEnabled() {
+    return !!this.hairConfig.enabled;
+  }
+  setHairPhysicsConfig(value) {
+    this.hairConfig = parse(this.core.set_hair_config_json(json2(value)));
+    this.restartHair();
+  }
+  getHairPhysicsConfig() {
+    return copy(this.hairConfig);
+  }
+  validateHairMorphTargets() {
+    return parse(this.core.get_missing_hair_morph_targets_json(json2(this.getHairMorphTargets())));
+  }
+  applyHairStateToObject(name, state) {
+    const mesh = this.hairObjects.get(name);
+    if (!mesh) return;
+    if (state.visible !== void 0) mesh.visible = state.visible;
+    if (state.scale) mesh.scale.set(state.scale.x, state.scale.y, state.scale.z);
+    if (state.position) mesh.position.set(state.position.x, state.position.y, state.position.z);
+    if (state.color) this.applier.applyHairAppearance([mesh], state.color);
+  }
+  authoredHeadMotion(clip) {
+    if (!this.hairConfig.enabled || clip.name.startsWith("__embody_hair") || !this.hairObjects.size) return void 0;
+    const tracks = [];
+    for (const track of clip.tracks) {
+      if (track.ValueTypeName !== "quaternion") continue;
+      const parsed = PropertyBinding.parseTrackName(track.name);
+      let object = PropertyBinding.findNode(this.requireModel(), parsed.nodeName);
+      if (parsed.objectName === "bones" && object) {
+        const skeleton = object.skeleton;
+        object = skeleton?.bones.find((bone) => bone.name === String(parsed.objectIndex)) ?? skeleton?.bones[Number(parsed.objectIndex)];
+      }
+      if (!object) continue;
+      const cubic = track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true;
+      const stride = track.getValueSize();
+      const reference = this.restValues(track);
+      if (!reference) continue;
+      const samples = [];
+      for (let index = 0; index < track.times.length; index += 1) {
+        const offset = index * stride + (cubic ? 4 : 0);
+        samples.push(Array.from(track.values.subarray(offset, offset + 4)));
+      }
+      tracks.push({ boneName: object.name, current: object.quaternion.toArray(), reference, samples });
+    }
+    return parse(this.core.resolve_hair_motion_json(json2(tracks), clip.blendMode === AdditiveAnimationBlendMode)) ?? void 0;
+  }
+  setHairGravity(pitch, durationSeconds) {
+    const clip = parse(this.core.build_hair_gravity_clip("__embody_hair_gravity", pitch, durationSeconds, json2({ meshNames: [...this.hairObjects.keys()], source: "hair" })));
+    if (!clip.tracks.length) return;
+    this.handle({ name: clip.name, kind: "compiled", clip }, { loopMode: "once", finalPose: "hold", blendMode: "additive" }, true);
+  }
+  playHairImpulse(horizontal, vertical) {
+    if (!this.hairConfig.enabled || !this.hairObjects.size) return void 0;
+    const curves = parse(this.wasm.build_hair_impulse_curves(json2(this.hairConfig), this.hairConfig.impulseClipDuration, horizontal, vertical));
+    if (!Object.keys(curves).length) return void 0;
+    return this.playSnippet("__embody_hair_impulse", curves, { loopMode: "once", finalPose: "release", meshNames: [...this.hairObjects.keys()], source: "hair", blendMode: "additive" });
+  }
+  start() {
+    this.assertAlive();
+    this.rendering = true;
+    this.connector?.setRendering(true);
+  }
+  stop() {
+    this.assertAlive();
+    this.rendering = false;
+    this.connector?.setRendering(false);
+  }
+  clear() {
+    this.mutateLive(() => this.core.clear());
+  }
+  resetToNeutral() {
+    this.clear();
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.connector?.dispose();
+    this.core.free();
+    this.playbacks.clear();
+    this.current.clear();
+    this.sources.clear();
+    this.hairObjects.clear();
+    this.meshes.length = 0;
+    this.meshByName.clear();
+    this.bones = {};
+    this.liveTargets.clear();
+    this.connector = void 0;
+    this.inspection = void 0;
+    this.boundModel = void 0;
+    this.disposed = true;
   }
 };
+function createRustEmbodyHostUnbound(config = {}) {
+  return new Embody(config);
+}
+async function createRustEmbodyHost(model, config = {}) {
+  const character = await Embody.create(config);
+  try {
+    character.onReady({ model, meshes: config.meshes, referencePose: config.referencePose });
+    return character;
+  } catch (error) {
+    character.dispose();
+    throw error;
+  }
+}
 var draco = null;
 var dracoPath = "";
 var gltfLoader = null;
@@ -7437,7 +8900,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
       if (pendingRendererChange && preference === settings.preference && (status === "initializing" || status === "switching")) return pendingRendererChange;
       if (status === "ready" && preference === settings.preference) return Promise.resolve(getSnapshot());
       settings = { preference };
-      const request2 = ++generation;
+      const request3 = ++generation;
       const previous = pending;
       status = active ? "switching" : "initializing";
       error = null;
@@ -7451,7 +8914,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
         let restoreModelSkinning = () => {
         };
         const check = () => {
-          if (disposed || generation !== request2) throw renderingAborted();
+          if (disposed || generation !== request3) throw renderingAborted();
           if (!active) throwIfAborted(options.signal);
           if (candidate?.lost) throw candidate.lost;
         };
@@ -7534,7 +8997,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
           if (attached && candidate?.renderer.domElement.parentElement === container) container.removeChild(candidate.renderer.domElement);
           rollback(() => environment?.dispose());
           rollback(() => candidate?.dispose());
-          const canceled = disposed || generation !== request2 || !active && options.signal?.aborted;
+          const canceled = disposed || generation !== request3 || !active && options.signal?.aborted;
           if (!disposed) {
             rollback(restoreModelSkinning);
             rollback(restoreCameraCoordinates);
@@ -7546,7 +9009,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
                 owner.reportFailure(resumeError, active.renderer);
               }
             }
-            if (generation === request2) {
+            if (generation === request3) {
               status = active?.lost ? "lost" : "error";
               error = failure instanceof Error ? failure : new Error(String(failure));
               notify();
@@ -7723,6 +9186,184 @@ async function createDefaultCharacterSceneAsync(container, options = {}) {
   }
 }
 
+// three/characterHost.ts
+async function createCharacterHost(options) {
+  if (!options.container) throw new Error("createCharacterHost requires a container HTMLElement");
+  if (!options.character?.modelUrl) throw new Error("createCharacterHost requires character.modelUrl");
+  let loaded;
+  let state;
+  let engine;
+  let controller;
+  let disposed = false;
+  let disposal;
+  let switching = Promise.resolve();
+  let mountedCanvas;
+  const aborted = () => new DOMException("Character host creation was aborted", "AbortError");
+  const checkCreation = () => {
+    if (options.signal?.aborted) throw aborted();
+  };
+  const releaseModel = async (value) => {
+    const release = () => disposeCharacterModel(state?.scene ?? null, value.model);
+    if (state?.rendering) await state.rendering.releaseSceneResources(release);
+    else release();
+  };
+  const makeEngine = (value, character) => {
+    const next = new Embody({ ...options.embody, presetType: character.presetType ?? options.embody?.presetType, profile: character.profile ?? options.embody?.profile });
+    try {
+      next.onReady(value);
+      return next;
+    } catch (error) {
+      try {
+        next.dispose();
+      } catch {
+      }
+      throw error;
+    }
+  };
+  const dispose = () => {
+    if (disposal) return disposal;
+    disposed = true;
+    disposal = (async () => {
+      let failure;
+      const attempt = async (release) => {
+        try {
+          await release();
+        } catch (error) {
+          failure ?? (failure = error);
+        }
+      };
+      await attempt(() => controller?.dispose());
+      await switching.catch(() => {
+      });
+      await attempt(() => engine?.dispose());
+      const ownedScene = !options.external && state && "dispose" in state ? state : void 0;
+      if (ownedScene) await attempt(() => ownedScene.dispose());
+      const lastModel = loaded;
+      if (lastModel) await attempt(() => releaseModel(lastModel));
+      mountedCanvas?.remove();
+      if (failure !== void 0) throw failure;
+    })();
+    return disposal;
+  };
+  try {
+    checkCreation();
+    loaded = await loadCharacterModel(options.character.modelUrl, options.loader);
+    checkCreation();
+    state = options.external ?? await createDefaultCharacterSceneAsync(options.container, { ...options.scene, signal: options.signal });
+    checkCreation();
+    await initEmbodyCore();
+    checkCreation();
+    applyCharacterModelTransform(loaded.model, options.character);
+    state.scene.add(loaded.model);
+    engine = makeEngine(loaded, options.character);
+    if (options.external?.mountCanvas && !state.renderer.domElement.parentElement) {
+      mountedCanvas = state.renderer.domElement;
+      options.container.appendChild(mountedCanvas);
+    }
+    if (options.renderLoop ?? !options.external) {
+      if (!(state.camera instanceof PerspectiveCamera)) throw new Error("Character host rendering requires a PerspectiveCamera");
+      controller = new DPthreeCameraController({
+        scene: state.scene,
+        camera: state.camera,
+        domElement: state.renderer.domElement,
+        ...state.rendering ? { rendering: state.rendering } : { renderer: state.renderer },
+        showDOMControls: false
+      });
+      controller.setModel(loaded.model);
+      await controller.prepareModelForRender(loaded.model, { signal: options.signal });
+      if (options.autoFrame !== false) await controller.focusFullBody(0);
+    }
+    checkCreation();
+    if (options.autoStart === false) engine.stop();
+    else engine.start();
+    const sceneState = state;
+    const rendering = state.rendering ?? null;
+    const host = {
+      engine,
+      scene: state.scene,
+      camera: state.camera,
+      get renderer() {
+        return rendering ? rendering.getSnapshot().renderer : sceneState.renderer;
+      },
+      get backend() {
+        return rendering ? rendering.getSnapshot().backend : sceneState.backend ?? null;
+      },
+      rendering,
+      model: loaded.model,
+      meshes: loaded.meshes,
+      animations: loaded.animations,
+      lighting: "lighting" in state ? state.lighting : null,
+      ownsScene: !options.external,
+      container: options.container,
+      resize() {
+        if ("resize" in sceneState) sceneState.resize();
+      },
+      setCharacter(character, loader = options.loader) {
+        if (disposed) return Promise.reject(new Error("Character host is disposed"));
+        const change = switching.catch(() => {
+        }).then(async () => {
+          if (disposed) throw new Error("Character host is disposed");
+          const next = await loadCharacterModel(character.modelUrl, loader);
+          let nextEngine;
+          try {
+            if (disposed) throw new Error("Character host is disposed");
+            applyCharacterModelTransform(next.model, character);
+            nextEngine = makeEngine(next, character);
+            nextEngine.stop();
+            sceneState.scene.add(next.model);
+            if (controller) await controller.prepareModelForRender(next.model);
+            if (disposed) throw new Error("Character host is disposed");
+          } catch (error) {
+            try {
+              nextEngine?.dispose();
+            } catch {
+            }
+            try {
+              await releaseModel(next);
+            } catch {
+            }
+            throw error;
+          }
+          const previous = loaded;
+          try {
+            engine.dispose();
+          } catch (error) {
+            try {
+              nextEngine?.dispose();
+            } catch {
+            }
+            try {
+              await releaseModel(next);
+            } catch {
+            }
+            throw error;
+          }
+          engine = nextEngine;
+          loaded = next;
+          host.engine = engine;
+          host.model = next.model;
+          host.meshes = next.meshes;
+          host.animations = next.animations;
+          controller?.setModel(next.model);
+          if (options.autoStart !== false) engine.start();
+          await releaseModel(previous);
+          if (controller && options.autoFrame !== false) await controller.focusFullBody(0);
+        });
+        switching = change;
+        return change;
+      },
+      dispose
+    };
+    return host;
+  } catch (error) {
+    try {
+      await dispose();
+    } catch {
+    }
+    throw error;
+  }
+}
+
 // three/index.ts
 var THREE_BLENDING_MODES = {
   Normal: NormalBlending,
@@ -7731,6 +9372,7 @@ var THREE_BLENDING_MODES = {
   Multiply: MultiplyBlending,
   None: NoBlending
 };
+var BLENDING_MODES = THREE_BLENDING_MODES;
 var MORPH_ATTRIBUTE_SEMANTICS = ["position", "normal", "tangent", "color"];
 var createNeutralMorphAttribute = (geometry, semantic, name) => {
   const base = geometry.getAttribute(semantic);
@@ -7925,6 +9567,8 @@ function createAnimationClipFromClipIR(clip, inspection) {
   const tracks = [];
   for (const track of clip.tracks ?? []) {
     const kind = track.target?.kind;
+    const trackName = concreteTrackName(track.target, inspection);
+    if (!trackName) continue;
     const times = Array.from(track.times ?? []);
     const values = Array.from(track.values ?? []);
     if (!times.length || !values.length) continue;
@@ -7932,7 +9576,6 @@ function createAnimationClipFromClipIR(clip, inspection) {
     if (kind === "morphTarget") {
       const binding = inspection.morphBindings.get(Number(track.target.morphTargetId));
       if (!binding?.mesh) continue;
-      const trackName = `${binding.mesh.uuid}.morphTargetInfluences[${binding.index}]`;
       if (track.inheritStart) {
         values[0] = binding.mesh.morphTargetInfluences?.[binding.index] ?? 0;
       }
@@ -7945,13 +9588,13 @@ function createAnimationClipFromClipIR(clip, inspection) {
       const property = track.target.property ?? "rotation";
       if (property === "rotation" || property === "quaternion") {
         if (track.inheritStart) object.quaternion.toArray(values, 0);
-        tracks.push(new QuaternionKeyframeTrack(`${object.uuid}.quaternion`, times, values, interpolation));
+        tracks.push(new QuaternionKeyframeTrack(trackName, times, values, interpolation));
       } else if (property === "position") {
         if (track.inheritStart) object.position.toArray(values, 0);
-        tracks.push(new VectorKeyframeTrack(`${object.uuid}.position`, times, values, interpolation));
+        tracks.push(new VectorKeyframeTrack(trackName, times, values, interpolation));
       } else if (property === "scale") {
         if (track.inheritStart) object.scale.toArray(values, 0);
-        tracks.push(new VectorKeyframeTrack(`${object.uuid}.scale`, times, values, interpolation));
+        tracks.push(new VectorKeyframeTrack(trackName, times, values, interpolation));
       }
       continue;
     }
@@ -7959,7 +9602,7 @@ function createAnimationClipFromClipIR(clip, inspection) {
       const mesh = inspection.meshBindings.get(Number(track.target.meshId));
       if (!mesh) continue;
       if (track.inheritStart) values[0] = Number(mesh.visible);
-      tracks.push(new NumberKeyframeTrack(`${mesh.uuid}.visible`, times, values, interpolation));
+      tracks.push(new NumberKeyframeTrack(trackName, times, values, interpolation));
     }
   }
   const duration = Number.isFinite(clip.durationSeconds) ? Number(clip.durationSeconds) : -1;
@@ -8002,14 +9645,19 @@ function serializeAnimationClips(model, clips, inspection) {
       }
       if (!target) return;
       const kind = target.kind === "morphTarget" ? "face" : target.kind === "boneTransform" ? "body" : "scene";
-      const size = track.getValueSize();
+      const cubic = !!track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline;
+      const size = track.getValueSize() / (cubic ? 3 : 1);
+      if (!Array.from(track.values).every(Number.isFinite)) {
+        throw new Error(`Animation track ${JSON.stringify(track.name)} contains non-finite samples.`);
+      }
+      const values = cubic ? Array.from(track.times).flatMap((_, key) => Array.from(track.values.slice((key * 3 + 1) * size, (key * 3 + 2) * size))) : Array.from(track.values);
       tracks.push({
         id: index + 1,
         channelId: channelId(kind),
         target,
         valueType: size === 4 ? "quat" : size === 3 ? "vec3" : "scalar",
         times: Array.from(track.times),
-        values: Array.from(track.values),
+        values,
         interpolation: track.getInterpolation() === InterpolateDiscrete ? "step" : "linear",
         sourceName: track.name
       });
@@ -8098,7 +9746,7 @@ var ThreeFrameApplier = class {
       mesh.visible = visible;
     });
   }
-  highlightMesh(root, name, color = 65535, intensity = 0.5) {
+  highlightMesh(root, name, color = 65535, intensity2 = 0.5) {
     root.traverse((object) => {
       if (!object.isMesh) return;
       for (const material of materials(object.material)) {
@@ -8107,7 +9755,7 @@ var ThreeFrameApplier = class {
         if (name === object.name) {
           if (!this.originalEmissive.has(key)) this.originalEmissive.set(key, { color: material.emissive.getHex(), intensity: material.emissiveIntensity ?? 0 });
           material.emissive.setHex(color);
-          material.emissiveIntensity = intensity;
+          material.emissiveIntensity = intensity2;
         } else {
           const original = this.originalEmissive.get(key);
           if (original) {
@@ -8276,6 +9924,6 @@ var collectMorphMeshes = (root) => {
   return meshes;
 };
 
-export { CHARACTER_SCENE_TYPES, CHARACTER_SCENE_TYPE_IDS, DPthreeCameraController as CameraController, CameraDOMControls, CameraDOMControls as Controls, DEFAULT_CHARACTER_LIGHTING_PRESETS, DEFAULT_CHARACTER_LIGHTING_PRESET_ID, DEFAULT_CHARACTER_LIGHTING_PRESET_IDS, DEFAULT_CHARACTER_LIGHTING_SETTINGS, DEFAULT_CHARACTER_SCENE_TYPE_ID, DEFAULT_MARKER_AUTO_HIDE_MS, DEFAULT_PREVIEW_AUTO_CLEAR_MS, DPthree, DPthree3DMarkers, DPthreeCameraController, DPthreeHTMLMarkers, DPthreeMarkers, DPthree3DMarkers as Markers3D, DPthreeHTMLMarkers as MarkersHTML, RUNTIME_ANNOTATION_REGION_PREFIX, RustAnnotationCameraCore, THREE_BLENDING_MODES, ThreeFrameApplier, ThreeGazeFocus, ThreeModelInspector, applyCharacterModelTransform, bindModelReferencePose, boneResolutionProfile, buildRegionDisplayOptions, captureModelReferencePose, collectMorphMeshes, createAnimationClipFromClipIR, createDefaultCharacterLighting, createDefaultCharacterScene, createDefaultCharacterSceneAsync, createDefaultCharacterSceneRuntime, createMarkerLifecycleRevealOptions, createMarkerVisibilityLifecycle, createRuntimeAnnotationPreviewLifecycle, createRustAnnotationCameraCore, createShadowPlane, detectAnnotationLaterality, disposeCharacterModel, extendModelReferencePose, filterCameraViewRegions, getDefaultAnnotationLaterality, getModelLocalOrbitAngle, getRuntimeAUMeshSideOffset, getRuntimeAUMorphAnchorPoint, getRuntimeAnnotationSide, getSemanticHorizontalSign, getSemanticHorizontalSignForSide, getWorldDirectionForCameraAngle, inferRuntimeAnnotationPreviewSide, isRuntimeAnnotationRegionName, loadCharacterModel, normalizeDefaultCharacterLightingSettings, parseCharacterModel, passesMarkerCameraAngleGate, pickContinuumAnnotationAuId, resolveAnnotationCharacterConfig, resolveFaceCenter, resolveMarkerAnchorRegion, resolveRegionCameraAngle, resolveRegionVisibilityCameraAngle, serializeAnimationClips, shouldProjectMarkerAnchorToSurface, shouldUseFaceCenterForMarkerAnchor, toWorldDirection };
+export { BLENDING_MODES, CHARACTER_SCENE_TYPES, CHARACTER_SCENE_TYPE_IDS, DPthreeCameraController as CameraController, CameraDOMControls, CameraDOMControls as Controls, DEFAULT_CHARACTER_LIGHTING_PRESETS, DEFAULT_CHARACTER_LIGHTING_PRESET_ID, DEFAULT_CHARACTER_LIGHTING_PRESET_IDS, DEFAULT_CHARACTER_LIGHTING_SETTINGS, DEFAULT_CHARACTER_SCENE_TYPE_ID, DEFAULT_MARKER_AUTO_HIDE_MS, DEFAULT_PREVIEW_AUTO_CLEAR_MS, DPthree, DPthree3DMarkers, DPthreeCameraController, DPthreeHTMLMarkers, DPthreeMarkers, Embody, DPthree3DMarkers as Markers3D, DPthreeHTMLMarkers as MarkersHTML, RUNTIME_ANNOTATION_REGION_PREFIX, RustAnnotationCameraCore, THREE_BLENDING_MODES, ThreeFrameApplier, ThreeModelInspector, ThreeNativePlaybackConnector, analyzeModel, applyAUBoneBindingUpdate, applyBilateralAxisBindingUpdate, applyBoneAxisBindingUpdate, applyCharacterModelTransform, bindModelReferencePose, boneResolutionProfile, buildBoneAuOptions, buildRegionDisplayOptions, captureModelReferencePose, classifyAuAsJointControl, collectMorphMeshes, computeHumanoidSkeletonTemplateRestBounds, createAnimationClipFromClipIR, createBilateralBoneAxisAu, createBoneAxisAu, createCharacterHost, createDefaultCharacterLighting, createDefaultCharacterScene, createDefaultCharacterSceneAsync, createDefaultCharacterSceneRuntime, createMarkerLifecycleRevealOptions, createMarkerVisibilityLifecycle, createRuntimeAnnotationPreviewLifecycle, createRustAnnotationCameraCore, createRustEmbodyHost, createRustEmbodyHostUnbound, createScenePlaybackFrame, createShadowPlane, createValidationSkeletonFromHumanoidTemplate, detectAnnotationLaterality, disposeCharacterModel, ensureBilateralBoneNodeKeys, ensureBoneNodeKey, extendCharacterConfigWithPreset, extendModelReferencePose, extractHumanoidSkeletonTemplateFromModel, extractModelData, extractProfileOverrides, filterCameraViewRegions, findNodeKeyForBone, formatAxisDirectionLabel, formatAxisLabel, fuzzyNameMatch, getAUBoneBindingState, getAxisFromChannel, getBilateralAxisBindingState, getBodyControls, getBoneAxisBindingState, getDefaultAnnotationLaterality, getHumanoidSkeletonTemplate, getHumanoidSkeletonTemplateBoneNames, getHumanoidSpecification, getMeshNamesForAUProfile, getModelLocalOrbitAngle, getPreset, getRuntimeAUMeshSideOffset, getRuntimeAUMorphAnchorPoint, getRuntimeAnnotationSide, getSemanticHorizontalSign, getSemanticHorizontalSignForSide, getWorldDirectionForCameraAngle, hasLeftRightMorphs, inferChiralBoneNamePair, inferEyeControlFamily, inferEyeControlScope, inferRuntimeAnnotationPreviewSide, isJointControlAuInfo, isMaxDegreesOnlyAxisBindingUpdate, isMixedAU, isRuntimeAnnotationRegionName, loadCharacterModel, mergeCharacterRegionsByName, normalizeDefaultCharacterLightingSettings, normalizeHairColorAppearance, parseCharacterModel, passesMarkerCameraAngleGate, pickContinuumAnnotationAuId, renderScenePlayback, resolveAnnotationCharacterConfig, resolveBoneAxisChannel, resolveBoneNameForNodeKey, resolveBoneNames, resolveContinuumDisplayLabel, resolveFaceCenter, resolveHumanoidCharacterization, resolveMarkerAnchorRegion, resolveRegionCameraAngle, resolveRegionVisibilityCameraAngle, resolveVisemeProfile, serializeAnimationClips, setAUMorphTargets, setHumanoidRoleBinding, shouldProjectMarkerAnchorToSurface, shouldUseFaceCenterForMarkerAnchor, stripConfiguredBoneAffixes, supportsRustEmbodyPreset, toWorldDirection, validateHumanoidCharacterization, validateMappings };
 //# sourceMappingURL=three.js.map
 //# sourceMappingURL=three.js.map