@lovelace_lol/embody 0.0.14 → 0.0.16

package/dist/index.js

@@ -1,10 +1,10 @@
-import * as THREE10 from 'three';
-import { NoBlending, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NormalBlending, Timer, Quaternion, Vector3, Matrix4, AnimationMixer, AdditiveAnimationBlendMode, NormalAnimationBlendMode, LoopOnce, LoopRepeat, LoopPingPong, PropertyBinding, Euler, AnimationUtils, InterpolateDiscrete, InterpolateLinear, Box3, MathUtils, Mesh, PlaneGeometry, ShadowMaterial, HemisphereLight, DirectionalLight, SRGBColorSpace, ACESFilmicToneMapping, WebGLRenderer, Scene, Color, PerspectiveCamera, PCFShadowMap, PCFSoftShadowMap, NumberKeyframeTrack, QuaternionKeyframeTrack, VectorKeyframeTrack, AnimationClip, PMREMGenerator, FloatType, Float32BufferAttribute, BufferAttribute, WebGPUCoordinateSystem, WebGLCoordinateSystem } from 'three';
-import { CC4_HUMANOID_SKELETON_TEMPLATE, HUMANOID_SKELETON_TEMPLATES, DEFAULT_HAIR_COLOR_APPEARANCE, requireInitializedEmbodyCore, initEmbodyCore } from '@lovelace_lol/embody/wasm';
+import * as THREE11 from 'three';
+import { Matrix4, NoBlending, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NormalBlending, Timer, Quaternion, Vector3, NormalAnimationBlendMode, InterpolateLinear, InterpolateDiscrete, QuaternionKeyframeTrack, VectorKeyframeTrack, AnimationClip, LoadingManager, AnimationMixer, AdditiveAnimationBlendMode, LoopOnce, LoopRepeat, LoopPingPong, PropertyBinding, Euler, AnimationUtils, Box3, MathUtils, Mesh, PlaneGeometry, ShadowMaterial, HemisphereLight, DirectionalLight, SRGBColorSpace, ACESFilmicToneMapping, WebGLRenderer, Scene, Color, PerspectiveCamera, PCFShadowMap, PCFSoftShadowMap, NumberKeyframeTrack, MeshBasicMaterial, TextureLoader, Texture, PMREMGenerator, Group, FloatType, Float32BufferAttribute, BufferAttribute, EquirectangularReflectionMapping, CanvasTexture, WebGPUCoordinateSystem, WebGLCoordinateSystem } from 'three';
+import { CC4_HUMANOID_SKELETON_TEMPLATE, HUMANOID_SKELETON_TEMPLATES, DEFAULT_HAIR_COLOR_APPEARANCE, initEmbodyCore, requireInitializedEmbodyCore } from '@lovelace_lol/embody/wasm';
 export * 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, LEGACY_BODY_CONTROL_AUS, VISEME_KEYS, getAUDescriptors } from '@lovelace_lol/embody/wasm';
-import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
 
@@ -33,46 +33,72 @@ function annotationProfileInput(profile) {
   }
   return result;
 }
-function getRuntimeAnnotationSide(region) {
-  return annotationQuery("side", { region });
-}
-function getRuntimeAUMeshSideOffset(region, sideSign, modelSize) {
-  const value = annotationQuery("meshSideOffset", { region, sideSign, size: modelSize });
-  return value ? new THREE10.Vector3(value.x, value.y, value.z) : null;
+function readAttribute(attribute) {
+  const values = new Float32Array(attribute.count * attribute.itemSize);
+  for (let index = 0; index < attribute.count; index++) for (let axis = 0; axis < attribute.itemSize; axis++) values[index * attribute.itemSize + axis] = attribute.getComponent(index, axis);
+  return values;
 }
-function getRuntimeAUMorphAnchorPoint(region, mesh) {
-  const core = requireInitializedEmbodyCore();
-  const names = annotationQuery("morphNames", { region });
-  const positions = mesh.geometry.getAttribute("position");
-  if (!positions) return null;
+function readMorphGeometry(mesh, names) {
+  const position = mesh.geometry.getAttribute("position");
+  if (!position || position.itemSize !== 3) return null;
   const attributes = names.flatMap((name) => {
     const index = mesh.morphTargetDictionary?.[name];
     const attribute = index == null ? void 0 : mesh.geometry.morphAttributes.position?.[index];
     return attribute ? [attribute] : [];
   });
-  const base = readAttribute(positions);
+  if (!attributes.length || attributes.some((attribute) => attribute.count !== position.count || attribute.itemSize !== 3)) return null;
+  const base = readAttribute(position);
   const morphs = new Float32Array(attributes.length * base.length);
   attributes.forEach((attribute, index) => morphs.set(readAttribute(attribute), index * base.length));
-  const candidates = core.annotation_morph_candidates(base, morphs, mesh.geometry.morphTargetsRelative);
-  mesh.updateWorldMatrix(true, false);
+  return { base, morphs, relative: mesh.geometry.morphTargetsRelative };
+}
+function updateAnnotationWorldMatrices(model) {
+  model.parent?.updateWorldMatrix(true, false);
+  model.updateMatrixWorld(true);
+}
+function sampleMorphVertices(mesh, indices, samples, vertex = new THREE11.Vector3()) {
   const skinned = mesh;
-  if (skinned.isSkinnedMesh) skinned.skeleton.update();
-  const samples = new Float32Array(candidates.length / 2 * 4);
-  const vertex = new THREE10.Vector3();
-  for (let offset = 0; offset < candidates.length; offset += 2) {
-    mesh.getVertexPosition(candidates[offset], vertex).applyMatrix4(mesh.matrixWorld);
-    samples.set([vertex.x, vertex.y, vertex.z, candidates[offset + 1]], offset * 2);
+  if (skinned.isSkinnedMesh) {
+    for (const bone of skinned.skeleton.bones) bone.updateWorldMatrix(true, false);
+    skinned.skeleton.update();
+  }
+  for (let offset = 0; offset < indices.length; offset++) {
+    mesh.getVertexPosition(indices[offset], vertex).applyMatrix4(mesh.matrixWorld);
+    samples[offset * 3] = vertex.x;
+    samples[offset * 3 + 1] = vertex.y;
+    samples[offset * 3 + 2] = vertex.z;
   }
-  const value = core.annotation_morph_center(JSON.stringify(region), samples);
-  return value.length === 3 ? new THREE10.Vector3().fromArray(value) : null;
 }
+var MorphGeometryObservation = class {
+  constructor() {
+    __publicField(this, "revision", 0);
+    __publicField(this, "namesJson", "[]");
+    __publicField(this, "signature", []);
+  }
+  observe(mesh) {
+    const dictionary = Object.entries(mesh.morphTargetDictionary ?? {}).sort(([a], [b]) => a.localeCompare(b));
+    const attributes = [mesh.geometry.getAttribute("position"), ...mesh.geometry.morphAttributes.position ?? []];
+    const signature = [mesh.geometry, mesh.geometry.morphTargetsRelative, ...dictionary.flat()];
+    for (const attribute of attributes) {
+      signature.push(attribute);
+      if (attribute) signature.push(
+        attribute.array,
+        attribute.count,
+        attribute.itemSize,
+        attribute.normalized,
+        "data" in attribute ? attribute.data.version : attribute.version,
+        "data" in attribute ? attribute.data.stride : 0,
+        "offset" in attribute ? attribute.offset : 0
+      );
+    }
+    if (signature.length === this.signature.length && signature.every((value, index) => value === this.signature[index])) return;
+    this.signature = signature;
+    this.revision++;
+    this.namesJson = JSON.stringify(dictionary.map(([name]) => name));
+  }
+};
 
 // three/annotations/modelObservation.ts
-function readAttribute(attribute) {
-  const values = new Float32Array(attribute.count * attribute.itemSize);
-  for (let index = 0; index < attribute.count; index++) for (let axis = 0; axis < attribute.itemSize; axis++) values[index * attribute.itemSize + axis] = attribute.getComponent(index, axis);
-  return values;
-}
 var bounds = (box) => box.isEmpty() ? null : { min: box.min.toArray(), max: box.max.toArray() };
 var AnnotationModelObserver = class {
   constructor(model) {
@@ -80,6 +106,10 @@ var AnnotationModelObserver = class {
     __publicField(this, "objects", /* @__PURE__ */ new Map());
     __publicField(this, "meshes", []);
     __publicField(this, "ids", /* @__PURE__ */ new Map());
+    __publicField(this, "morphGeneration", null);
+    __publicField(this, "morphObservations", []);
+    __publicField(this, "morphGeometry", /* @__PURE__ */ new Map());
+    __publicField(this, "vertex", new THREE11.Vector3());
     model.traverse((object) => {
       const id = this.objects.size + 1;
       this.ids.set(object, id);
@@ -90,13 +120,16 @@ var AnnotationModelObserver = class {
   id(object) {
     return this.ids.get(object);
   }
+  updateWorldMatrices() {
+    updateAnnotationWorldMatrices(this.model);
+  }
   capture() {
-    this.model.updateWorldMatrix(true, true);
-    const modelBox = new THREE10.Box3().setFromObject(this.model);
-    if (modelBox.isEmpty()) modelBox.setFromCenterAndSize(this.model.getWorldPosition(new THREE10.Vector3()), new THREE10.Vector3());
+    this.updateWorldMatrices();
+    const modelBox = new THREE11.Box3().setFromObject(this.model);
+    if (modelBox.isEmpty()) modelBox.setFromCenterAndSize(this.model.getWorldPosition(new THREE11.Vector3()), new THREE11.Vector3());
     return {
       bounds: bounds(modelBox),
-      quaternion: this.model.getWorldQuaternion(new THREE10.Quaternion()).toArray(),
+      quaternion: this.model.getWorldQuaternion(new THREE11.Quaternion()).toArray(),
       inverse: this.model.matrixWorld.clone().invert().toArray(),
       objects: [...this.objects].map(([id, object]) => {
         const mesh = object;
@@ -106,8 +139,8 @@ var AnnotationModelObserver = class {
           name: object.name,
           kind: mesh.isMesh ? "Mesh" : bone ? "Bone" : object.type,
           parent: object.parent ? this.ids.get(object.parent) ?? null : null,
-          position: object.getWorldPosition(new THREE10.Vector3()).toArray(),
-          bounds: bone ? null : bounds(new THREE10.Box3().setFromObject(object)),
+          position: object.getWorldPosition(new THREE11.Vector3()).toArray(),
+          bounds: bone ? null : bounds(new THREE11.Box3().setFromObject(object)),
           matrix: object.matrixWorld.toArray(),
           inverse: object.matrixWorld.clone().invert().toArray(),
           morphNames: Object.keys(mesh.morphTargetDictionary ?? {})
@@ -121,7 +154,7 @@ var AnnotationModelObserver = class {
   transforms(runtime) {
     const ids = runtime.tracked_objects();
     if (!ids.length) return new Float32Array();
-    this.model.updateWorldMatrix(true, true);
+    this.updateWorldMatrices();
     const values = new Float32Array(ids.length * 17);
     ids.forEach((id, index) => {
       const object = this.objects.get(id);
@@ -132,16 +165,51 @@ var AnnotationModelObserver = class {
     });
     return values;
   }
-  morphAnchors(runtime) {
+  prepareMorphAnchors(runtime) {
+    const generation = runtime.generation();
+    if (!runtime.is_current(generation)) return;
+    if (this.morphGeneration !== generation) this.morphObservations = [];
+    this.morphGeneration = generation;
+    const changed = /* @__PURE__ */ new Set();
+    for (const mesh of this.meshes) {
+      const id = this.ids.get(mesh);
+      let observation = this.morphGeometry.get(id);
+      if (!observation) {
+        observation = new MorphGeometryObservation();
+        this.morphGeometry.set(id, observation);
+      }
+      observation.observe(mesh);
+      if (runtime.observe_morph_geometry(generation, id, observation.revision, observation.namesJson)) changed.add(id);
+    }
+    if (!changed.size) return;
+    this.morphObservations = this.morphObservations.filter((observation) => !changed.has(observation.objectId));
     const requests = JSON.parse(runtime.command("morphRequests", "{}", performance.now()));
-    const anchors = {};
     for (const request3 of requests) {
+      if (!changed.has(request3.objectId)) continue;
       const mesh = this.objects.get(request3.objectId);
       if (!mesh?.isMesh) continue;
-      const point2 = getRuntimeAUMorphAnchorPoint(request3.region, mesh);
-      if (point2) anchors[request3.region.name] = { x: point2.x, y: point2.y, z: point2.z };
+      const geometry = readMorphGeometry(mesh, request3.morphNames);
+      if (!geometry) continue;
+      const plan = runtime.prepare_morph_anchor(generation, request3.objectId, request3.region.name, geometry.base, geometry.morphs, geometry.relative);
+      if (plan.length < 2) continue;
+      const indices = plan.slice(1);
+      this.morphObservations.push({ planId: plan[0], objectId: request3.objectId, mesh, indices, samples: new Float32Array(indices.length * 3) });
+    }
+  }
+  /** Transport only: Rust owns the vertex selection, weights and live anchor. */
+  observeMorphAnchors(runtime) {
+    this.prepareMorphAnchors(runtime);
+    if (this.morphGeneration === null || !runtime.is_current(this.morphGeneration)) {
+      this.morphObservations = [];
+      this.morphGeneration = null;
+      return;
+    }
+    if (!this.morphObservations.length) return;
+    this.updateWorldMatrices();
+    for (const { planId, mesh, indices, samples } of this.morphObservations) {
+      sampleMorphVertices(mesh, indices, samples, this.vertex);
+      runtime.observe_morph_anchor(this.morphGeneration, planId, samples);
     }
-    return anchors;
   }
   /** Rust selects influenced vertices; Three evaluates the current native pose. */
   observeFocus(runtime, request3) {
@@ -162,7 +230,7 @@ var AnnotationModelObserver = class {
         if (index < 0 || !skinIndices || !skinWeights) continue;
         mesh.skeleton.update();
         const selected = core.annotation_bone_vertices(readAttribute(skinIndices), readAttribute(skinWeights), new Uint32Array([index]));
-        const vertex = new THREE10.Vector3();
+        const vertex = new THREE11.Vector3();
         for (const selectedIndex of selected) {
           mesh.getVertexPosition(selectedIndex, vertex).applyMatrix4(mesh.matrixWorld);
           points.push(vertex.x, vertex.y, vertex.z);
@@ -192,9 +260,9 @@ function bindSceneRendering(controller, scene, camera, binding) {
   if (owner.scene !== scene || owner.camera !== camera) throw new Error("Rendering and camera controllers must share their scene and camera.");
   if (owner.binding) throw new Error("Character scene rendering already has a camera controller.");
   owner.binding = binding;
-  const snapshot2 = controller.getSnapshot();
-  if (snapshot2.renderer) void binding.commit(snapshot2.renderer).catch(binding.onError);
-  if (snapshot2.status !== "ready" && snapshot2.status !== "error") void binding.suspend().catch(binding.onError);
+  const snapshot3 = controller.getSnapshot();
+  if (snapshot3.renderer) void binding.commit(snapshot3.renderer).catch(binding.onError);
+  if (snapshot3.status !== "ready" && snapshot3.status !== "error") void binding.suspend().catch(binding.onError);
   return () => {
     if (owner.binding === binding) {
       owner.drain = binding.suspend();
@@ -236,8 +304,8 @@ function prepareModelSkinning(model) {
   };
 }
 var bindings = /* @__PURE__ */ new WeakMap();
-function bindPlaybackRendering(model, mixer, afterFrame) {
-  const binding = { mixer, enabled: true, afterFrame };
+function bindPlaybackRendering(model, mixer, afterFrame, afterSample) {
+  const binding = { mixer, enabled: true, disposed: false, afterFrame, afterSample };
   const entries = bindings.get(model) ?? /* @__PURE__ */ new Set();
   entries.add(binding);
   bindings.set(model, entries);
@@ -246,6 +314,7 @@ function bindPlaybackRendering(model, mixer, afterFrame) {
       binding.enabled = enabled;
     },
     dispose() {
+      binding.disposed = true;
       entries.delete(binding);
       if (!entries.size) bindings.delete(model);
     }
@@ -262,8 +331,16 @@ function renderScenePlayback(scene, timer) {
       }
     }
   });
-  for (const mixer of mixers) mixer.update(timer.getDelta());
-  for (const binding of active) binding.afterFrame();
+  const deltaSeconds = timer.getDelta();
+  const elapsed = /* @__PURE__ */ new Map();
+  for (const mixer of mixers) {
+    elapsed.set(mixer, Math.abs(deltaSeconds * mixer.timeScale));
+    mixer.update(deltaSeconds);
+  }
+  for (const binding of active) if (binding.enabled && !binding.disposed) {
+    binding.afterSample?.(elapsed.get(binding.mixer));
+  }
+  for (const binding of active) if (binding.enabled && !binding.disposed) binding.afterFrame(deltaSeconds);
 }
 function createScenePlaybackFrame(scene, document2) {
   const timer = new Timer();
@@ -349,12 +426,12 @@ function compileModelForRender(renderer, scene, camera, model) {
   });
 }
 function drawModelForRender(renderer, scene, camera, model) {
-  const viewport = renderer.getViewport(new THREE10.Vector4());
-  const scissor = renderer.getScissor(new THREE10.Vector4());
+  const viewport = renderer.getViewport(new THREE11.Vector4());
+  const scissor = renderer.getScissor(new THREE11.Vector4());
   const scissorTest = renderer.getScissorTest();
   const restoreRenderTarget = captureRenderTarget(renderer);
   const autoClear = renderer.autoClear;
-  const clearColor = renderer.getClearColor(Object.assign(new THREE10.Color(), { a: 1 }));
+  const clearColor = renderer.getClearColor(Object.assign(new THREE11.Color(), { a: 1 }));
   const clearAlpha = renderer.getClearAlpha();
   const native = "isWebGPURenderer" in renderer ? renderer : null;
   const renderObject = native?.getRenderObjectFunction();
@@ -778,14 +855,14 @@ var CameraDOMControls = class {
     this.wrapper.remove();
   }
 };
-var ThreeAnnotationControls = class extends THREE10.EventDispatcher {
+var ThreeAnnotationControls = class extends THREE11.EventDispatcher {
   constructor(domElement, runtime, advance, captureInput = true) {
     super();
     this.domElement = domElement;
     this.runtime = runtime;
     this.advance = advance;
     this.captureInput = captureInput;
-    __publicField(this, "target", new THREE10.Vector3());
+    __publicField(this, "target", new THREE11.Vector3());
     __publicField(this, "disposed", false);
     __publicField(this, "previousTouchAction", "");
     __publicField(this, "connected", false);
@@ -928,12 +1005,12 @@ var ThreeAnnotationRenderer = class {
     this.domElement = domElement;
     this.onPick = onPick;
     this.onHover = onHover;
-    __publicField(this, "group", new THREE10.Group());
+    __publicField(this, "group", new THREE11.Group());
     __publicField(this, "objects", /* @__PURE__ */ new Map());
     __publicField(this, "overlay");
-    __publicField(this, "raycaster", new THREE10.Raycaster());
-    __publicField(this, "pointer", new THREE10.Vector2());
-    __publicField(this, "viewProjection", new THREE10.Matrix4());
+    __publicField(this, "raycaster", new THREE11.Raycaster());
+    __publicField(this, "pointer", new THREE11.Vector2());
+    __publicField(this, "viewProjection", new THREE11.Matrix4());
     __publicField(this, "overlayParent", null);
     __publicField(this, "releaseParentPosition", null);
     __publicField(this, "overlayResizeObserver");
@@ -991,28 +1068,28 @@ var ThreeAnnotationRenderer = class {
     this.attachOverlay();
     element.addEventListener("click", this.click);
   }
-  sync(snapshot2) {
-    if (this.revision === snapshot2.descriptorRevision && this.style === snapshot2.style) return;
-    if (this.style !== snapshot2.style) this.clear();
-    this.style = snapshot2.style;
-    const ids = new Set(snapshot2.descriptors.map((descriptor) => descriptor.id));
+  sync(snapshot3) {
+    if (this.revision === snapshot3.descriptorRevision && this.style === snapshot3.style) return;
+    if (this.style !== snapshot3.style) this.clear();
+    this.style = snapshot3.style;
+    const ids = new Set(snapshot3.descriptors.map((descriptor) => descriptor.id));
     for (const id of this.objects.keys()) if (!ids.has(id)) this.remove(id);
-    for (const descriptor of snapshot2.descriptors) {
+    for (const descriptor of snapshot3.descriptors) {
       const signature = JSON.stringify(descriptor);
       if (this.objects.get(descriptor.id)?.descriptor === signature) continue;
       this.remove(descriptor.id);
       this.objects.set(descriptor.id, this.create(descriptor, signature));
     }
-    this.revision = snapshot2.descriptorRevision;
+    this.revision = snapshot3.descriptorRevision;
   }
   create(descriptor, signature) {
     const { style } = descriptor;
-    const sphere = new THREE10.Mesh(new THREE10.SphereGeometry(descriptor.radius, 12, 12), new THREE10.MeshBasicMaterial({ color: style.markerColor, transparent: true }));
+    const sphere = new THREE11.Mesh(new THREE11.SphereGeometry(descriptor.radius, 12, 12), new THREE11.MeshBasicMaterial({ color: style.markerColor, transparent: true }));
     const dashed = style.line.style === "dashed" || style.line.style === "dotted";
-    const material = dashed ? new THREE10.LineDashedMaterial({ color: style.lineColor, transparent: true, dashSize: style.line.style === "dotted" ? 5e-3 : 0.02, gapSize: 0.01, linewidth: style.line.thickness }) : new THREE10.LineBasicMaterial({ color: style.lineColor, transparent: true, linewidth: style.line.thickness });
-    const geometry = new THREE10.BufferGeometry();
-    geometry.setAttribute("position", new THREE10.BufferAttribute(new Float32Array(51), 3));
-    const line = new THREE10.Line(geometry, material);
+    const material = dashed ? new THREE11.LineDashedMaterial({ color: style.lineColor, transparent: true, dashSize: style.line.style === "dotted" ? 5e-3 : 0.02, gapSize: 0.01, linewidth: style.line.thickness }) : new THREE11.LineBasicMaterial({ color: style.lineColor, transparent: true, linewidth: style.line.thickness });
+    const geometry = new THREE11.BufferGeometry();
+    geometry.setAttribute("position", new THREE11.BufferAttribute(new Float32Array(51), 3));
+    const line = new THREE11.Line(geometry, material);
     const canvas = document.createElement("canvas");
     const context = canvas.getContext("2d");
     if (!context) {
@@ -1033,9 +1110,9 @@ var ThreeAnnotationRenderer = class {
     context.fillRect(0, 0, canvas.width, canvas.height);
     context.fillStyle = style.labelColor;
     context.fillText(descriptor.label, canvas.width / 2, canvas.height / 2);
-    const texture = new THREE10.CanvasTexture(canvas);
-    const label = new THREE10.Sprite(new THREE10.SpriteMaterial({ map: texture, transparent: true, depthTest: true, depthWrite: false, sizeAttenuation: false }));
-    const arrow = style.line.arrowHead ? new THREE10.Mesh(new THREE10.ConeGeometry(descriptor.arrowRadius, descriptor.arrowLength, 8), new THREE10.MeshBasicMaterial({ color: style.lineColor, transparent: true })) : null;
+    const texture = new THREE11.CanvasTexture(canvas);
+    const label = new THREE11.Sprite(new THREE11.SpriteMaterial({ map: texture, transparent: true, depthTest: true, depthWrite: false, sizeAttenuation: false }));
+    const arrow = style.line.arrowHead ? new THREE11.Mesh(new THREE11.ConeGeometry(descriptor.arrowRadius, descriptor.arrowLength, 8), new THREE11.MeshBasicMaterial({ color: style.lineColor, transparent: true })) : null;
     let element = null;
     if (this.style === "html") {
       element = document.createElement("div");
@@ -1070,7 +1147,7 @@ var ThreeAnnotationRenderer = class {
     const rays = this.runtime.occlusion_queries();
     const hits = new Float32Array(rays.length / 8 * 2);
     for (let offset = 0; offset < rays.length; offset += 8) {
-      this.raycaster.set(new THREE10.Vector3().fromArray(rays, offset + 1), new THREE10.Vector3().fromArray(rays, offset + 4));
+      this.raycaster.set(new THREE11.Vector3().fromArray(rays, offset + 1), new THREE11.Vector3().fromArray(rays, offset + 4));
       this.raycaster.near = 0;
       this.raycaster.far = rays[offset + 7];
       const intersection = this.raycaster.intersectObjects(this.meshes, false)[0];
@@ -1097,7 +1174,7 @@ var ThreeAnnotationRenderer = class {
       positions.array.set(values.subarray(offset + 19, offset + 70));
       positions.needsUpdate = true;
       objects.line.geometry.computeBoundingSphere();
-      if (objects.line.material instanceof THREE10.LineDashedMaterial) objects.line.computeLineDistances();
+      if (objects.line.material instanceof THREE11.LineDashedMaterial) objects.line.computeLineDistances();
       objects.label.position.fromArray(values, offset + 5);
       objects.label.scale.set(values[offset + 9], values[offset + 10], 1);
       objects.label.material.opacity = values[offset + 11];
@@ -1220,7 +1297,7 @@ var ThreeAnnotationController = class _ThreeAnnotationController {
     __publicField(this, "markerStateListeners", /* @__PURE__ */ new Set());
     __publicField(this, "regionListeners", /* @__PURE__ */ new Set());
     __publicField(this, "renderer", null);
-    __publicField(this, "playbackTimer", new THREE10.Timer());
+    __publicField(this, "playbackTimer", new THREE11.Timer());
     __publicField(this, "renderFrame");
     __publicField(this, "resizeRenderer");
     __publicField(this, "onRenderError");
@@ -1248,7 +1325,7 @@ var ThreeAnnotationController = class _ThreeAnnotationController {
     }, nativeOptions.captureInput);
     this.state = this.readState();
     if (this.manageCamera) this.applyCameraState(this.state.camera);
-    else this.controls.target.copy(this.camera.getWorldDirection(new THREE10.Vector3()).add(this.camera.position));
+    else this.controls.target.copy(this.camera.getWorldDirection(new THREE11.Vector3()).add(this.camera.position));
     this.markerRenderer = new ThreeAnnotationRenderer(this.runtime, this.scene, this.camera, this.domElement, (ids) => this.pick(ids), (id) => {
       if (!this.disposed) {
         this.call("hover", { id });
@@ -1451,11 +1528,12 @@ var ThreeAnnotationController = class _ThreeAnnotationController {
     const observer = this.observer;
     const generation = this.runtime.generation();
     observer.observe(this.runtime);
-    const queries = JSON.parse(this.runtime.plan_markers(JSON.stringify(observer.morphAnchors(this.runtime))));
+    observer.observeMorphAnchors(this.runtime);
+    const queries = JSON.parse(this.runtime.plan_markers("{}"));
     for (const initial of queries) {
       let query = initial;
       while (query && this.isCurrent(generation)) {
-        const raycaster = new THREE10.Raycaster(new THREE10.Vector3().fromArray(query.origin), new THREE10.Vector3().fromArray(query.direction), 0, query.far);
+        const raycaster = new THREE11.Raycaster(new THREE11.Vector3().fromArray(query.origin), new THREE11.Vector3().fromArray(query.direction), 0, query.far);
         const hits = sliceSurfaceQueries ? await intersectMeshesInSlices(raycaster, observer.meshes, { isCurrent: () => this.isCurrent(generation), yieldToPaint: waitForCharacterLoadPaint }) : raycaster.intersectObjects(observer.meshes, false);
         if (!hits || !this.isCurrent(generation)) return;
         query = JSON.parse(this.runtime.surface_result(query.generation, query.id, query.phase, new Float32Array(hits.flatMap((hit) => hit.point.toArray()))));
@@ -1566,6 +1644,7 @@ var ThreeAnnotationController = class _ThreeAnnotationController {
     if (this.disposed) return;
     this.cancelModelPreparation();
     this.call("clear");
+    this.observer?.observeMorphAnchors(this.runtime);
     this.hostConfig = null;
     this.configSnapshot = null;
     this.configSnapshotHost = null;
@@ -1679,7 +1758,10 @@ var ThreeAnnotationController = class _ThreeAnnotationController {
       this.controls.target.fromArray(pose, 3);
       this.camera.lookAt(this.controls.target);
     }
-    if (this.observer) this.runtime.observe_transforms(this.observer.transforms(this.runtime));
+    if (this.observer) {
+      this.runtime.observe_transforms(this.observer.transforms(this.runtime));
+      this.observer.observeMorphAnchors(this.runtime);
+    }
     this.sync();
     this.markerRenderer.update(now);
     this.settleFlights();
@@ -1937,7 +2019,7 @@ var ThreeAnnotationMarkers = class {
   }
   getMarkerPosition(name) {
     const p = this.controller.getMarkerPosition(name);
-    return p ? new THREE10.Vector3(p.x, p.y, p.z) : null;
+    return p ? new THREE11.Vector3(p.x, p.y, p.z) : null;
   }
   updateLineStyle(name, line) {
     this.controller.setRegionLineStyle(name, line);
@@ -2112,11 +2194,35 @@ function shouldUseFaceCenterForMarkerAnchor(resolved) {
 function shouldProjectMarkerAnchorToSurface(resolved, legacyDefault) {
   return annotationQuery("projectAnchor", { resolved, legacyDefault });
 }
+function getRuntimeAnnotationSide(region) {
+  return annotationQuery("side", { region });
+}
+function getRuntimeAUMeshSideOffset(region, sideSign, modelSize) {
+  const value = annotationQuery("meshSideOffset", { region, sideSign, size: modelSize });
+  return value ? new THREE11.Vector3(value.x, value.y, value.z) : null;
+}
+function getRuntimeAUMorphAnchorPoint(region, mesh) {
+  const core = requireInitializedEmbodyCore();
+  const names = annotationQuery("morphNames", { region });
+  const geometry = readMorphGeometry(mesh, names);
+  if (!geometry) return null;
+  const candidates = core.annotation_morph_anchor_candidates(JSON.stringify(region), geometry.base, geometry.morphs, geometry.relative);
+  updateAnnotationWorldMatrices(mesh);
+  const positions = new Float32Array(candidates.length / 2 * 3);
+  sampleMorphVertices(mesh, candidates.filter((_value, index) => index % 2 === 0), positions);
+  const samples = new Float32Array(candidates.length / 2 * 4);
+  for (let index = 0; index < candidates.length / 2; index++) {
+    samples.set(positions.subarray(index * 3, index * 3 + 3), index * 4);
+    samples[index * 4 + 3] = candidates[index * 2 + 1];
+  }
+  const value = core.annotation_weighted_anchor(samples);
+  return value.length === 3 ? new THREE11.Vector3().fromArray(value) : null;
+}
 var AnnotationLifecycleBridge = class {
-  constructor(mode, duration, apply) {
+  constructor(mode, duration, apply2) {
     this.mode = mode;
     this.duration = duration;
-    this.apply = apply;
+    this.apply = apply2;
     __publicField(this, "readiness", Promise.resolve());
     __publicField(this, "initializing", null);
     __publicField(this, "core", null);
@@ -2258,96 +2364,6 @@ function boneResolutionProfile(profile) {
     suffixPattern: profile.suffixPattern
   };
 }
-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 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)) {
@@ -2472,6 +2488,286 @@ function bindModelReferencePose(model, referencePose) {
   if (index !== referencePose.nodes.length) throw new Error("Incompatible reference pose hierarchy: extra captured nodes");
   return bindings2;
 }
+
+// three/vrm-animation.ts
+var MAX_BYTES = 64 * 1024 * 1024;
+var identity = new Matrix4();
+var isBone2 = (node) => node.isBone || node.type === "Bone";
+function decomposeReference(matrix, name) {
+  const position = new Vector3();
+  const rotation = new Quaternion();
+  const scale = new Vector3();
+  if (!matrix.elements.every(Number.isFinite) || Math.abs(matrix.determinant()) < 1e-20) {
+    throw new Error(`Invalid reference matrix for ${name}`);
+  }
+  matrix.decompose(position, rotation, scale);
+  const reconstructed = new Matrix4().compose(position, rotation, scale);
+  if (matrix.elements.some((v, i) => Math.abs(v - reconstructed.elements[i]) > 1e-5 * Math.max(1, Math.abs(v)))) {
+    throw new Error(`Reference ${name} contains shear, which VRMA retargeting does not support`);
+  }
+  return { translation: position.toArray(), rotation: rotation.toArray(), scale: scale.toArray() };
+}
+function objectsInModel(model) {
+  const all = [];
+  model.traverse((node) => all.push(node));
+  const needed = /* @__PURE__ */ new Set([model]);
+  for (const bone of all.filter(isBone2)) {
+    for (let node = bone; node && node !== model; node = node.parent) needed.add(node);
+  }
+  const objects = all.filter((node) => needed.has(node));
+  if (objects.length > 4096) throw new Error("Animation rig exceeds 4096 nodes");
+  const ids = new Map(objects.map((node, i) => [node, String(i)]));
+  return { objects, ids };
+}
+function inspectReference(model, referencePose, metersPerUnit, includeRoot = false) {
+  const bindings2 = bindModelReferencePose(model, referencePose);
+  const { objects, ids } = objectsInModel(model);
+  const nodes = objects.map((node) => ({
+    id: ids.get(node),
+    name: node.name,
+    parent: node === model ? null : ids.get(node.parent),
+    // Placement of the model in a scene is not part of its humanoid coordinate system.
+    ...decomposeReference(node === model && !includeRoot ? identity : new Matrix4().fromArray(bindings2.get(node).localMatrix), node.name)
+  }));
+  return { rig: { metersPerUnit, nodes, humanoidBones: {} }, objects, ids };
+}
+function inspectSkinBind(model, metersPerUnit) {
+  if (model.parent) throw new Error("Use an explicit referencePose for a parented source model");
+  const initial = captureModelReferencePose(model);
+  const initialBindings = bindModelReferencePose(model, initial);
+  const { objects, ids } = objectsInModel(model);
+  const world = /* @__PURE__ */ new Map();
+  const all = [];
+  model.traverse((node) => all.push(node));
+  for (const node of all) {
+    const mesh = node;
+    if (!mesh.isSkinnedMesh) continue;
+    const { bones, boneInverses } = mesh.skeleton;
+    if (bones.length !== boneInverses.length) throw new Error("Invalid skin bind inverse count");
+    bones.forEach((bone, index) => {
+      const inverse = boneInverses[index];
+      if (Math.abs(inverse.determinant()) < 1e-20) throw new Error(`Singular bind matrix for ${bone.name}`);
+      const bind = inverse.clone().invert();
+      const prior = world.get(bone);
+      if (prior && prior.elements.some((value, i) => Math.abs(value - bind.elements[i]) > 1e-4)) {
+        throw new Error(`Conflicting skin bind matrices for ${bone.name}`);
+      }
+      world.set(bone, bind);
+    });
+  }
+  const nodes = objects.map((node) => {
+    if (isBone2(node) && !world.has(node)) {
+      throw new Error(`No skin bind reference for ${node.name}; supply an explicit authored T-pose reference`);
+    }
+    const nodeWorld = world.get(node) ?? new Matrix4().fromArray(initialBindings.get(node).worldMatrix);
+    const parentWorld = node.parent ? world.get(node.parent) ?? new Matrix4().fromArray(initialBindings.get(node.parent).worldMatrix) : identity;
+    const local = parentWorld.clone().invert().multiply(nodeWorld);
+    return { id: ids.get(node), name: node.name, parent: node === model ? null : ids.get(node.parent), ...decomposeReference(local, node.name) };
+  });
+  return { rig: { metersPerUnit, nodes, humanoidBones: {} }, objects, ids };
+}
+function uniqueBone(objects, name) {
+  const matches = objects.filter((node) => isBone2(node) && (node.name === name || node.uuid === name));
+  if (matches.length !== 1) throw new Error(`Animation bone ${name} must resolve uniquely (found ${matches.length})`);
+  return matches[0];
+}
+function convertMixamoToVrmAnimation(source, clip, options) {
+  const core = requireInitializedEmbodyCore();
+  if (clip.blendMode !== NormalAnimationBlendMode) {
+    throw new Error("VRMA conversion requires absolute local animation keys; additive clips are unsupported");
+  }
+  const { rig, objects, ids } = options.referencePose ? inspectReference(source, options.referencePose, options.metersPerUnit, true) : inspectSkinBind(source, options.metersPerUnit);
+  const tracks = clip.tracks.map((track) => {
+    const match = /^(.*)\.(quaternion|position|scale)$/.exec(track.name);
+    if (!match) throw new Error(`Unsupported Mixamo track ${track.name}`);
+    const bone = uniqueBone(objects, match[1]);
+    const interpolation = track.getInterpolation();
+    if (interpolation !== InterpolateLinear && interpolation !== InterpolateDiscrete) {
+      throw new Error(`Unsupported interpolation on ${track.name}`);
+    }
+    return {
+      node: ids.get(bone),
+      path: match[2] === "quaternion" ? "rotation" : match[2] === "position" ? "translation" : "scale",
+      interpolation: interpolation === InterpolateDiscrete ? "STEP" : "LINEAR",
+      times: Array.from(track.times),
+      values: Array.from(track.values)
+    };
+  });
+  const normalized = core.normalize_mixamo_animation(JSON.stringify({ version: 1, name: clip.name, durationSeconds: clip.duration, rig, tracks }));
+  return core.encode_vrma_animation(normalized);
+}
+function inspectVrmAnimation(bytes) {
+  if (bytes.byteLength > MAX_BYTES) throw new Error("VRMA exceeds 64 MiB");
+  return JSON.parse(requireInitializedEmbodyCore().decode_vrma_animation(bytes));
+}
+function createAnimationClipFromVrmAnimation(bytes, target, options) {
+  const core = requireInitializedEmbodyCore();
+  const document2 = inspectVrmAnimation(bytes);
+  const { rig, objects, ids } = inspectReference(target, options.referencePose, options.metersPerUnit);
+  let humanoidBones = options.humanoidBones;
+  if (!humanoidBones) {
+    if (!options.profile) throw new Error("VRMA target requires a characterized profile or explicit humanoidBones");
+    const inspection = new ThreeModelInspector().inspectModel(target, { referencePose: options.referencePose });
+    const result = JSON.parse(core.validate_humanoid_characterization(JSON.stringify(options.profile), JSON.stringify(inspection.descriptor)));
+    if (!result.valid) throw new Error(`Cannot characterize VRMA target: ${result.errors.join("; ")}`);
+    humanoidBones = Object.fromEntries(Object.entries(result.roles).map(([role, binding]) => [role, binding.boneName]));
+  }
+  for (const [role, name] of Object.entries(humanoidBones)) {
+    if (role !== "leftEye" && role !== "rightEye") rig.humanoidBones[role] = ids.get(uniqueBone(objects, name));
+  }
+  const retargeted = JSON.parse(core.retarget_vrma_animation(JSON.stringify(document2), JSON.stringify(rig)));
+  const byId = new Map(objects.map((node) => [ids.get(node), node]));
+  const tracks = retargeted.tracks.map((track) => {
+    const node = byId.get(track.node);
+    if (!node) throw new Error(`Retargeted node ${track.node} is not in the target model`);
+    const interpolation = track.interpolation === "STEP" ? InterpolateDiscrete : InterpolateLinear;
+    return track.path === "rotation" ? new QuaternionKeyframeTrack(`${node.uuid}.quaternion`, track.times, track.values, interpolation) : new VectorKeyframeTrack(`${node.uuid}.position`, track.times, track.values, interpolation);
+  });
+  return new AnimationClip(options.name ?? document2.name, retargeted.durationSeconds, tracks);
+}
+function convertMixamoFbxToVrmAnimations(bytes, options) {
+  requireInitializedEmbodyCore();
+  if (!bytes.byteLength || bytes.byteLength > MAX_BYTES) throw new Error("FBX must be between 1 byte and 64 MiB");
+  const textures = /* @__PURE__ */ new Set();
+  class AnimationTextureLoader extends TextureLoader {
+    load(url) {
+      if (url.startsWith("blob:")) URL.revokeObjectURL(url);
+      const texture = new Texture();
+      textures.add(texture);
+      return texture;
+    }
+  }
+  const manager = new LoadingManager();
+  manager.addHandler(/.*/, new AnimationTextureLoader(manager));
+  manager.setURLModifier(() => {
+    throw new Error("External FBX resources are not allowed for animation conversion");
+  });
+  let source;
+  try {
+    source = new FBXLoader(manager).parse(bytes, "");
+    if (!source.animations.length) throw new Error("FBX has no animation clips");
+    let hasSkin = false;
+    source.traverse((node) => {
+      if (node.isSkinnedMesh) hasSkin = true;
+    });
+    const referencePose = hasSkin ? void 0 : captureModelReferencePose(source);
+    return source.animations.map((clip) => ({ name: clip.name, bytes: convertMixamoToVrmAnimation(source, clip, { ...options, referencePose }) }));
+  } finally {
+    const materials2 = /* @__PURE__ */ new Set();
+    source?.traverse((node) => {
+      const mesh = node;
+      mesh.geometry?.dispose();
+      if (mesh.material) for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) materials2.add(material);
+      node.skeleton?.dispose();
+    });
+    for (const material of materials2) material.dispose();
+    for (const texture of textures) texture.dispose();
+  }
+}
+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 resolveMorphMeshSelections = (profile, categories, availableNames) => request2("profile.resolveMorphMeshSelections", { profile, categories, availableNames });
+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 getAUBoneBindingStates = (profile, auIds) => request2("bone.getAUBindingStates", {
+  profile: {
+    auToBones: profile.auToBones,
+    boneNodes: profile.boneNodes,
+    bonePrefix: profile.bonePrefix,
+    boneSuffix: profile.boneSuffix,
+    suffixPattern: profile.suffixPattern,
+    compositeRotations: profile.compositeRotations,
+    continuumPairs: profile.continuumPairs,
+    humanoidCharacterization: profile.humanoidCharacterization
+  },
+  auIds
+});
+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 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)));
+}
 function withComponentTracks(clip) {
   let expanded = false;
   const tracks = clip.tracks.flatMap((track) => {
@@ -2484,16 +2780,18 @@ function withComponentTracks(clip) {
     if (!Number.isInteger(width) || width < 1 || euler && width !== 3) throw new Error(`Invalid component track ${JSON.stringify(track.name)}.`);
     expanded = true;
     return Array.from({ length: width }, (_, component) => {
-      const scalar = track.clone();
-      scalar.name = `${track.name}[${euler ? ["x", "y", "z"][component] : component}]`;
-      scalar.values = track.values.slice(0, track.times.length * parts);
-      for (let sample = 0; sample < scalar.values.length; sample += 1) scalar.values[sample] = track.values[sample * width + component];
+      const values = track.values.slice(0, track.times.length * parts);
+      for (let sample = 0; sample < values.length; sample += 1) values[sample] = track.values[sample * width + component];
+      const Track = track.constructor;
+      const scalar = new Track(`${track.name}[${euler ? ["x", "y", "z"][component] : component}]`, track.times.slice(), values);
+      scalar.createInterpolant = track.createInterpolant;
       return scalar;
     });
   });
   if (!expanded) return clip;
-  const indexed = clip.clone();
-  indexed.tracks = tracks;
+  const Clip = clip.constructor;
+  const indexed = new Clip(clip.name, clip.duration, tracks, clip.blendMode);
+  indexed.userData = JSON.parse(JSON.stringify(clip.userData));
   return indexed;
 }
 function concreteTrackName(target, inspection) {
@@ -2565,6 +2863,23 @@ var ThreeNativePlaybackConnector = class {
     __publicField(this, "disposed", false);
     __publicField(this, "onError");
     __publicField(this, "onRelease");
+    __publicField(this, "afterSample");
+    __publicField(this, "afterFrame", (deltaSeconds) => {
+      this.flushEvents();
+      if (!this.disposed) this.binding.onFrame?.(deltaSeconds);
+    });
+    __publicField(this, "sampleResponse", (deltaSeconds) => {
+      if (this.disposed || !this.renderingEnabled) return;
+      try {
+        this.afterSample?.(deltaSeconds);
+      } catch (error) {
+        const failure = asError(error);
+        queueMicrotask(() => {
+          if (this.onError) this.onError(failure);
+          else throw failure;
+        });
+      }
+    });
     __publicField(this, "finished", (event) => {
       const handle = this.actionHandles.get(event.action);
       if (!handle || this.disposed) return;
@@ -2587,8 +2902,14 @@ var ThreeNativePlaybackConnector = class {
     this.binding = { ...binding, mixer: binding.mixer ?? new AnimationMixer(binding.model) };
     this.onError = binding.onError;
     this.onRelease = binding.onRelease;
+    this.afterSample = binding.afterSample;
     this.binding.mixer.addEventListener("finished", this.finished);
-    this.rendering = bindPlaybackRendering(binding.model, this.binding.mixer, () => this.flushEvents());
+    this.rendering = bindPlaybackRendering(
+      binding.model,
+      this.binding.mixer,
+      this.afterFrame,
+      this.sampleResponse
+    );
   }
   /** Prepare bindings first; old actions are released before the new binding is exposed. */
   rebind(modelKey, profileKey, binding = this.binding) {
@@ -2599,7 +2920,12 @@ var ThreeNativePlaybackConnector = class {
       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 = bindPlaybackRendering(
+        binding.model,
+        this.binding.mixer,
+        this.afterFrame,
+        this.sampleResponse
+      );
       this.rendering.setEnabled(this.renderingEnabled);
     });
   }
@@ -2933,7 +3259,15 @@ 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 weightRatio = (outgoing, options) => outgoing.getEffectiveWeight() / (finite2(options.mixerWeight) && options.mixerWeight > 0 ? options.mixerWeight : 1);
+var weighted = (sample, neutral, ratio, quaternion) => {
+  if (ratio === 1) return sample;
+  if (quaternion) return new Quaternion().fromArray(neutral ?? [0, 0, 0, 1]).slerp(new Quaternion().fromArray(sample), ratio).toArray();
+  return sample.map((value, axis) => (neutral?.[axis] ?? 0) + (value - (neutral?.[axis] ?? 0)) * ratio);
+};
 var presetId = (value) => value?.trim().toLowerCase() || "cc4";
+var HAIR_RESPONSE = "__embody_hair_response";
+var HAIR_IMPULSE_CLIP = "__embody_hair_impulse";
 function supportsRustEmbodyPreset(value) {
   return requireInitializedEmbodyCore().has_preset(presetId(value));
 }
@@ -2957,10 +3291,12 @@ var Embody = class _Embody {
     __publicField(this, "profileMode");
     __publicField(this, "preset");
     __publicField(this, "sources", /* @__PURE__ */ new Map());
+    __publicField(this, "vrmAnimations", /* @__PURE__ */ new Map());
     __publicField(this, "playbacks", /* @__PURE__ */ new Map());
     __publicField(this, "current", /* @__PURE__ */ new Map());
     __publicField(this, "playDepth", 0);
     __publicField(this, "pendingEvents", []);
+    __publicField(this, "pendingReleases", []);
     __publicField(this, "bindingGeneration", 0);
     __publicField(this, "disposed", false);
     __publicField(this, "rendering", true);
@@ -2968,6 +3304,7 @@ var Embody = class _Embody {
     __publicField(this, "nextLiveTarget", 0);
     __publicField(this, "liveTargets", /* @__PURE__ */ new Map());
     __publicField(this, "hairObjects", /* @__PURE__ */ new Map());
+    __publicField(this, "hairHeadObservation");
     __publicField(this, "hairConfig", {});
     __publicField(this, "hairAppearance", {
       hairColor: copy(DEFAULT_HAIR_COLOR_APPEARANCE),
@@ -3017,6 +3354,7 @@ var Embody = class _Embody {
     this.assertAlive();
     const model = options.model;
     if (!model?.isObject3D) throw new Error("onReady requires a Three Object3D model.");
+    this.applier.clearMeshHighlights();
     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);
@@ -3056,7 +3394,10 @@ var Embody = class _Embody {
     }
     this.core.free();
     this.core = core;
-    if (replacingModel) this.sources.clear();
+    if (replacingModel) {
+      this.sources.clear();
+      this.vrmAnimations.clear();
+    }
     this.boundModel = model;
     this.inspection = inspection;
     this.referenceBindings = referenceBindings;
@@ -3077,10 +3418,17 @@ var Embody = class _Embody {
       this.connector = new ThreeNativePlaybackConnector(session, {
         model,
         inspection,
+        onFrame: (deltaSeconds) => {
+          if (this.disposed) return;
+          this.applier.applyMeshHighlightFrame(parse(this.core.advance_mesh_highlight(deltaSeconds)));
+        },
         onRelease: (id) => {
           const playback = this.playbacks.get(id);
-          if (playback?.terminal) this.forget(playback);
-        }
+          if (!playback?.terminal) return;
+          if (this.playDepth) this.pendingReleases.push(playback);
+          else this.forget(playback);
+        },
+        afterSample: (mixerDeltaSeconds) => this.sampleHairResponse(mixerDeltaSeconds, true)
       });
     } catch (error) {
       session.free();
@@ -3091,17 +3439,20 @@ var Embody = class _Embody {
     this.connector.setTimeScale(this.timeScale);
     this.connector.subscribe((event) => this.onPlaybackEvent(event));
     this.hairConfig = parse(this.core.get_hair_config_json());
+    this.bindHairHead(model, inspection);
     this.registerHairObjects(inspection.allMeshes.filter((mesh) => ["hair", "eyebrow"].includes(this.meshCategory(mesh))));
     if (preserveLiveState) this.commitLive();
   }
   bindModel(meshes) {
     const model = this.requireModel();
+    this.applier.clearMeshHighlights();
     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();
+    this.applier.clearMeshHighlights();
     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);
@@ -3116,6 +3467,7 @@ var Embody = class _Embody {
       this.profile = profile;
       return;
     }
+    this.applier.clearMeshHighlights();
     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);
@@ -3140,12 +3492,16 @@ var Embody = class _Embody {
     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);
-    }
+    if (!playback.connector.getAction(playback.id)) this.forget(playback);
     playback.notify({ ...event, actionId: event.handle, clipName: playback.source.name });
   }
+  flushPendingPlaybackEvents() {
+    while (!this.playDepth && this.pendingReleases.length) {
+      const playback = this.pendingReleases.shift();
+      if (this.playbacks.get(playback.id) === playback) this.forget(playback);
+    }
+    while (!this.playDepth && this.pendingEvents.length) this.onPlaybackEvent(this.pendingEvents.shift());
+  }
   compile(source, options) {
     const buildOptions = { ..."options" in source ? source.options : {}, ...options, intensityScale: intensity(options) };
     switch (source.kind) {
@@ -3215,7 +3571,10 @@ var Embody = class _Embody {
           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));
+            const sample = Array.from(oldTrack.createInterpolant().evaluate(outgoing.time));
+            const quaternion = track.ValueTypeName === "quaternion";
+            const ratio = weightRatio(outgoing, options);
+            previous = outgoing.blendMode === AdditiveAnimationBlendMode ? weighted(sample, void 0, ratio, quaternion) : weighted(sample, rest, ratio, quaternion);
             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]);
             }
@@ -3351,7 +3710,7 @@ var Embody = class _Embody {
   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) {
+  handle(source, options, autoPlay, owner = "caller") {
     options = { ..."options" in source ? source.options : {}, ...options };
     const listeners = /* @__PURE__ */ new Set();
     const generation = this.bindingGeneration;
@@ -3379,8 +3738,10 @@ var Embody = class _Embody {
       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 outgoing = previous ? connector.getAction(previous.id) : void 0;
+      const predecessorTime = outgoing ? outgoing.time : Number.NaN;
+      const predecessorWeightRatio = outgoing ? weightRatio(outgoing, options) : 1;
       const settings = this.nativeOptions(options, clip);
       if (previous && connector.getAction(previous.id)) settings.replace = previous.id;
       if (current) newPromise();
@@ -3392,12 +3753,30 @@ var Embody = class _Embody {
         id = connector.playNativeClip(clip, settings);
       } catch (error) {
         this.playDepth -= 1;
-        while (!this.playDepth && this.pendingEvents.length) this.onPlaybackEvent(this.pendingEvents.shift());
+        this.flushPendingPlaybackEvents();
+        throw error;
+      }
+      try {
+        if (source.kind === "curves") {
+          this.core.record_semantic_slot(
+            source.name,
+            json2(source.input),
+            intensity(options),
+            options.easing ?? "linear",
+            predecessorTime,
+            predecessorWeightRatio
+          );
+        } else this.core.release_semantic_slot(source.name);
+      } catch (error) {
+        connector.control(id, { type: "stop" });
+        this.playDepth -= 1;
+        this.flushPendingPlaybackEvents();
         throw error;
       }
       const playback = {
         id,
         source,
+        owner,
         options: { ...options, intensityScale: intensity(options) },
         connector,
         terminal: false,
@@ -3439,7 +3818,7 @@ var Embody = class _Embody {
         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);
+        if (seconds > 0) connector.fadeOut(id, seconds);
         else control({ type: "stop" });
         return result;
       };
@@ -3473,11 +3852,7 @@ var Embody = class _Embody {
         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);
+        this.flushPendingPlaybackEvents();
       }
       return result;
     };
@@ -3515,7 +3890,10 @@ var Embody = class _Embody {
   }
   forget(playback) {
     this.playbacks.delete(playback.id);
-    if (this.current.get(playback.source.name) === playback) this.current.delete(playback.source.name);
+    if (this.current.get(playback.source.name) === playback) {
+      this.current.delete(playback.source.name);
+      this.core.release_semantic_slot(playback.source.name);
+    }
   }
   updatePlayback(playback, patch) {
     this.validateEasing(patch);
@@ -3531,6 +3909,7 @@ var Embody = class _Embody {
     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 (playback.source.kind === "curves") this.core.restyle_semantic_slot(playback.source.name, intensity(options), options.easing ?? "linear");
       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 });
@@ -3556,6 +3935,38 @@ var Embody = class _Embody {
     playback.options = options;
     if (!connector.getAction(playback.id)) this.forget(playback);
   }
+  supportsVrmAnimation() {
+    return true;
+  }
+  convertMixamoFbxToVrmAnimations(bytes, options) {
+    this.requireModel();
+    return convertMixamoFbxToVrmAnimations(bytes, options);
+  }
+  getVrmAnimationInfo(bytes) {
+    this.requireModel();
+    const document2 = inspectVrmAnimation(bytes);
+    return { name: document2.name, durationSeconds: document2.durationSeconds, trackCount: document2.tracks.length };
+  }
+  /** Registers a source; Animation owns the later playback request. */
+  registerVrmAnimation(name, bytes, options) {
+    if (typeof name !== "string" || !name.trim()) throw new Error("VRM Animation requires a nonempty clip name.");
+    const model = this.requireModel();
+    const clip = createAnimationClipFromVrmAnimation(bytes, model, {
+      name,
+      metersPerUnit: options.metersPerUnit,
+      referencePose: this.references.get(model),
+      profile: this.profile
+    });
+    this.registerAnimationClips([clip]);
+    this.vrmAnimations.set(name, { model, clip });
+  }
+  /** Stale editor cleanup must not remove a later same-name native source. */
+  releaseVrmAnimation(name) {
+    const registered = this.vrmAnimations.get(name);
+    const source = this.sources.get(name);
+    if (registered && !this.disposed && registered.model === this.boundModel && source?.kind === "native" && source.clip === registered.clip) this.removeAnimationClip(name);
+    this.vrmAnimations.delete(name);
+  }
   registerAnimationClips(clips) {
     const model = this.requireModel();
     for (const clip of clips) {
@@ -3567,12 +3978,13 @@ var Embody = class _Embody {
   }
   loadAnimationClips(clips) {
     this.stopAllAnimations();
+    this.vrmAnimations.clear();
     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();
+    this.sampleHairResponse(0);
   }
   removeAnimationClip(name) {
     this.stopAnimation(name);
@@ -3587,12 +3999,12 @@ var Embody = class _Embody {
     if (!source) throw new Error(`Unknown animation clip: ${name}`);
     return this.handle(source, options, true);
   }
-  build(source, options, play) {
+  build(source, options, play, owner = "caller") {
     this.requireModel();
     this.validateEasing(options);
     this.compile(source, options);
     this.sources.set(source.name, source);
-    return this.handle(source, options, play);
+    return this.handle(source, options, play, owner);
   }
   buildClip(name, curves, options = {}) {
     if (options.semanticAnimation) throw new Error("Decode legacy named animation tracks to numeric AU curves before building a clip.");
@@ -3625,7 +4037,7 @@ var Embody = class _Embody {
     this.core.cleanup_snippet(name);
   }
   crossfadeTo(name, seconds, options = {}) {
-    const outgoing = [...this.current.values()].filter((playback) => !playback.source.name.startsWith("__embody_"));
+    const outgoing = [...this.current.values()].filter((playback) => playback.owner === "caller");
     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;
@@ -3636,28 +4048,35 @@ var Embody = class _Embody {
     if (playback.connector.getAction(playback.id)) playback.connector.control(playback.id, { type: "stop" });
     this.forget(playback);
   }
+  /** Stop every caller playback. Live setter targets and hair actions keep running. */
   stopAllAnimations() {
     for (const playback of [...this.playbacks.values()]) {
-      if (playback.source.kind === "compiled") continue;
+      if (playback.owner !== "caller") continue;
       if (playback.connector.getAction(playback.id)) playback.connector.control(playback.id, { type: "stop" });
       this.forget(playback);
     }
   }
   pauseAnimation(name) {
+    if (name === HAIR_RESPONSE) this.core.set_hair_response_paused(true);
     const p = this.current.get(name);
     if (p) p.connector.control(p.id, { type: "pause" });
   }
   resumeAnimation(name) {
+    if (name === HAIR_RESPONSE) {
+      this.core.set_hair_response_paused(false);
+      this.sampleHairResponse(0);
+    }
     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" });
   }
+  // Hair actions follow the hair configuration and Embody.stop()/start(), not caller pause commands.
   pauseAllAnimations() {
-    for (const p of this.playbacks.values()) if (!p.terminal) p.connector.control(p.id, { type: "pause" });
+    for (const p of this.playbacks.values()) if (!p.terminal && p.owner !== "hair") p.connector.control(p.id, { type: "pause" });
   }
   resumeAllAnimations() {
-    for (const name of [...this.current.keys()]) this.resumeAnimation(name);
+    for (const [name, p] of [...this.current]) if (p.owner !== "hair") this.resumeAnimation(name);
   }
   updateClipParams(name, options) {
     const p = this.current.get(name);
@@ -3758,7 +4177,8 @@ var Embody = class _Embody {
       const handle = this.handle(
         { name: releaseClip.name, kind: "compiled", clip: releaseClip },
         { loopMode: "once", finalPose: "release", mixerWeight: action.getEffectiveWeight() },
-        true
+        true,
+        "live"
       );
       connector.fadeOut(handle.actionId, duration);
       const record = { track: released, handle, releasing: true };
@@ -3776,11 +4196,17 @@ var Embody = class _Embody {
       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));
+        const outgoingTrack = outgoing.getClip().tracks[0];
+        const start = weighted(
+          Array.from(outgoingTrack.createInterpolant().evaluate(outgoing.time)),
+          this.restValues(outgoingTrack),
+          outgoing.getEffectiveWeight(),
+          outgoingTrack.ValueTypeName === "quaternion"
+        );
         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);
+      const handle = this.handle({ name, kind: "compiled", clip: targetClip }, { loopMode: "once", finalPose: "hold" }, true, "live");
       this.liveTargets.set(key, { track, handle, releasing: false });
       handles.push(handle);
     }
@@ -3825,6 +4251,49 @@ var Embody = class _Embody {
   getContinuum(negative, positive) {
     return this.core.get_continuum(negative, positive);
   }
+  /**
+   * One clip slot's own semantic AU contribution right now (`{auId: value}`),
+   * evaluated in Rust at the native action's time and effective weight.
+   * Null when the slot is not playing or was not an AU-curve clip.
+   */
+  readAUContribution(name) {
+    const playback = this.current.get(name);
+    const action = playback?.connector.getAction(playback.id);
+    return playback && action ? parse(this.core.read_semantic_slot(name, action.time, action.getEffectiveWeight())) : null;
+  }
+  /**
+   * On-demand AU state: live control values, active AU-curve clip
+   * contributions and their sum. Baked/native and typed clips cannot be
+   * inverted to AU values and are listed as `unreadable`, never estimated.
+   */
+  readAUState() {
+    const active = [];
+    const unreadable = [];
+    for (const [name, playback] of this.current) {
+      const action = playback.connector.getAction(playback.id);
+      if (!action) continue;
+      if (playback.source.kind === "curves") active.push({ name, time: action.time, weight: action.getEffectiveWeight() });
+      else if (playback.source.kind !== "compiled") unreadable.push(name);
+    }
+    return { ...parse(this.core.read_semantic_state(json2(active))), unreadable };
+  }
+  /**
+   * Distance from a slot's current contribution to AU destinations, measured
+   * along profile continuum pairs, and whether it reverses unfinished travel.
+   * A slot that is not playing is at zero. Callers choose any timing policy.
+   */
+  measureAUGoal(name, destinations) {
+    const playback = this.current.get(name);
+    const action = playback?.connector.getAction(playback.id);
+    const unfinished = !!playback && !!action && !playback.terminal && action.time < action.getClip().duration;
+    return parse(this.core.measure_au_goal(
+      name,
+      action?.time ?? Number.NaN,
+      action?.getEffectiveWeight() ?? Number.NaN,
+      json2(destinations),
+      unfinished
+    ));
+  }
   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));
   }
@@ -3924,7 +4393,9 @@ var Embody = class _Embody {
     this.meshProfile(name).visible = visible;
   }
   highlightMesh(name, color, value) {
-    this.applier.highlightMesh(this.requireModel(), name, color, value);
+    this.requireModel();
+    this.core.request_mesh_highlight(name ?? void 0, color, value);
+    this.applier.applyMeshHighlightFrame(parse(this.core.evaluate_mesh_highlight_frame()));
   }
   getMeshMaterialConfig(name) {
     return this.applier.getMeshMaterialConfig(this.requireModel(), name);
@@ -3942,7 +4413,9 @@ var Embody = class _Embody {
       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();
+    for (const [name, playback] of [...this.current]) if (playback.owner === "hair") this.stopAnimation(name);
+    this.core.reset_hair_response();
+    this.sampleHairResponse(0);
     return [...this.hairObjects.values()].map((mesh) => ({ name: mesh.name, isMesh: true, isEyebrow: this.meshCategory(mesh) === "eyebrow" }));
   }
   getRegisteredHairObjects() {
@@ -3982,12 +4455,69 @@ var Embody = class _Embody {
   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" });
+  hairClipOptions(options) {
+    return { ...options, meshNames: [...this.hairObjects.keys()], source: "hair", blendMode: "additive" };
+  }
+  bindHairHead(model, inspection) {
+    this.hairHeadObservation = void 0;
+    const binding = parse(this.core.get_hair_head_binding_json());
+    const head = binding && inspection.boneBindings.get(binding.boneId);
+    if (!binding || !head) return;
+    const chain = [];
+    for (let node2 = head; node2 && node2 !== model; node2 = node2.parent) chain.push(node2);
+    if (!chain.length || chain[chain.length - 1].parent !== model) return;
+    const reference = new Quaternion();
+    const node = new Quaternion();
+    for (let index = chain.length - 1; index >= 0; index -= 1) {
+      const rotation = this.referenceBindings.get(chain[index])?.transform.rotation;
+      reference.multiply(rotation ? node.set(rotation.x, rotation.y, rotation.z, rotation.w) : chain[index].quaternion);
+    }
+    this.hairHeadObservation = {
+      boneName: binding.boneName,
+      chain,
+      reference: binding.reference,
+      modelToReference: new Quaternion().fromArray(binding.reference).multiply(reference.normalize().invert()),
+      rotation: new Quaternion()
+    };
+  }
+  sampleHairResponse(deltaSeconds, observeHead = false) {
+    if (this.disposed || !this.connector || !this.inspection) return;
+    if (!this.hairConfig.enabled || !this.hairObjects.size) {
+      this.stopAnimation(HAIR_RESPONSE);
+      return;
+    }
+    const previous = this.current.get(HAIR_RESPONSE);
+    const action = previous?.connector.getAction(previous.id);
+    const head = this.hairHeadObservation;
+    let pose = null;
+    if (observeHead && head) {
+      const rotation = head.rotation.copy(head.modelToReference);
+      for (let index = head.chain.length - 1; index >= 0; index -= 1) rotation.multiply(head.chain[index].quaternion);
+      pose = { boneName: head.boneName, reference: head.reference, current: rotation.normalize().toArray() };
+    }
+    const ir = parse(this.core.build_hair_response_clip(
+      HAIR_RESPONSE,
+      JSON.stringify(pose),
+      action?.paused ? 0 : deltaSeconds,
+      json2({ meshNames: [...this.hairObjects.keys()] })
+    ));
+    if (!ir.tracks.length) {
+      this.stopAnimation(HAIR_RESPONSE);
+      return;
+    }
+    const clip = createAnimationClipFromClipIR(ir, this.inspection);
+    clip.blendMode = AdditiveAnimationBlendMode;
+    const oldTracks = action?.getClip().tracks;
+    const sameBindings = oldTracks && oldTracks.length === clip.tracks.length && clip.tracks.every((track, index) => {
+      const old = oldTracks[index];
+      return old.name === track.name && old.ValueTypeName === track.ValueTypeName && old.getValueSize() === track.getValueSize();
+    });
+    if (previous && action && sameBindings) {
+      this.connector.replaceClip(previous.id, clip);
+      previous.source = { name: HAIR_RESPONSE, kind: "native", clip };
+    } else {
+      const handle = this.handle({ name: HAIR_RESPONSE, kind: "native", clip }, { loopMode: "repeat", blendMode: "additive" }, true, "hair");
+      if (action?.paused || this.core.is_hair_response_paused()) handle.pause();
     }
   }
   setHairPhysicsEnabled(value) {
@@ -3997,8 +4527,12 @@ var Embody = class _Embody {
     return !!this.hairConfig.enabled;
   }
   setHairPhysicsConfig(value) {
+    this.assertAlive();
     this.hairConfig = parse(this.core.set_hair_config_json(json2(value)));
-    this.restartHair();
+    if (!this.hairConfig.enabled) {
+      for (const [name, playback] of [...this.current]) if (playback.owner === "hair") this.stopAnimation(name);
+    }
+    this.sampleHairResponse(0);
   }
   getHairPhysicsConfig() {
     return copy(this.hairConfig);
@@ -4014,41 +4548,12 @@ var Embody = class _Embody {
     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" });
+    const options = this.hairClipOptions({ loopMode: "once", finalPose: "release" });
+    return this.build({ name: HAIR_IMPULSE_CLIP, kind: "curves", input: curves, options: copy(options) }, options, true, "hair");
   }
   start() {
     this.assertAlive();
@@ -4069,11 +4574,14 @@ var Embody = class _Embody {
   dispose() {
     if (this.disposed) return;
     this.connector?.dispose();
+    this.applier.clearMeshHighlights();
     this.core.free();
     this.playbacks.clear();
     this.current.clear();
     this.sources.clear();
+    this.vrmAnimations.clear();
     this.hairObjects.clear();
+    this.hairHeadObservation = void 0;
     this.meshes.length = 0;
     this.meshByName.clear();
     this.bones = {};
@@ -4115,7 +4623,7 @@ function createSceneInkBackgroundCss(palette = DEFAULT_PALETTE) {
 createSceneInkBackgroundCss();
 
 // three/sceneInkBackground.ts
-var toCssColor = (tone) => `#${new THREE10.Color(tone).getHexString()}`;
+var toCssColor = (tone) => `#${new THREE11.Color(tone).getHexString()}`;
 function createSceneInkBackground(onBackgroundChange) {
   let currentBackground = "";
   let disposed = false;
@@ -4255,7 +4763,7 @@ function sampleTexture(texture) {
       if (alpha < 0.18) {
         continue;
       }
-      const color = new THREE10.Color(
+      const color = new THREE11.Color(
         data[index] / 255,
         data[index + 1] / 255,
         data[index + 2] / 255
@@ -4300,7 +4808,7 @@ function buildPalette(samples) {
     const hsl = { h: 0, s: 0, l: 0 };
     sample.color.getHSL(hsl);
     const bucketId = Math.floor(hsl.h * 18);
-    const bucket = buckets.get(bucketId) ?? { color: new THREE10.Color(0, 0, 0), score: 0 };
+    const bucket = buckets.get(bucketId) ?? { color: new THREE11.Color(0, 0, 0), score: 0 };
     bucket.color.r += sample.color.r * sample.score;
     bucket.color.g += sample.color.g * sample.score;
     bucket.color.b += sample.color.b * sample.score;
@@ -4333,18 +4841,18 @@ function buildPalette(samples) {
 function massageBackgroundTone(color) {
   const hsl = { h: 0, s: 0, l: 0 };
   color.getHSL(hsl);
-  const saturation = THREE10.MathUtils.clamp(Math.max(hsl.s * 1.35, 0.46), 0.46, 0.82);
-  const lightness = THREE10.MathUtils.clamp(hsl.l + 0.08, 0.42, 0.66);
-  return new THREE10.Color().setHSL(hsl.h, saturation, lightness);
+  const saturation = THREE11.MathUtils.clamp(Math.max(hsl.s * 1.35, 0.46), 0.46, 0.82);
+  const lightness = THREE11.MathUtils.clamp(hsl.l + 0.08, 0.42, 0.66);
+  return new THREE11.Color().setHSL(hsl.h, saturation, lightness);
 }
 function createCompanionTone(source, index) {
   const hsl = { h: 0, s: 0, l: 0 };
   source.getHSL(hsl);
   const hueOffset = index === 1 ? 0.075 : -0.065;
-  return new THREE10.Color().setHSL(
-    THREE10.MathUtils.euclideanModulo(hsl.h + hueOffset, 1),
-    THREE10.MathUtils.clamp(hsl.s * (index === 1 ? 0.92 : 0.82), 0.38, 0.76),
-    THREE10.MathUtils.clamp(hsl.l + (index === 1 ? 0.04 : -0.03), 0.38, 0.68)
+  return new THREE11.Color().setHSL(
+    THREE11.MathUtils.euclideanModulo(hsl.h + hueOffset, 1),
+    THREE11.MathUtils.clamp(hsl.s * (index === 1 ? 0.92 : 0.82), 0.38, 0.76),
+    THREE11.MathUtils.clamp(hsl.l + (index === 1 ? 0.04 : -0.03), 0.38, 0.68)
   );
 }
 function colorDistance(a, b) {
@@ -4383,6 +4891,11 @@ var prepare = (model, castShadows = true) => {
   });
   return meshes;
 };
+var prepareCharacterModelResult = (model, animations, gltf, options) => ({ model, meshes: prepare(model, options.castShadows), animations, gltf });
+var bufferFormat = (data) => {
+  const header = new TextDecoder().decode(new Uint8Array(data, 0, Math.min(data.byteLength, 4096)));
+  return header.startsWith("Kaydara FBX Binary  \0") || /^\s*FBXHeaderExtension\s*:/m.test(header) ? "fbx" : "gltf";
+};
 var progress = (listener) => {
   let last = -1;
   return (event) => {
@@ -4415,8 +4928,8 @@ function disposeCharacterModel(scene, model) {
   });
 }
 function loadCharacterModel(url, options = {}) {
-  const done = (model, animations, gltf) => ({ model, meshes: prepare(model, options.castShadows), animations, gltf });
-  if (/\.fbx(?:\?|$)/i.test(url)) {
+  const done = (model, animations, gltf) => prepareCharacterModelResult(model, animations, gltf, options);
+  if ((options.format ?? (/\.fbx(?:[?#]|$)/i.test(url) ? "fbx" : "gltf")) === "fbx") {
     fbxLoader ?? (fbxLoader = new FBXLoader());
     return new Promise((resolve, reject) => fbxLoader.load(url, (model) => resolve(done(model, model.animations ?? [], null)), progress(options.onProgress), reject));
   }
@@ -4424,8 +4937,15 @@ function loadCharacterModel(url, options = {}) {
   return new Promise((resolve, reject) => loader.load(url, (gltf) => resolve(done(gltf.scene, gltf.animations ?? [], gltf)), progress(options.onProgress), reject));
 }
 function parseCharacterModel(data, resourcePath = "", options = {}) {
+  if ((options.format ?? bufferFormat(data)) === "fbx") {
+    return Promise.resolve().then(() => {
+      fbxLoader ?? (fbxLoader = new FBXLoader());
+      const model = fbxLoader.parse(data, resourcePath);
+      return prepareCharacterModelResult(model, model.animations ?? [], null, options);
+    });
+  }
   const loader = getGltfLoader(options.dracoDecoderPath);
-  return new Promise((resolve, reject) => loader.parse(data, resourcePath, (gltf) => resolve({ model: gltf.scene, meshes: prepare(gltf.scene, options.castShadows), animations: gltf.animations ?? [], gltf }), reject));
+  return new Promise((resolve, reject) => loader.parse(data, resourcePath, (gltf) => resolve(prepareCharacterModelResult(gltf.scene, gltf.animations ?? [], gltf, options)), reject));
 }
 
 // three/modelMorphLayout.ts
@@ -4575,6 +5095,63 @@ function assertRenderableCharacterMorphAttributes(model) {
     }
   });
 }
+var owners2 = /* @__PURE__ */ new WeakMap();
+var snapshot = (scene) => ({ value: scene.background, intensity: scene.backgroundIntensity, rotation: scene.backgroundRotation.clone() });
+var apply = (scene, value) => {
+  scene.background = value.value;
+  scene.backgroundIntensity = value.intensity;
+  scene.backgroundRotation.copy(value.rotation);
+};
+var ownerFor = (scene) => {
+  let owner = owners2.get(scene);
+  if (!owner) {
+    owner = { base: snapshot(scene), override: null, disposed: false };
+    owners2.set(scene, owner);
+  }
+  return owner;
+};
+function setSceneBaseBackground(scene, value) {
+  const owner = ownerFor(scene);
+  owner.base = { value, intensity: 1, rotation: new Euler() };
+  if (!owner.override?.value) apply(scene, owner.base);
+}
+function acquireSceneBackground(scene, onSceneDispose) {
+  const owner = ownerFor(scene);
+  if (owner.disposed) throw new Error("The scenery scene has been disposed.");
+  if (owner.override) throw new Error("The scene already has a scenery renderer.");
+  owner.base = snapshot(scene);
+  const override = { value: null, onSceneDispose };
+  owner.override = override;
+  let disposed = false;
+  return {
+    set(value, intensity2, rotationDegrees) {
+      if (disposed || owner.disposed) throw new Error("The scenery background has been disposed.");
+      override.value = { value, intensity: intensity2, rotation: new Euler(0, rotationDegrees * Math.PI / 180, 0) };
+      apply(scene, override.value);
+    },
+    clear() {
+      if (disposed) return;
+      override.value = null;
+      apply(scene, owner.base);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (owner.override === override) {
+        owner.override = null;
+        apply(scene, owner.base);
+      }
+    }
+  };
+}
+function disposeSceneBackground(scene) {
+  const owner = ownerFor(scene);
+  if (owner.disposed) return;
+  owner.disposed = true;
+  owner.override?.onSceneDispose();
+}
+
+// three/scene.ts
 var DEFAULT_CHARACTER_LIGHTING_PRESETS = {
   cleanStudio: { id: "cleanStudio", label: "Soft Studio", settings: { envMapEnabled: true, environmentIntensity: 0.24, environmentBlur: 0.04, exposure: 1.08, ambientIntensity: 0.32, keyIntensity: 0.52, fillIntensity: 0.18, rimIntensity: 0.08, shadowOpacity: 0.22 } },
   softFill: { id: "softFill", label: "Soft Fill", settings: { envMapEnabled: true, environmentIntensity: 0.3, environmentBlur: 0.04, exposure: 1.1, ambientIntensity: 0.38, keyIntensity: 0.44, fillIntensity: 0.24, rimIntensity: 0.1, shadowOpacity: 0.18 } },
@@ -4819,7 +5396,8 @@ function constructDefaultCharacterScene(container, options, renderer, disposeRen
     Object.assign(renderer.domElement.style, { display: "block", width: "100%", height: "100%" });
     const scene = new Scene();
     const background = options.background === void 0 ? sceneType.background : options.background;
-    scene.background = background == null ? null : new Color(background);
+    setSceneBaseBackground(scene, background == null ? null : new Color(background));
+    lifetime.add(() => disposeSceneBackground(scene));
     const camera = new PerspectiveCamera(options.cameraFov ?? 45, width / height, 0.1, 1e3);
     const preset = DEFAULT_CHARACTER_LIGHTING_PRESETS[options.lightingPreset ?? sceneType.lightingPreset]?.settings ?? DEFAULT_CHARACTER_LIGHTING_SETTINGS;
     const lighting = createLighting(scene, { ...preset, ...options.lighting });
@@ -4840,7 +5418,7 @@ function constructDefaultCharacterScene(container, options, renderer, disposeRen
       const type = CHARACTER_SCENE_TYPES[value.type ?? DEFAULT_CHARACTER_SCENE_TYPE_ID] ?? CHARACTER_SCENE_TYPES[DEFAULT_CHARACTER_SCENE_TYPE_ID];
       currentSceneType = type.id;
       const background2 = value.background === void 0 ? type.background : value.background;
-      scene.background = background2 == null ? null : new Color(background2);
+      setSceneBaseBackground(scene, background2 == null ? null : new Color(background2));
       camera.fov = value.cameraFov ?? 45;
       camera.updateProjectionMatrix();
       const preset2 = DEFAULT_CHARACTER_LIGHTING_PRESETS[value.lightingPreset ?? type.lightingPreset] ?? DEFAULT_CHARACTER_LIGHTING_PRESETS[DEFAULT_CHARACTER_LIGHTING_PRESET_ID];
@@ -4975,17 +5553,17 @@ function prepareCameraCoordinates(scene, camera, backend) {
     }
   });
   const previous = Array.from(cameras, (current) => [current, current.coordinateSystem]);
-  const apply = (current, coordinates2) => {
+  const apply2 = (current, coordinates2) => {
     current.coordinateSystem = coordinates2;
     current.updateProjectionMatrix();
   };
   const coordinates = backend === "webgpu" ? WebGPUCoordinateSystem : WebGLCoordinateSystem;
-  cameras.forEach((current) => apply(current, coordinates));
+  cameras.forEach((current) => apply2(current, coordinates));
   shadows.forEach((shadow) => {
     shadow.needsUpdate = true;
   });
   return () => {
-    previous.forEach(([current, original]) => apply(current, original));
+    previous.forEach(([current, original]) => apply2(current, original));
     shadows.forEach((shadow) => {
       shadow.needsUpdate = true;
     });
@@ -4999,7 +5577,8 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
     let currentSceneType = sceneType.id;
     const scene = new Scene();
     const background = options.background === void 0 ? sceneType.background : options.background;
-    scene.background = background == null ? null : new Color(background);
+    setSceneBaseBackground(scene, background == null ? null : new Color(background));
+    lifetime.add(() => disposeSceneBackground(scene));
     const camera = new PerspectiveCamera(options.cameraFov ?? 45, 1, 0.1, 1e3);
     const preset = DEFAULT_CHARACTER_LIGHTING_PRESETS[options.lightingPreset ?? sceneType.lightingPreset]?.settings ?? DEFAULT_CHARACTER_LIGHTING_SETTINGS;
     const lighting = createMutableCharacterLighting(scene, { ...preset, ...options.lighting });
@@ -5039,10 +5618,10 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
       return { ...common, backend: null, renderer: null };
     };
     const notify = () => {
-      const snapshot2 = getSnapshot();
+      const snapshot3 = getSnapshot();
       for (const listener of listeners) {
         try {
-          listener(snapshot2);
+          listener(snapshot3);
         } catch (failure) {
           console.error("Character rendering subscriber failed.", failure);
         }
@@ -5169,9 +5748,9 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
           rollback(() => oldRenderer?.dispose());
           status = "ready";
           error = null;
-          const snapshot2 = getSnapshot();
+          const snapshot3 = getSnapshot();
           notify();
-          return snapshot2;
+          return snapshot3;
         } catch (failure) {
           if (suspended) {
             try {
@@ -5250,6 +5829,17 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
           }
         } };
       },
+      acquireRendererAsync: async () => {
+        for (; ; ) {
+          if (disposed) throw renderingAborted();
+          const settling = pending;
+          if (settling) {
+            await settling.catch(() => void 0);
+            continue;
+          }
+          return rendering.acquireRenderer();
+        }
+      },
       releaseSceneResources: (release) => {
         if (disposal) return disposal.then(release, release);
         const previous = pending;
@@ -5333,7 +5923,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
       const type = CHARACTER_SCENE_TYPES[value.type ?? DEFAULT_CHARACTER_SCENE_TYPE_ID] ?? CHARACTER_SCENE_TYPES[DEFAULT_CHARACTER_SCENE_TYPE_ID];
       currentSceneType = type.id;
       const background2 = value.background === void 0 ? type.background : value.background;
-      scene.background = background2 == null ? null : new Color(background2);
+      setSceneBaseBackground(scene, background2 == null ? null : new Color(background2));
       camera.fov = value.cameraFov ?? 45;
       camera.updateProjectionMatrix();
       const preset2 = DEFAULT_CHARACTER_LIGHTING_PRESETS[value.lightingPreset ?? type.lightingPreset] ?? DEFAULT_CHARACTER_LIGHTING_PRESETS[DEFAULT_CHARACTER_LIGHTING_PRESET_ID];
@@ -5376,9 +5966,9 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
 async function createDefaultCharacterSceneAsync(container, options = {}) {
   const runtime = createDefaultCharacterSceneRuntime(container, options);
   try {
-    const snapshot2 = await runtime.ready;
-    if (!snapshot2.renderer) throw new Error("Character scene renderer was not initialized.");
-    const handle = snapshot2.backend === "webgl" ? { ...runtime, renderer: snapshot2.renderer, backend: "webgl" } : { ...runtime, renderer: snapshot2.renderer, backend: "webgpu" };
+    const snapshot3 = await runtime.ready;
+    if (!snapshot3.renderer) throw new Error("Character scene renderer was not initialized.");
+    const handle = snapshot3.backend === "webgl" ? { ...runtime, renderer: snapshot3.renderer, backend: "webgl" } : { ...runtime, renderer: snapshot3.renderer, backend: "webgpu" };
     Object.defineProperties(handle, {
       renderer: { get: () => runtime.renderer },
       backend: { get: () => runtime.backend },
@@ -5465,7 +6055,14 @@ async function createCharacterHost(options) {
       if (!rendering.getSnapshot().renderer) throw error;
     }
     check(signal);
-    return rendering.acquireRenderer();
+    const lease = await rendering.acquireRendererAsync();
+    try {
+      check(signal);
+      return lease;
+    } catch (error) {
+      lease.release();
+      throw error;
+    }
   };
   const makeEngine = (value, character) => {
     let profile = character.profile ?? options.embody?.profile;
@@ -5714,6 +6311,302 @@ async function createCharacterHost(options) {
     throw error;
   }
 }
+var finite4 = (value) => typeof value === "number" && Number.isFinite(value);
+var identity2 = (value) => typeof value === "string" && value.trim().length > 0;
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+function copyLayout(layout) {
+  if (layout === null) return { skybox: null, instances: [] };
+  if (!layout || !Array.isArray(layout.instances)) throw new Error("Scenery requires an instances array.");
+  const ids = /* @__PURE__ */ new Set();
+  const instances = layout.instances.map((instance) => {
+    if (!instance || !identity2(instance.instanceId) || !identity2(instance.assetId)) throw new Error("Each scenery placement requires an instanceId and assetId.");
+    if (ids.has(instance.instanceId)) throw new Error(`Duplicate scenery instanceId: ${instance.instanceId}`);
+    ids.add(instance.instanceId);
+    const position = instance.position;
+    if (!position || !finite4(position.x) || !finite4(position.y) || !finite4(position.z)) throw new Error(`Scenery placement ${instance.instanceId} requires finite X/Y/Z coordinates.`);
+    return { instanceId: instance.instanceId, assetId: instance.assetId, position: { x: position.x, y: position.y, z: position.z } };
+  });
+  const skybox = layout.skybox;
+  if (skybox !== null) {
+    if (!skybox || !["skybox", "backdrop", "color"].includes(skybox.kind)) throw new Error("Scenery background kind must be skybox, backdrop or color.");
+    if (skybox.assetId !== null && !identity2(skybox.assetId)) throw new Error("The scenery background assetId must be a nonempty string or null.");
+    if (skybox.kind === "color" && skybox.assetId !== null) throw new Error("A solid scenery color cannot use an image asset.");
+    if (typeof skybox.color !== "string" || !/^#[\da-f]{6}$/i.test(skybox.color)) throw new Error("Scenery background color must use six-digit #rrggbb.");
+    if (!finite4(skybox.intensity) || skybox.intensity < 0 || !finite4(skybox.rotation)) throw new Error("Scenery background intensity must be nonnegative and rotation must be finite degrees.");
+  }
+  return { instances, skybox: skybox === null ? null : { kind: skybox.kind, assetId: skybox.assetId, color: skybox.color, intensity: skybox.intensity, rotation: skybox.rotation } };
+}
+function disposeRoots(roots) {
+  const geometries = /* @__PURE__ */ new Set(), materials2 = /* @__PURE__ */ new Set(), textures = /* @__PURE__ */ new Set();
+  const skeletons = /* @__PURE__ */ new Set();
+  for (const root of roots) root.traverse((object) => {
+    if (object.geometry) geometries.add(object.geometry);
+    if (object.skeleton) skeletons.add(object.skeleton);
+    for (const material of object.material ? Array.isArray(object.material) ? object.material : [object.material] : []) {
+      materials2.add(material);
+      for (const value of Object.values(material)) if (value?.isTexture) textures.add(value);
+    }
+  });
+  const images = /* @__PURE__ */ new Set();
+  for (const texture of textures) {
+    for (const image of Array.isArray(texture.image) ? texture.image : [texture.image]) if (image) images.add(image);
+    texture.dispose();
+  }
+  for (const geometry of geometries) geometry.dispose();
+  for (const material of materials2) material.dispose();
+  for (const skeleton of skeletons) skeleton.dispose();
+  for (const image of images) image.close?.();
+}
+function display(value, skybox) {
+  const texture = "isTexture" in value ? value : null;
+  if (texture) {
+    texture.colorSpace = SRGBColorSpace;
+    if (skybox.kind === "skybox") texture.mapping = EquirectangularReflectionMapping;
+  }
+  let disposed = false;
+  return {
+    value,
+    texture,
+    intensity: skybox.intensity,
+    rotation: skybox.kind === "skybox" ? skybox.rotation : 0,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      texture?.dispose();
+    }
+  };
+}
+function generatedSky(skybox) {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1024;
+  canvas.height = 512;
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("The browser could not create the scenery skybox.");
+  const gradient = context.createLinearGradient(0, 0, 0, 512);
+  gradient.addColorStop(0, "#10172c");
+  gradient.addColorStop(0.48, skybox.color);
+  gradient.addColorStop(0.52, "#b6aaa0");
+  gradient.addColorStop(1, "#151c25");
+  context.fillStyle = gradient;
+  context.fillRect(0, 0, 1024, 512);
+  return display(new CanvasTexture(canvas), skybox);
+}
+async function imageDisplay(asset, skybox) {
+  if (!["image/png", "image/jpeg", "image/webp"].includes(asset.contentType)) throw new Error("Scenery backgrounds require a PNG, JPEG or WebP image.");
+  const url = URL.createObjectURL(new Blob([asset.bytes], { type: asset.contentType }));
+  let pending;
+  try {
+    const texture = await new Promise((resolve, reject) => {
+      pending = new TextureLoader().load(url, resolve, void 0, reject);
+    });
+    return display(texture, skybox);
+  } catch (error) {
+    pending?.dispose();
+    throw new Error(`Scenery background image could not decode: ${messageOf(error)}`);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+async function parseModel(asset) {
+  if (asset.contentType !== "model/gltf-binary" || asset.bytes.byteLength < 20) throw new Error("Scenery models require a self-contained GLB 2.0 file.");
+  const header = new DataView(asset.bytes);
+  if (header.getUint32(0, true) !== 1179937895 || header.getUint32(4, true) !== 2 || header.getUint32(8, true) !== asset.bytes.byteLength) throw new Error("Scenery models require a valid GLB 2.0 container.");
+  let offset = 12, document2;
+  while (offset < asset.bytes.byteLength) {
+    if (offset + 8 > asset.bytes.byteLength) throw new Error("The scenery GLB has a truncated chunk header.");
+    const size = header.getUint32(offset, true), kind = header.getUint32(offset + 4, true);
+    if (size % 4 || size > asset.bytes.byteLength - offset - 8) throw new Error("The scenery GLB has an invalid chunk length.");
+    if (offset === 12 && kind !== 1313821514) throw new Error("The scenery GLB must begin with its JSON chunk.");
+    if (kind === 1313821514) {
+      if (document2) throw new Error("The scenery GLB contains duplicate JSON chunks.");
+      try {
+        document2 = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(asset.bytes, offset + 8, size)));
+      } catch (error) {
+        throw new Error(`The scenery GLB JSON is invalid: ${messageOf(error)}`);
+      }
+      if (!document2 || typeof document2 !== "object" || Array.isArray(document2)) throw new Error("The scenery GLB JSON must be an object.");
+    }
+    offset += 8 + size;
+  }
+  for (const resources of [document2?.buffers, document2?.images]) {
+    if (resources !== void 0 && !Array.isArray(resources)) throw new Error("The scenery GLB buffers and images must be arrays.");
+    for (const resource of resources ?? []) {
+      if (resource?.uri !== void 0 && (typeof resource.uri !== "string" || !resource.uri.startsWith("data:"))) {
+        throw new Error("Scenery GLB files must embed their geometry and textures; external URLs are not allowed.");
+      }
+    }
+  }
+  const manager = new LoadingManager();
+  manager.setURLModifier((url) => {
+    if (url.startsWith("data:") || url.startsWith("blob:")) return url;
+    throw new Error("Scenery GLB files must embed their geometry and textures; external URLs are not allowed.");
+  });
+  const gltf = await new GLTFLoader(manager).parseAsync(asset.bytes, "");
+  if (!gltf.scene?.isObject3D) throw new Error("The scenery GLB has no scene to display.");
+  return [gltf.scene, ...gltf.scenes.filter((root) => root !== gltf.scene)];
+}
+function createSceneSceneryRenderer(options) {
+  const { scene, rendering, loadAsset } = options;
+  if (!scene?.isScene || typeof loadAsset !== "function") throw new Error("Scenery requires a Three scene and an asset loader.");
+  let disposed = false, disposal = null;
+  let backgroundKey = null, backgroundGeneration = 0;
+  let backgroundLoad = null, currentDisplay = null;
+  const models = /* @__PURE__ */ new Map(), tasks = /* @__PURE__ */ new Set();
+  const report = (message) => {
+    try {
+      options.onError?.(message);
+    } catch (error) {
+      console.error("Scenery error subscriber failed.", error);
+    }
+  };
+  const track = (task) => {
+    tasks.add(task);
+    void task.then(() => tasks.delete(task), (error) => {
+      tasks.delete(task);
+      report(messageOf(error));
+    });
+    return task;
+  };
+  const release = (callback) => {
+    try {
+      return rendering ? rendering.releaseSceneResources(callback) : (callback(), Promise.resolve());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  };
+  const background = acquireSceneBackground(scene, () => {
+    void dispose().catch((error) => report(messageOf(error)));
+  });
+  const retire = (model) => {
+    if (model.retired) return Promise.resolve();
+    model.retired = true;
+    model.controller.abort();
+    return release(() => {
+      model.wrapper.removeFromParent();
+      model.attached = false;
+      disposeRoots(model.roots);
+      model.roots = [];
+    });
+  };
+  const mount = (instance) => {
+    const wrapper = new Group();
+    wrapper.name = `Scenery ${instance.instanceId}`;
+    wrapper.position.set(instance.position.x, instance.position.y, instance.position.z);
+    const model = { assetId: instance.assetId, wrapper, controller: new AbortController(), roots: [], attached: false, retired: false };
+    models.set(instance.instanceId, model);
+    track((async () => {
+      let roots = [];
+      try {
+        const asset = await loadAsset(model.assetId, model.controller.signal);
+        if (model.controller.signal.aborted) return;
+        roots = await parseModel(asset);
+        if (model.controller.signal.aborted || disposed) {
+          disposeRoots(roots);
+          roots = [];
+          return;
+        }
+        await release(() => {
+          if (model.controller.signal.aborted || disposed) {
+            disposeRoots(roots);
+            roots = [];
+            return;
+          }
+          model.roots = roots;
+          roots = [];
+          wrapper.add(model.roots[0]);
+          scene.add(wrapper);
+          model.attached = true;
+        });
+      } catch (error) {
+        if (roots.length) disposeRoots(roots);
+        if (!model.controller.signal.aborted && !disposed) {
+          if (models.get(instance.instanceId) === model) models.delete(instance.instanceId);
+          await retire(model);
+          report(`Scenery placement ${instance.instanceId} could not load: ${messageOf(error)}`);
+        }
+      }
+    })());
+  };
+  const updateBackground = (skybox) => {
+    const key = JSON.stringify(skybox);
+    if (backgroundKey === key) return;
+    backgroundKey = key;
+    const generation = ++backgroundGeneration;
+    backgroundLoad?.abort();
+    const controller = new AbortController();
+    backgroundLoad = controller;
+    track((async () => {
+      let next = null;
+      try {
+        if (skybox) {
+          if (skybox.kind === "color") next = display(new Color(skybox.color), skybox);
+          else if (!skybox.assetId) next = generatedSky(skybox);
+          else {
+            const asset = await loadAsset(skybox.assetId, controller.signal);
+            if (controller.signal.aborted) return;
+            next = await imageDisplay(asset, skybox);
+          }
+        }
+        await release(() => {
+          if (controller.signal.aborted || generation !== backgroundGeneration || disposed) {
+            next?.dispose();
+            next = null;
+            return;
+          }
+          if (next) background.set(next.value, next.intensity, next.rotation);
+          else background.clear();
+          const previous = currentDisplay;
+          currentDisplay = next;
+          next = null;
+          previous?.dispose();
+        });
+      } catch (error) {
+        next?.dispose();
+        if (!controller.signal.aborted && generation === backgroundGeneration && !disposed) {
+          backgroundKey = null;
+          report(`Scenery background could not load: ${messageOf(error)}`);
+        }
+      }
+    })());
+  };
+  function dispose() {
+    if (disposal) return disposal;
+    disposed = true;
+    backgroundGeneration++;
+    backgroundLoad?.abort();
+    background.dispose();
+    const releases = [...models.values()].map(retire);
+    models.clear();
+    releases.push(release(() => {
+      currentDisplay?.dispose();
+      currentDisplay = null;
+    }));
+    disposal = (async () => {
+      const results = await Promise.allSettled([...tasks, ...releases]);
+      const failed = results.find((result) => result.status === "rejected");
+      if (failed) throw failed.reason;
+    })();
+    return disposal;
+  }
+  return {
+    update(value) {
+      if (disposed) throw new Error("The scenery renderer has been disposed.");
+      const layout = copyLayout(value);
+      const next = new Map(layout.instances.map((instance) => [instance.instanceId, instance]));
+      for (const [id, model] of models) if (next.get(id)?.assetId !== model.assetId) {
+        models.delete(id);
+        track(retire(model));
+      }
+      for (const instance of layout.instances) {
+        const current = models.get(instance.instanceId);
+        if (current) current.wrapper.position.set(instance.position.x, instance.position.y, instance.position.z);
+        else mount(instance);
+      }
+      updateBackground(layout.skybox);
+    },
+    dispose
+  };
+}
 var COLORS = {
   mapped: 4889258,
   unmapped: 5925498,
@@ -5840,8 +6733,8 @@ function createOctahedralBoneGeometry() {
     -w,
     MID_POSITION
   ]);
-  const geometry = new THREE10.BufferGeometry();
-  geometry.setAttribute("position", new THREE10.BufferAttribute(positions, 3));
+  const geometry = new THREE11.BufferGeometry();
+  geometry.setAttribute("position", new THREE11.BufferAttribute(positions, 3));
   geometry.computeVertexNormals();
   return geometry;
 }
@@ -5858,24 +6751,24 @@ function collectBones(root) {
   });
   return Array.from(bones);
 }
-function isBone2(obj) {
+function isBone3(obj) {
   return !!obj && obj.isBone;
 }
 function countBoneSubtree(bone) {
   let count = 1;
   for (const child of bone.children) {
-    if (isBone2(child)) {
+    if (isBone3(child)) {
       count += countBoneSubtree(child);
     }
   }
   return count;
 }
 function resolveTopLevelHelperRoot(root) {
-  const topLevelBones = collectBones(root).filter((bone) => !isBone2(bone.parent));
+  const topLevelBones = collectBones(root).filter((bone) => !isBone3(bone.parent));
   if (topLevelBones.length !== 1) return null;
   let helperRoot = topLevelBones[0];
   while (ROOT_HELPER_NAME_PATTERN.test(helperRoot.name)) {
-    const boneChildren = helperRoot.children.filter(isBone2);
+    const boneChildren = helperRoot.children.filter(isBone3);
     if (boneChildren.length !== 1) break;
     const onlyChild = boneChildren[0];
     if (!ROOT_HELPER_NAME_PATTERN.test(onlyChild.name)) break;
@@ -5886,7 +6779,7 @@ function resolveTopLevelHelperRoot(root) {
 function resolveBodyDisplayRoot(root) {
   const helperRoot = resolveTopLevelHelperRoot(root);
   if (!helperRoot) return null;
-  const boneChildren = helperRoot.children.filter(isBone2);
+  const boneChildren = helperRoot.children.filter(isBone3);
   if (boneChildren.length === 0) return null;
   if (boneChildren.length === 1) return boneChildren[0];
   const subtreeSizes = boneChildren.map((child) => ({ child, size: countBoneSubtree(child) })).sort((left, right) => right.size - left.size);
@@ -5898,7 +6791,7 @@ function resolveBodyDisplayRoot(root) {
   return null;
 }
 function collectBoneChildren(bone) {
-  return bone.children.filter(isBone2);
+  return bone.children.filter(isBone3);
 }
 function hasZeroLengthConnection(parentBone, childBone) {
   parentBone.getWorldPosition(_parentPos);
@@ -5907,7 +6800,7 @@ function hasZeroLengthConnection(parentBone, childBone) {
 }
 function hasRootHelperAncestor(bone) {
   let current = bone.parent;
-  while (isBone2(current)) {
+  while (isBone3(current)) {
     if (ROOT_HELPER_NAME_PATTERN.test(current.name)) return true;
     current = current.parent;
   }
@@ -5917,7 +6810,7 @@ function shouldSkipRootHelperConnection(parentBone, boneChildren) {
   if (boneChildren.length !== 1) return false;
   const childBone = boneChildren[0];
   if (ROOT_HELPER_NAME_PATTERN.test(parentBone.name)) {
-    if (!isBone2(parentBone.parent)) return true;
+    if (!isBone3(parentBone.parent)) return true;
     return collectBoneChildren(childBone).some((grandChild) => hasZeroLengthConnection(childBone, grandChild));
   }
   return hasRootHelperAncestor(parentBone) && HIP_NAME_PATTERN.test(parentBone.name) && PELVIS_NAME_PATTERN.test(childBone.name) && hasZeroLengthConnection(parentBone, childBone);
@@ -5930,20 +6823,20 @@ function setRayFromPointer(clientX, clientY, camera, domElement) {
   _raycaster.setFromCamera(_mouse, camera);
   return true;
 }
-var _parentPos = new THREE10.Vector3();
-var _childPos = new THREE10.Vector3();
-var _direction = new THREE10.Vector3();
-var _zAxis = new THREE10.Vector3(0, 0, 1);
-var _quaternion = new THREE10.Quaternion();
-var _bonePos = new THREE10.Vector3();
-var _boneQuat = new THREE10.Quaternion();
-var _boneEuler = new THREE10.Euler();
-var _mouse = new THREE10.Vector2();
-var _raycaster = new THREE10.Raycaster();
-var _cameraSpacePosition = new THREE10.Vector3();
-var _planeNormal = new THREE10.Vector3();
-var _dragPlane = new THREE10.Plane();
-var _planeHit = new THREE10.Vector3();
+var _parentPos = new THREE11.Vector3();
+var _childPos = new THREE11.Vector3();
+var _direction = new THREE11.Vector3();
+var _zAxis = new THREE11.Vector3(0, 0, 1);
+var _quaternion = new THREE11.Quaternion();
+var _bonePos = new THREE11.Vector3();
+var _boneQuat = new THREE11.Quaternion();
+var _boneEuler = new THREE11.Euler();
+var _mouse = new THREE11.Vector2();
+var _raycaster = new THREE11.Raycaster();
+var _cameraSpacePosition = new THREE11.Vector3();
+var _planeNormal = new THREE11.Vector3();
+var _dragPlane = new THREE11.Plane();
+var _planeHit = new THREE11.Vector3();
 function resolveSkeletonOverlayStartBoneName(root) {
   return resolveBodyDisplayRoot(root)?.name ?? null;
 }
@@ -5990,9 +6883,9 @@ var SkeletonOverlay = class {
     this.scene = scene;
     this.mappedBoneNames = mappedBoneNames;
     this.semanticKeyMap = semanticKeyMap;
-    this.opacityScale = THREE10.MathUtils.clamp(options.opacityScale ?? 1, 0, 1);
+    this.opacityScale = THREE11.MathUtils.clamp(options.opacityScale ?? 1, 0, 1);
     this.focusSelectedBone = options.focusSelectedBone ?? false;
-    this.group = new THREE10.Group();
+    this.group = new THREE11.Group();
     this.group.name = "SkeletonOverlay";
     this.group.renderOrder = 999;
     this.group.visible = false;
@@ -6001,50 +6894,50 @@ var SkeletonOverlay = class {
       transparent: true,
       depthTest: false,
       depthWrite: false,
-      side: THREE10.DoubleSide
+      side: THREE11.DoubleSide
     };
-    this.mappedMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: COLORS.mapped, opacity: OPACITY.mapped });
-    this.unmappedMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: COLORS.unmapped, opacity: OPACITY.unmapped });
-    this.highlightMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: COLORS.highlighted, opacity: OPACITY.highlighted });
-    this.selectedMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: COLORS.selected, opacity: OPACITY.selected });
-    this.contextMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: COLORS.selected, opacity: OPACITY.context });
-    this.mutedMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: COLORS.unmapped, opacity: OPACITY.muted });
+    this.mappedMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: COLORS.mapped, opacity: OPACITY.mapped });
+    this.unmappedMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: COLORS.unmapped, opacity: OPACITY.unmapped });
+    this.highlightMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: COLORS.highlighted, opacity: OPACITY.highlighted });
+    this.selectedMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: COLORS.selected, opacity: OPACITY.selected });
+    this.contextMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: COLORS.selected, opacity: OPACITY.context });
+    this.mutedMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: COLORS.unmapped, opacity: OPACITY.muted });
     this.mappedMaterial.forceSinglePass = true;
     this.unmappedMaterial.forceSinglePass = true;
     this.highlightMaterial.forceSinglePass = true;
     this.selectedMaterial.forceSinglePass = true;
     this.contextMaterial.forceSinglePass = true;
     this.mutedMaterial.forceSinglePass = true;
-    this.axisRingGeometry = new THREE10.TorusGeometry(1, 0.032, 10, 120);
-    this.axisRingHitGeometry = new THREE10.TorusGeometry(1, AXIS_GIZMO_HIT_TUBE, 8, 64);
-    this.axisCenterGeometry = new THREE10.SphereGeometry(0.082, 12, 8);
-    this.pitchRingMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.pitch, opacity: AXIS_GIZMO_IDLE_OPACITY });
-    this.yawRingMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.yaw, opacity: AXIS_GIZMO_IDLE_OPACITY });
-    this.rollRingMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.roll, opacity: AXIS_GIZMO_IDLE_OPACITY });
-    this.axisHitMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, opacity: 0 });
+    this.axisRingGeometry = new THREE11.TorusGeometry(1, 0.032, 10, 120);
+    this.axisRingHitGeometry = new THREE11.TorusGeometry(1, AXIS_GIZMO_HIT_TUBE, 8, 64);
+    this.axisCenterGeometry = new THREE11.SphereGeometry(0.082, 12, 8);
+    this.pitchRingMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.pitch, opacity: AXIS_GIZMO_IDLE_OPACITY });
+    this.yawRingMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.yaw, opacity: AXIS_GIZMO_IDLE_OPACITY });
+    this.rollRingMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.roll, opacity: AXIS_GIZMO_IDLE_OPACITY });
+    this.axisHitMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, opacity: 0 });
     this.axisHitMaterial.colorWrite = false;
-    this.axisCenterMaterial = new THREE10.MeshBasicMaterial({ ...materialOpts, color: 16119802, opacity: 0.92 });
-    this.axisGizmoGroup = new THREE10.Group();
+    this.axisCenterMaterial = new THREE11.MeshBasicMaterial({ ...materialOpts, color: 16119802, opacity: 0.92 });
+    this.axisGizmoGroup = new THREE11.Group();
     this.axisGizmoGroup.name = "SelectedBoneAxisGizmo";
     this.axisGizmoGroup.visible = false;
     this.axisGizmoGroup.renderOrder = 1e3;
-    const pitchRing = new THREE10.Mesh(this.axisRingGeometry, this.pitchRingMaterial);
+    const pitchRing = new THREE11.Mesh(this.axisRingGeometry, this.pitchRingMaterial);
     pitchRing.renderOrder = 1e3;
     pitchRing.userData.axis = "pitch";
-    const pitchHit = new THREE10.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
+    const pitchHit = new THREE11.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
     pitchHit.userData.axis = "pitch";
-    const yawRing = new THREE10.Mesh(this.axisRingGeometry, this.yawRingMaterial);
+    const yawRing = new THREE11.Mesh(this.axisRingGeometry, this.yawRingMaterial);
     yawRing.renderOrder = 1e3;
     yawRing.userData.axis = "yaw";
-    const yawHit = new THREE10.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
+    const yawHit = new THREE11.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
     yawHit.userData.axis = "yaw";
-    const rollRing = new THREE10.Mesh(this.axisRingGeometry, this.rollRingMaterial);
+    const rollRing = new THREE11.Mesh(this.axisRingGeometry, this.rollRingMaterial);
     rollRing.renderOrder = 1e3;
     rollRing.userData.axis = "roll";
-    const rollHit = new THREE10.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
+    const rollHit = new THREE11.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
     rollHit.rotation.copy(rollRing.rotation);
     rollHit.userData.axis = "roll";
-    const center = new THREE10.Mesh(this.axisCenterGeometry, this.axisCenterMaterial);
+    const center = new THREE11.Mesh(this.axisCenterGeometry, this.axisCenterMaterial);
     center.renderOrder = 1001;
     this.axisGizmoMeshes = {
       pitch: pitchRing,
@@ -6084,11 +6977,11 @@ var SkeletonOverlay = class {
     this.boneTree = allBones.map((bone) => {
       const isMapped = this.mappedBoneNames.has(bone.name);
       const semanticKey = this.semanticKeyMap.get(bone.name) ?? null;
-      const boneChildren = bone.children.filter((c) => isBone2(c) && includedBones.has(c)).map((c) => c.name);
-      const parentName = bone.parent && isBone2(bone.parent) && includedBones.has(bone.parent) ? bone.parent.name : null;
+      const boneChildren = bone.children.filter((c) => isBone3(c) && includedBones.has(c)).map((c) => c.name);
+      const parentName = bone.parent && isBone3(bone.parent) && includedBones.has(bone.parent) ? bone.parent.name : null;
       let depth = 0;
       let current = bone.parent;
-      while (current && isBone2(current) && includedBones.has(current)) {
+      while (current && isBone3(current) && includedBones.has(current)) {
         depth++;
         current = current.parent;
       }
@@ -6104,7 +6997,7 @@ var SkeletonOverlay = class {
     });
     for (const bone of allBones) {
       const boneChildren = bone.children.filter(
-        (c) => isBone2(c) && includedBones.has(c)
+        (c) => isBone3(c) && includedBones.has(c)
       );
       if (boneChildren.length > 0) {
         if (shouldSkipRootHelperConnection(bone, boneChildren)) {
@@ -6118,15 +7011,15 @@ var SkeletonOverlay = class {
       }
     }
     this.group.add(this.axisGizmoGroup);
-    const sentinelGeo = new THREE10.SphereGeometry(1e-6, 4, 2);
-    const sentinelMat = new THREE10.MeshBasicMaterial({
+    const sentinelGeo = new THREE11.SphereGeometry(1e-6, 4, 2);
+    const sentinelMat = new THREE11.MeshBasicMaterial({
       transparent: true,
       opacity: 0,
       depthWrite: false,
       depthTest: false
     });
     sentinelMat.colorWrite = false;
-    const sentinel = new THREE10.Mesh(sentinelGeo, sentinelMat);
+    const sentinel = new THREE11.Mesh(sentinelGeo, sentinelMat);
     sentinel.visible = true;
     sentinel.frustumCulled = false;
     sentinel.onBeforeRender = (renderer, _scene, camera) => this.update(camera, renderer.domElement);
@@ -6138,7 +7031,7 @@ var SkeletonOverlay = class {
   createBoneMesh(parentBone, childBone) {
     const isMapped = this.mappedBoneNames.has(parentBone.name);
     const material = isMapped ? this.mappedMaterial : this.unmappedMaterial;
-    const mesh = new THREE10.Mesh(this.sharedGeometry, material);
+    const mesh = new THREE11.Mesh(this.sharedGeometry, material);
     mesh.name = `bone_vis_${parentBone.name}${childBone ? `_${childBone.name}` : "_leaf"}`;
     mesh.frustumCulled = false;
     mesh.renderOrder = 999;
@@ -6218,20 +7111,20 @@ var SkeletonOverlay = class {
     bone.getWorldPosition(_parentPos);
     let referenceLength = 0;
     for (const child of bone.children) {
-      if (!isBone2(child)) continue;
+      if (!isBone3(child)) continue;
       child.getWorldPosition(_childPos);
       const nextDistance = _parentPos.distanceTo(_childPos);
       if (nextDistance <= 1e-4) continue;
       referenceLength = referenceLength === 0 ? nextDistance : Math.min(referenceLength, nextDistance);
     }
-    if (referenceLength <= 1e-4 && isBone2(bone.parent)) {
+    if (referenceLength <= 1e-4 && isBone3(bone.parent)) {
       bone.parent.getWorldPosition(_childPos);
       referenceLength = _parentPos.distanceTo(_childPos);
     }
     if (referenceLength <= 1e-4) {
       referenceLength = LEAF_BONE_LENGTH;
     }
-    return THREE10.MathUtils.clamp(
+    return THREE11.MathUtils.clamp(
       referenceLength * AXIS_GIZMO_RADIUS_FACTOR,
       AXIS_GIZMO_MIN_RADIUS,
       AXIS_GIZMO_MAX_RADIUS
@@ -6247,7 +7140,7 @@ var SkeletonOverlay = class {
       _cameraSpacePosition.copy(origin).applyMatrix4(perspectiveCamera.matrixWorldInverse);
       const depth = -_cameraSpacePosition.z;
       if (!Number.isFinite(depth) || depth <= perspectiveCamera.near) return null;
-      const visibleWorldHeight = 2 * depth * Math.tan(THREE10.MathUtils.degToRad(perspectiveCamera.getEffectiveFOV()) / 2);
+      const visibleWorldHeight = 2 * depth * Math.tan(THREE11.MathUtils.degToRad(perspectiveCamera.getEffectiveFOV()) / 2);
       return visibleWorldHeight * (AXIS_GIZMO_SCREEN_RADIUS_PX / viewportHeight);
     }
     if (camera.isOrthographicCamera) {
@@ -6378,9 +7271,9 @@ var SkeletonOverlay = class {
     return {
       position: [_bonePos.x, _bonePos.y, _bonePos.z],
       rotation: [
-        THREE10.MathUtils.radToDeg(_boneEuler.x),
-        THREE10.MathUtils.radToDeg(_boneEuler.y),
-        THREE10.MathUtils.radToDeg(_boneEuler.z)
+        THREE11.MathUtils.radToDeg(_boneEuler.x),
+        THREE11.MathUtils.radToDeg(_boneEuler.y),
+        THREE11.MathUtils.radToDeg(_boneEuler.z)
       ]
     };
   }
@@ -6582,7 +7475,7 @@ function getDeltaMagnitudeAtIndex(mesh, morphAttribute, index) {
   return Math.hypot(dx, dy, dz);
 }
 function resolveMorphPreviewMeshes(root, morphName, meshNames) {
-  const nameFilter = meshNames?.length ? new Set(meshNames) : null;
+  const nameFilter = meshNames ? new Set(meshNames) : null;
   const meshes = [];
   root.traverse((obj) => {
     const mesh = obj;
@@ -6631,7 +7524,7 @@ function writePointColor(colors, offset, intensity2) {
   colors[offset + 1] = COLOR_LOW.g + (COLOR_HIGH.g - COLOR_LOW.g) * intensity2;
   colors[offset + 2] = COLOR_LOW.b + (COLOR_HIGH.b - COLOR_LOW.b) * intensity2;
 }
-function buildMorphVertexPreviewRenderData(meshes, morphName, cache, options = {}) {
+function buildMorphVertexPreviewRenderData(meshes, morphName, cache, options = {}, previous = null) {
   const threshold = options.threshold ?? DEFAULT_THRESHOLD;
   const maxPoints = options.maxPoints ?? DEFAULT_MAX_POINTS;
   const sampledMeshes = [];
@@ -6648,9 +7541,9 @@ function buildMorphVertexPreviewRenderData(meshes, morphName, cache, options = {
     pointCount += sample.indices.length;
   }
   if (pointCount === 0) return null;
-  const positions = new Float32Array(pointCount * 3);
-  const colors = new Float32Array(pointCount * 3);
-  const vertex = new THREE10.Vector3();
+  const positions = previous?.positions.length === pointCount * 3 ? previous.positions : new Float32Array(pointCount * 3);
+  const colors = previous?.colors.length === pointCount * 3 ? previous.colors : new Float32Array(pointCount * 3);
+  const vertex = new THREE11.Vector3();
   let cursor = 0;
   for (const { mesh, sample } of sampledMeshes) {
     mesh.updateWorldMatrix(true, false);
@@ -6706,6 +7599,7 @@ var MorphVertexPreview = class {
     __publicField(this, "cache", /* @__PURE__ */ new Map());
     __publicField(this, "points", null);
     __publicField(this, "active", null);
+    __publicField(this, "renderData", null);
     __publicField(this, "disposed", false);
     __publicField(this, "unbindRender", null);
   }
@@ -6715,12 +7609,18 @@ var MorphVertexPreview = class {
       this.hide();
       return;
     }
+    if (this.active?.morphName !== morphName || this.active?.meshNames?.length !== meshNames?.length || meshNames?.some((name, index) => name !== this.active?.meshNames?.[index])) {
+      this.cache.clear();
+      this.renderData = null;
+    }
     this.active = { morphName, meshNames: meshNames?.slice() };
     this.unbindRender ?? (this.unbindRender = bindPreviewRender(this.scene, () => this.update()));
     this.update();
   }
   hide() {
     this.active = null;
+    this.cache.clear();
+    this.renderData = null;
     this.unbindRender?.();
     this.unbindRender = null;
     if (this.points) this.points.visible = false;
@@ -6737,7 +7637,7 @@ var MorphVertexPreview = class {
     this.points = null;
   }
   createPoints() {
-    const points = new THREE10.Points(new THREE10.BufferGeometry(), new THREE10.PointsMaterial({
+    const points = new THREE11.Points(new THREE11.BufferGeometry(), new THREE11.PointsMaterial({
       size: 0.012,
       sizeAttenuation: true,
       transparent: true,
@@ -6758,26 +7658,31 @@ var MorphVertexPreview = class {
     if (this.disposed || !this.active) return;
     const { morphName, meshNames } = this.active;
     const meshes = resolveMorphPreviewMeshes(this.scene, morphName, meshNames);
-    const data = buildMorphVertexPreviewRenderData(meshes, morphName, this.cache, this.options);
+    const data = buildMorphVertexPreviewRenderData(meshes, morphName, this.cache, this.options, this.renderData);
+    this.renderData = data;
     if (!data) {
       if (this.points) this.points.visible = false;
       return;
     }
     const points = this.points ?? this.createPoints();
-    this.updateAttribute(points.geometry, "position", data.positions, data.pointCount);
-    this.updateAttribute(points.geometry, "color", data.colors, data.pointCount);
+    this.updateGeometry(points.geometry, data);
     points.geometry.computeBoundingSphere();
     points.material.size = data.pointCount > 6e3 ? 9e-3 : 0.012;
     points.visible = true;
   }
-  updateAttribute(geometry, name, values, pointCount) {
-    const attribute = geometry.getAttribute(name);
-    if (!attribute || attribute.count !== pointCount) {
-      geometry.setAttribute(name, new THREE10.BufferAttribute(values, 3));
+  updateGeometry(geometry, data) {
+    const position = geometry.getAttribute("position");
+    const color = geometry.getAttribute("color");
+    if (!position || !color || position.count !== data.pointCount || color.count !== data.pointCount) {
+      if (position || color) geometry.dispose();
+      geometry.setAttribute("position", new THREE11.BufferAttribute(data.positions, 3));
+      geometry.setAttribute("color", new THREE11.BufferAttribute(data.colors, 3));
       return;
     }
-    attribute.array.set(values);
-    attribute.needsUpdate = true;
+    if (position.array !== data.positions) position.array.set(data.positions);
+    if (color.array !== data.colors) color.array.set(data.colors);
+    position.needsUpdate = true;
+    color.needsUpdate = true;
   }
 };
 
@@ -6831,7 +7736,7 @@ var transform = (obj) => ({
   rotation: { x: obj.quaternion.x, y: obj.quaternion.y, z: obj.quaternion.z, w: obj.quaternion.w },
   scale: { x: obj.scale.x, y: obj.scale.y, z: obj.scale.z }
 });
-var snapshot = (obj, reference) => {
+var snapshot2 = (obj, reference) => {
   if (!reference) {
     return {
       obj,
@@ -6881,6 +7786,7 @@ var ThreeModelInspector = class {
     const allMeshes = [];
     const boneObjects = [];
     model.traverse((obj) => {
+      if (highlightOverlays.has(obj)) return;
       objects.push(obj);
       if (obj.isMesh) allMeshes.push(obj);
       if (obj.isBone || obj.type === "Bone") boneObjects.push(obj);
@@ -6916,7 +7822,7 @@ var ThreeModelInspector = class {
     }
     const bones = {};
     for (const bone of boneObjects) {
-      if (bone.name) bones[bone.name] = snapshot(bone, references?.get(bone));
+      if (bone.name) bones[bone.name] = snapshot2(bone, references?.get(bone));
     }
     const profile = options.profile;
     if (profile?.boneNodes) {
@@ -6925,7 +7831,7 @@ var ThreeModelInspector = class {
         const suffix = profile.boneSuffix ?? "";
         const name = `${base.startsWith(prefix) ? "" : prefix}${base}${base.endsWith(suffix) ? "" : suffix}`;
         const object = model.getObjectByName(name) ?? model.getObjectByName(base);
-        if (object) bones[key] = bones[object.name] ?? snapshot(object, references?.get(object));
+        if (object) bones[key] = bones[object.name] ?? snapshot2(object, references?.get(object));
       }
     }
     return {
@@ -7033,6 +7939,16 @@ function serializeAnimationClips(model, clips, inspection) {
   const meshIds = new Map(Array.from(inspection.meshBindings, ([id, mesh]) => [mesh, id]));
   const boneIds = new Map(Array.from(inspection.boneBindings, ([id, bone]) => [bone, id]));
   const objectIds = new Map(Array.from(inspection.objectBindings, ([id, object]) => [object, id]));
+  const morphIds = /* @__PURE__ */ new Map();
+  for (const [id, { mesh, index }] of inspection.morphBindings) {
+    let indices = morphIds.get(mesh);
+    if (!indices) {
+      indices = /* @__PURE__ */ new Map();
+      morphIds.set(mesh, indices);
+    }
+    if (!indices.has(index)) indices.set(index, id);
+  }
+  const destinations = /* @__PURE__ */ new Map();
   return clips.map((clip) => {
     const tracks = [];
     const channelKinds = /* @__PURE__ */ new Map();
@@ -7044,7 +7960,11 @@ function serializeAnimationClips(model, clips, inspection) {
       return id;
     };
     withComponentTracks(clip).tracks.forEach((track, index) => {
-      const found = findTrackTarget(model, track);
+      let found = destinations.get(track.name);
+      if (found === void 0) {
+        found = findTrackTarget(model, track);
+        destinations.set(track.name, found);
+      }
       if (!found?.object) return;
       const { parsed, object } = found;
       let target = null;
@@ -7053,8 +7973,9 @@ function serializeAnimationClips(model, clips, inspection) {
         const mesh = object;
         const requested = parsed.propertyIndex;
         const indexValue = typeof requested === "number" ? requested : Number.isFinite(Number(requested)) ? Number(requested) : mesh.morphTargetDictionary?.[String(requested)];
-        const binding = Array.from(inspection.morphBindings).find(([, entry]) => entry.mesh === mesh && entry.index === indexValue);
-        if (binding) target = { kind: "morphTarget", meshId: meshIds.get(mesh), morphTargetId: binding[0] };
+        if (indexValue === void 0) return;
+        const morphTargetId = morphIds.get(mesh)?.get(indexValue);
+        if (morphTargetId !== void 0) target = { kind: "morphTarget", meshId: meshIds.get(mesh), morphTargetId };
       } else if (property === "visible" && object.isMesh) {
         target = { kind: "meshVisibility", meshId: meshIds.get(object) };
       } else {
@@ -7068,7 +7989,7 @@ function serializeAnimationClips(model, clips, inspection) {
       const kind = target.kind === "morphTarget" ? "face" : target.kind === "boneTransform" ? "body" : "scene";
       const cubic = !!track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline;
       const size = track.getValueSize() / (cubic ? 3 : 1);
-      if (!Array.from(track.values).every(Number.isFinite)) {
+      if (!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);
@@ -7092,15 +8013,17 @@ function serializeAnimationClips(model, clips, inspection) {
   });
 }
 var materials = (value) => value ? Array.isArray(value) ? value : [value] : [];
+var highlightOverlays = /* @__PURE__ */ new WeakSet();
 var ThreeFrameApplier = class {
   constructor() {
     __publicField(this, "meshes", /* @__PURE__ */ new Map());
     __publicField(this, "morphs", /* @__PURE__ */ new Map());
     __publicField(this, "bones", /* @__PURE__ */ new Map());
     __publicField(this, "objects", /* @__PURE__ */ new Map());
-    __publicField(this, "originalEmissive", /* @__PURE__ */ new Map());
+    __publicField(this, "highlighted", /* @__PURE__ */ new Map());
   }
   setBindings(inspection) {
+    this.clearMeshHighlights();
     this.meshes = new Map(inspection.meshBindings);
     this.morphs = new Map(inspection.morphBindings);
     this.bones = new Map(inspection.boneBindings);
@@ -7146,7 +8069,7 @@ var ThreeFrameApplier = class {
       const config = configs[object.name];
       if (!config) return;
       if (typeof config.visible === "boolean") object.visible = config.visible;
-      if (config.material) this.applyMaterial(object, config.material);
+      if (config.material) this.applyHighlightedMeshMaterial(object, config.material);
     });
   }
   getMeshMaterialConfig(root, name) {
@@ -7154,38 +8077,97 @@ var ThreeFrameApplier = class {
     this.visitMesh(root, name, (mesh) => {
       const material = materials(mesh.material)[0];
       if (!material) return;
-      const blending = Object.entries(THREE_BLENDING_MODES).find(([, value]) => value === material.blending)?.[0] ?? "Normal";
+      const blending = Object.keys(THREE_BLENDING_MODES).find((key) => THREE_BLENDING_MODES[key] === material.blending) ?? "Normal";
       result = { renderOrder: mesh.renderOrder, transparent: material.transparent, opacity: material.opacity, depthWrite: material.depthWrite, depthTest: material.depthTest, blending };
     });
     return result;
   }
   setMeshMaterialConfig(root, name, config) {
-    this.visitMesh(root, name, (mesh) => this.applyMaterial(mesh, config));
+    this.visitMesh(root, name, (mesh) => this.applyHighlightedMeshMaterial(mesh, config));
+  }
+  applyHighlightedMeshMaterial(mesh, config) {
+    this.applyMaterial(mesh, config);
+    const original = this.highlighted.get(mesh)?.original;
+    if (!original) return;
+    const highlighted = mesh.material;
+    try {
+      mesh.material = original;
+      this.applyMaterial(mesh, config);
+    } finally {
+      mesh.material = highlighted;
+    }
   }
   setMeshVisible(root, name, visible) {
     this.visitMesh(root, name, (mesh) => {
       mesh.visible = visible;
     });
   }
-  highlightMesh(root, name, color = 65535, intensity2 = 0.5) {
-    root.traverse((object) => {
-      if (!object.isMesh) return;
-      for (const material of materials(object.material)) {
+  /** Apply a complete Rust snapshot. Only native resources and ID bindings live here. */
+  applyMeshHighlightFrame(frame) {
+    if (frame.version !== 1) throw new Error(`Unsupported mesh highlight frame version: ${frame.version}`);
+    const selected = new Set(frame.highlights.map((write) => this.meshes.get(write.meshId)));
+    for (const mesh of this.highlighted.keys()) {
+      if (!selected.has(mesh)) this.clearMeshHighlight(mesh);
+    }
+    for (const write of frame.highlights) {
+      if (write.edgeMode !== "triangles") throw new Error(`Unsupported highlight edge mode: ${write.edgeMode}`);
+      const mesh = this.meshes.get(write.meshId);
+      if (!mesh) continue;
+      let state = this.highlighted.get(mesh);
+      if (!state) {
+        const original = mesh.material;
+        const copies = materials(original).map((material) => {
+          const copy2 = material.clone();
+          copy2.polygonOffset = true;
+          copy2.polygonOffsetFactor = 1;
+          copy2.polygonOffsetUnits = 1;
+          return copy2;
+        });
+        mesh.material = Array.isArray(original) ? copies : copies[0];
+        const overlay = mesh.clone(false);
+        overlay.name = "";
+        overlay.userData = {};
+        overlay.position.set(0, 0, 0);
+        overlay.quaternion.identity();
+        overlay.scale.set(1, 1, 1);
+        overlay.matrix.identity();
+        overlay.matrixAutoUpdate = true;
+        overlay.visible = true;
+        overlay.castShadow = overlay.receiveShadow = false;
+        overlay.raycast = () => {
+        };
+        overlay.material = new MeshBasicMaterial({ wireframe: write.edgeMode === "triangles", transparent: true, depthWrite: false, toneMapped: false });
+        overlay.onBeforeRender = () => {
+          overlay.geometry = mesh.geometry;
+          overlay.morphTargetInfluences = mesh.morphTargetInfluences;
+        };
+        highlightOverlays.add(overlay);
+        mesh.add(overlay);
+        state = { original, overlay };
+        this.highlighted.set(mesh, state);
+      }
+      for (const material of materials(mesh.material)) {
         if (!material.emissive) continue;
-        const key = `${object.uuid}:${material.uuid}`;
-        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 = intensity2;
-        } else {
-          const original = this.originalEmissive.get(key);
-          if (original) {
-            material.emissive.setHex(original.color);
-            material.emissiveIntensity = original.intensity;
-          }
-        }
+        material.emissive.setRGB(...write.fillColor);
+        material.emissiveIntensity = write.fillIntensity;
       }
-    });
+      const edges = state.overlay.material;
+      edges.color.setRGB(...write.edgeColor);
+      edges.opacity = write.edgeOpacity;
+      edges.side = materials(mesh.material)[0]?.side ?? edges.side;
+      state.overlay.renderOrder = mesh.renderOrder + 1;
+    }
+  }
+  clearMeshHighlights() {
+    for (const mesh of this.highlighted.keys()) this.clearMeshHighlight(mesh);
+  }
+  clearMeshHighlight(mesh) {
+    const state = this.highlighted.get(mesh);
+    state.overlay.removeFromParent();
+    state.overlay.material.dispose();
+    for (const material of materials(mesh.material)) material.dispose();
+    mesh.material = state.original;
+    this.highlighted.delete(mesh);
   }
   applyHairAppearance(meshes, appearance) {
     for (const mesh of meshes) {
@@ -7322,13 +8304,19 @@ var ThreeFrameApplier = class {
   applyMaterial(mesh, config) {
     if (typeof config.renderOrder === "number") mesh.renderOrder = config.renderOrder;
     for (const material of materials(mesh.material)) {
-      if (typeof config.opacity === "number") material.opacity = config.opacity;
-      if (typeof config.transparent === "boolean") material.transparent = config.transparent;
-      else if (typeof config.opacity === "number" && config.opacity < 1) material.transparent = true;
-      if (typeof config.depthWrite === "boolean") material.depthWrite = config.depthWrite;
-      if (typeof config.depthTest === "boolean") material.depthTest = config.depthTest;
-      if (config.blending) material.blending = THREE_BLENDING_MODES[config.blending];
-      material.needsUpdate = true;
+      let changed = false;
+      const assign = (key, value) => {
+        if (material[key] === value) return;
+        material[key] = value;
+        changed = true;
+      };
+      if (typeof config.opacity === "number") assign("opacity", config.opacity);
+      if (typeof config.transparent === "boolean") assign("transparent", config.transparent);
+      else if (typeof config.opacity === "number" && config.opacity < 1) assign("transparent", true);
+      if (typeof config.depthWrite === "boolean") assign("depthWrite", config.depthWrite);
+      if (typeof config.depthTest === "boolean") assign("depthTest", config.depthTest);
+      if (config.blending) assign("blending", THREE_BLENDING_MODES[config.blending]);
+      if (changed) material.needsUpdate = true;
     }
   }
   visitMesh(root, name, visit) {
@@ -7340,11 +8328,11 @@ var ThreeFrameApplier = class {
 var collectMorphMeshes = (root) => {
   const meshes = [];
   root.traverse((object) => {
-    if (object.isMesh && morphEntries(object).length > 0) meshes.push(object);
+    if (object.isMesh && !highlightOverlays.has(object) && morphEntries(object).length > 0) meshes.push(object);
   });
   return meshes;
 };
 
-export { BLENDING_MODES, CHARACTER_SCENE_TYPES, CHARACTER_SCENE_TYPE_IDS, ThreeAnnotationController 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, Embody, HtmlAnnotationMarkers, ThreeAnnotationMarkers as Markers3D, HtmlAnnotationMarkers as MarkersHTML, MorphVertexPreview, HtmlAnnotationMarkers as OverlayAnnotationMarkers, RUNTIME_ANNOTATION_REGION_PREFIX, RustAnnotationCameraCore, SkeletonOverlay, THREE_BLENDING_MODES, ThreeAnnotationController, ThreeAnnotationMarkers, ThreeAnnotations, ThreeFrameApplier, ThreeModelInspector, ThreeNativePlaybackConnector, analyzeModel, applyAUBoneBindingUpdate, applyBilateralAxisBindingUpdate, applyBoneAxisBindingUpdate, applyCharacterModelTransform, bindModelReferencePose, boneResolutionProfile, buildBoneAuOptions, buildMappedBoneInfo, buildMorphVertexPreviewRenderData, buildMorphVertexPreviewSample, buildRegionDisplayOptions, captureModelReferencePose, classifyAuAsJointControl, collectMorphMeshes, collectSkeletonBones, 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, findModelRoot, findNodeKeyForBone, formatAxisDirectionLabel, formatAxisLabel, fuzzyNameMatch, getAUBoneBindingState, getAxisFromChannel, getBilateralAxisBindingState, 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, resolveMorphPreviewMeshes, resolveRegionCameraAngle, resolveRegionVisibilityCameraAngle, resolveSkeletonOverlayStartBoneName, resolveVisemeProfile, serializeAnimationClips, setAUMorphTargets, setHumanoidRoleBinding, shouldProjectMarkerAnchorToSurface, shouldUseFaceCenterForMarkerAnchor, stripConfiguredBoneAffixes, supportsRustEmbodyPreset, toWorldDirection, validateHumanoidCharacterization, validateMappings };
+export { BLENDING_MODES, CHARACTER_SCENE_TYPES, CHARACTER_SCENE_TYPE_IDS, ThreeAnnotationController 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, Embody, HtmlAnnotationMarkers, ThreeAnnotationMarkers as Markers3D, HtmlAnnotationMarkers as MarkersHTML, MorphVertexPreview, HtmlAnnotationMarkers as OverlayAnnotationMarkers, RUNTIME_ANNOTATION_REGION_PREFIX, RustAnnotationCameraCore, SkeletonOverlay, THREE_BLENDING_MODES, ThreeAnnotationController, ThreeAnnotationMarkers, ThreeAnnotations, ThreeFrameApplier, ThreeModelInspector, ThreeNativePlaybackConnector, analyzeModel, applyAUBoneBindingUpdate, applyBilateralAxisBindingUpdate, applyBoneAxisBindingUpdate, applyCharacterModelTransform, bindModelReferencePose, boneResolutionProfile, buildBoneAuOptions, buildMappedBoneInfo, buildMorphVertexPreviewRenderData, buildMorphVertexPreviewSample, buildRegionDisplayOptions, captureModelReferencePose, classifyAuAsJointControl, collectMorphMeshes, collectSkeletonBones, computeHumanoidSkeletonTemplateRestBounds, convertMixamoFbxToVrmAnimations, convertMixamoToVrmAnimation, createAnimationClipFromClipIR, createAnimationClipFromVrmAnimation, createBilateralBoneAxisAu, createBoneAxisAu, createCharacterHost, createDefaultCharacterLighting, createDefaultCharacterScene, createDefaultCharacterSceneAsync, createDefaultCharacterSceneRuntime, createMarkerLifecycleRevealOptions, createMarkerVisibilityLifecycle, createRuntimeAnnotationPreviewLifecycle, createRustAnnotationCameraCore, createRustEmbodyHost, createRustEmbodyHostUnbound, createScenePlaybackFrame, createSceneSceneryRenderer, createShadowPlane, createValidationSkeletonFromHumanoidTemplate, detectAnnotationLaterality, disposeCharacterModel, ensureBilateralBoneNodeKeys, ensureBoneNodeKey, extendCharacterConfigWithPreset, extendModelReferencePose, extractHumanoidSkeletonTemplateFromModel, extractModelData, extractProfileOverrides, filterCameraViewRegions, findModelRoot, findNodeKeyForBone, formatAxisDirectionLabel, formatAxisLabel, fuzzyNameMatch, getAUBoneBindingState, getAUBoneBindingStates, getAxisFromChannel, getBilateralAxisBindingState, getBoneAxisBindingState, getDefaultAnnotationLaterality, getHumanoidSkeletonTemplate, getHumanoidSkeletonTemplateBoneNames, getHumanoidSpecification, getMeshNamesForAUProfile, getModelLocalOrbitAngle, getPreset, getRuntimeAUMeshSideOffset, getRuntimeAUMorphAnchorPoint, getRuntimeAnnotationSide, getSemanticHorizontalSign, getSemanticHorizontalSignForSide, getWorldDirectionForCameraAngle, hasLeftRightMorphs, inferChiralBoneNamePair, inferEyeControlFamily, inferEyeControlScope, inferRuntimeAnnotationPreviewSide, inspectVrmAnimation, isJointControlAuInfo, isMaxDegreesOnlyAxisBindingUpdate, isMixedAU, isRuntimeAnnotationRegionName, loadCharacterModel, mergeCharacterRegionsByName, normalizeDefaultCharacterLightingSettings, normalizeHairColorAppearance, parseCharacterModel, passesMarkerCameraAngleGate, pickContinuumAnnotationAuId, renderScenePlayback, resolveAnnotationCharacterConfig, resolveBoneAxisChannel, resolveBoneNameForNodeKey, resolveBoneNames, resolveContinuumDisplayLabel, resolveFaceCenter, resolveHumanoidCharacterization, resolveMarkerAnchorRegion, resolveMorphMeshSelections, resolveMorphPreviewMeshes, resolveRegionCameraAngle, resolveRegionVisibilityCameraAngle, resolveSkeletonOverlayStartBoneName, resolveVisemeProfile, serializeAnimationClips, setAUMorphTargets, setHumanoidRoleBinding, shouldProjectMarkerAnchorToSurface, shouldUseFaceCenterForMarkerAnchor, stripConfiguredBoneAffixes, supportsRustEmbodyPreset, toWorldDirection, validateHumanoidCharacterization, validateMappings };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map