@lovelace_lol/embody 0.0.12 → 0.0.13

package/dist/three.js

@@ -8377,6 +8377,262 @@ async function createRustEmbodyHost(model, config = {}) {
     throw error;
   }
 }
+
+// three/sceneInkBackgroundStyle.ts
+var SCENE_INK_BASE_GRADIENT = "radial-gradient(ellipse at 50% 42%, #46535c 0%, #35414a 42%, #29333b 76%, #252e35 100%)";
+var DEFAULT_PALETTE = ["#7cb8b2", "#627888", "#8b989f"];
+function createSceneInkBackgroundCss(palette = DEFAULT_PALETTE) {
+  const [a, b, c] = palette;
+  return [
+    `radial-gradient(ellipse 46% 62% at calc(20% + var(--scene-ink-shift-x, 0%)) 30%, color-mix(in srgb, ${a} 24%, transparent), transparent 78%)`,
+    `radial-gradient(ellipse 32% 44% at 34% calc(52% + var(--scene-ink-shift-y, 0%)), color-mix(in srgb, ${a} 12%, transparent), transparent 82%)`,
+    `radial-gradient(ellipse 48% 60% at calc(82% - var(--scene-ink-shift-x, 0%)) 62%, color-mix(in srgb, ${b} 22%, transparent), transparent 80%)`,
+    `radial-gradient(ellipse 28% 38% at 68% calc(26% - var(--scene-ink-shift-y, 0%)), color-mix(in srgb, ${b} 10%, transparent), transparent 82%)`,
+    `radial-gradient(ellipse 50% 38% at 38% calc(78% + var(--scene-ink-shift-y, 0%)), color-mix(in srgb, ${c} 18%, transparent), transparent 82%)`,
+    SCENE_INK_BASE_GRADIENT
+  ].join(", ");
+}
+createSceneInkBackgroundCss();
+
+// three/sceneInkBackground.ts
+var toCssColor = (tone) => `#${new THREE3.Color(tone).getHexString()}`;
+function createSceneInkBackground(onBackgroundChange) {
+  let currentBackground = "";
+  let disposed = false;
+  const applyBackground = (palette) => {
+    if (disposed) return;
+    const colors = palette ? [toCssColor(palette[0]), toCssColor(palette[1]), toCssColor(palette[2])] : void 0;
+    const background = createSceneInkBackgroundCss(colors);
+    if (background === currentBackground) return;
+    currentBackground = background;
+    onBackgroundChange?.(background);
+  };
+  applyBackground();
+  return {
+    setPalette: applyBackground,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+    }
+  };
+}
+var paletteCache = /* @__PURE__ */ new Map();
+var MAX_TEXTURE_SAMPLE_SIZE = 10;
+var MIN_SAMPLE_SATURATION = 0.04;
+var MIN_CANDIDATE_DISTANCE = 0.12;
+function resolveCharacterMaterialPalette(model, cacheKey) {
+  const cached = getCachedPalette(cacheKey);
+  if (cached.materialPalette !== void 0) {
+    return cached.materialPalette;
+  }
+  const samples = collectPaletteSamples(model, false);
+  const palette = buildPalette(samples);
+  cached.materialPalette = palette;
+  return palette;
+}
+function resolveCharacterTexturePalette(model, cacheKey) {
+  const cached = getCachedPalette(cacheKey);
+  if (cached.texturePalette !== void 0) {
+    return Promise.resolve(cached.texturePalette);
+  }
+  if (cached.texturePalettePromise) {
+    return cached.texturePalettePromise;
+  }
+  cached.texturePalettePromise = schedulePaletteExtraction(() => {
+    const samples = collectPaletteSamples(model, true);
+    const palette = buildPalette(samples);
+    cached.texturePalette = palette;
+    return palette;
+  });
+  return cached.texturePalettePromise;
+}
+function getCachedPalette(cacheKey) {
+  const cached = paletteCache.get(cacheKey) ?? {};
+  paletteCache.set(cacheKey, cached);
+  return cached;
+}
+function schedulePaletteExtraction(extractPalette) {
+  return new Promise((resolve) => {
+    const run = () => resolve(extractPalette());
+    if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+      window.requestIdleCallback(run, { timeout: 700 });
+      return;
+    }
+    globalThis.setTimeout(run, 0);
+  });
+}
+function collectPaletteSamples(model, includeTextures) {
+  const samples = [];
+  const seenMaterials = /* @__PURE__ */ new Set();
+  const seenTextures = /* @__PURE__ */ new Set();
+  model.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh || !mesh.material) {
+      return;
+    }
+    const materials2 = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    for (const material of materials2) {
+      if (!material || seenMaterials.has(material.uuid)) {
+        continue;
+      }
+      seenMaterials.add(material.uuid);
+      collectMaterialSamples(material, samples, seenTextures, includeTextures);
+    }
+  });
+  return samples;
+}
+function collectMaterialSamples(material, samples, seenTextures, includeTextures) {
+  pushColorSample(samples, material.color, 1.25);
+  pushColorSample(samples, material.emissive, 0.8);
+  if (!includeTextures) {
+    return;
+  }
+  if (material.map && !seenTextures.has(material.map.uuid)) {
+    seenTextures.add(material.map.uuid);
+    samples.push(...sampleTexture(material.map));
+  }
+  if (material.emissiveMap && !seenTextures.has(material.emissiveMap.uuid)) {
+    seenTextures.add(material.emissiveMap.uuid);
+    samples.push(...sampleTexture(material.emissiveMap).map(({ color, score }) => ({
+      color,
+      score: score * 0.65
+    })));
+  }
+}
+function pushColorSample(samples, color, score) {
+  if (!color || !isUsableColor(color)) {
+    return;
+  }
+  samples.push({
+    color: color.clone(),
+    score
+  });
+}
+function sampleTexture(texture) {
+  if (typeof document === "undefined") {
+    return [];
+  }
+  const image = texture.image;
+  const imageSize = getImageSize(image);
+  if (!image || !imageSize) {
+    return [];
+  }
+  const canvas = document.createElement("canvas");
+  const width = Math.min(MAX_TEXTURE_SAMPLE_SIZE, imageSize.width);
+  const height = Math.min(MAX_TEXTURE_SAMPLE_SIZE, imageSize.height);
+  canvas.width = width;
+  canvas.height = height;
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) {
+    return [];
+  }
+  try {
+    context.drawImage(image, 0, 0, width, height);
+    const data = context.getImageData(0, 0, width, height).data;
+    const samples = [];
+    for (let index = 0; index < data.length; index += 4) {
+      const alpha = data[index + 3] / 255;
+      if (alpha < 0.18) {
+        continue;
+      }
+      const color = new THREE3.Color(
+        data[index] / 255,
+        data[index + 1] / 255,
+        data[index + 2] / 255
+      );
+      if (!isUsableColor(color)) {
+        continue;
+      }
+      const hsl = { h: 0, s: 0, l: 0 };
+      color.getHSL(hsl);
+      samples.push({
+        color,
+        score: alpha * (0.4 + hsl.s * 1.3)
+      });
+    }
+    return samples;
+  } catch {
+    return [];
+  }
+}
+function getImageSize(image) {
+  if (!image || !("width" in image) || !("height" in image)) {
+    return null;
+  }
+  const width = Number(image.width);
+  const height = Number(image.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return null;
+  }
+  return { width, height };
+}
+function isUsableColor(color) {
+  const hsl = { h: 0, s: 0, l: 0 };
+  color.getHSL(hsl);
+  return hsl.l > 0.05 && hsl.l < 0.94 && hsl.s >= MIN_SAMPLE_SATURATION;
+}
+function buildPalette(samples) {
+  if (samples.length === 0) {
+    return null;
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const sample of 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 THREE3.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;
+    bucket.score += sample.score;
+    buckets.set(bucketId, bucket);
+  }
+  const candidates = Array.from(buckets.values()).filter((bucket) => bucket.score > 0).map((bucket) => ({
+    color: massageBackgroundTone(bucket.color.multiplyScalar(1 / bucket.score)),
+    score: bucket.score
+  })).sort((a, b) => b.score - a.score);
+  const selected = [];
+  for (const candidate of candidates) {
+    const distinctEnough = selected.every((color) => colorDistance(color, candidate.color) >= MIN_CANDIDATE_DISTANCE);
+    if (!distinctEnough) {
+      continue;
+    }
+    selected.push(candidate.color);
+    if (selected.length === 3) {
+      break;
+    }
+  }
+  if (selected.length === 0) {
+    return null;
+  }
+  while (selected.length < 3) {
+    selected.push(createCompanionTone(selected[0], selected.length));
+  }
+  return [selected[0], selected[1], selected[2]];
+}
+function massageBackgroundTone(color) {
+  const hsl = { h: 0, s: 0, l: 0 };
+  color.getHSL(hsl);
+  const saturation = THREE3.MathUtils.clamp(Math.max(hsl.s * 1.35, 0.46), 0.46, 0.82);
+  const lightness = THREE3.MathUtils.clamp(hsl.l + 0.08, 0.42, 0.66);
+  return new THREE3.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 THREE3.Color().setHSL(
+    THREE3.MathUtils.euclideanModulo(hsl.h + hueOffset, 1),
+    THREE3.MathUtils.clamp(hsl.s * (index === 1 ? 0.92 : 0.82), 0.38, 0.76),
+    THREE3.MathUtils.clamp(hsl.l + (index === 1 ? 0.04 : -0.03), 0.38, 0.68)
+  );
+}
+function colorDistance(a, b) {
+  const dr = a.r - b.r;
+  const dg = a.g - b.g;
+  const db = a.b - b.b;
+  return Math.sqrt(dr * dr + dg * dg + db * db);
+}
 var draco = null;
 var dracoPath = "";
 var gltfLoader = null;
@@ -8451,6 +8707,154 @@ function parseCharacterModel(data, resourcePath = "", 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));
 }
+
+// three/modelMorphLayout.ts
+var THREE_RENDERED_MORPH_SEMANTICS = ["position", "normal", "color"];
+function resolveMorphTargetCount(mesh) {
+  const morphAttributes = mesh.geometry.morphAttributes;
+  const attributeCount = THREE_RENDERED_MORPH_SEMANTICS.reduce(
+    (count, semantic) => Math.max(count, morphAttributes[semantic]?.length ?? 0),
+    0
+  );
+  const influenceCount = mesh.morphTargetInfluences?.length ?? 0;
+  const dictionaryCount = Object.values(mesh.morphTargetDictionary ?? {}).reduce((count, index) => {
+    if (!Number.isInteger(index) || index < 0) {
+      throw new Error(
+        `Mesh "${mesh.name || mesh.uuid}" has an invalid morph target dictionary index: ${index}.`
+      );
+    }
+    return Math.max(count, index + 1);
+  }, 0);
+  return Math.max(attributeCount, influenceCount, dictionaryCount);
+}
+function createNeutralMorphAttribute(mesh, semantic, existingAttributes, targetIndex) {
+  const geometry = mesh.geometry;
+  const baseAttribute = geometry.getAttribute(semantic);
+  const template = baseAttribute ?? existingAttributes.find(Boolean);
+  if (!template) {
+    throw new Error(
+      `Mesh "${mesh.name || mesh.uuid}" cannot repair morph ${semantic}[${targetIndex}] because it has no base or existing attribute to copy.`
+    );
+  }
+  const neutral = template.clone();
+  if (geometry.morphTargetsRelative || !baseAttribute) {
+    for (let vertexIndex = 0; vertexIndex < neutral.count; vertexIndex += 1) {
+      for (let component = 0; component < neutral.itemSize; component += 1) {
+        neutral.setComponent(vertexIndex, component, 0);
+      }
+    }
+  }
+  const targetName = Object.entries(mesh.morphTargetDictionary ?? {}).find(([, index]) => index === targetIndex)?.[0];
+  neutral.name = targetName ?? "";
+  return neutral;
+}
+function normalizeRenderableCharacterMorphAttributes(model) {
+  const repairs = [];
+  model.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh || !mesh.geometry) return;
+    const morphAttributes = mesh.geometry.morphAttributes;
+    const removedEmptyChannels = [];
+    for (const semantic of THREE_RENDERED_MORPH_SEMANTICS) {
+      if (semantic !== "position" && morphAttributes[semantic]?.length === 0) {
+        delete morphAttributes[semantic];
+        removedEmptyChannels.push(semantic);
+      }
+    }
+    const targetCount = resolveMorphTargetCount(mesh);
+    if (targetCount === 0) {
+      if (morphAttributes.position?.length === 0) {
+        delete morphAttributes.position;
+        removedEmptyChannels.push("position");
+      }
+      if (removedEmptyChannels.length > 0) {
+        repairs.push({
+          meshName: mesh.name || mesh.uuid,
+          paddedChannels: {},
+          removedEmptyChannels,
+          paddedInfluences: 0
+        });
+      }
+      return;
+    }
+    const positionCount = mesh.geometry.getAttribute("position")?.count;
+    if (!positionCount) {
+      throw new Error(
+        `Mesh "${mesh.name || mesh.uuid}" has morph targets but no base position attribute.`
+      );
+    }
+    const paddedChannels = {};
+    for (const semantic of THREE_RENDERED_MORPH_SEMANTICS) {
+      let attributes = morphAttributes[semantic];
+      if (!attributes) {
+        if (semantic !== "position") continue;
+        attributes = [];
+        morphAttributes.position = attributes;
+      }
+      const baseAttribute = mesh.geometry.getAttribute(semantic);
+      const referenceAttribute = baseAttribute ?? attributes.find(Boolean);
+      const expectedItemSize = referenceAttribute?.itemSize;
+      for (let targetIndex = 0; targetIndex < targetCount; targetIndex += 1) {
+        const attribute = attributes[targetIndex];
+        if (!attribute) {
+          attributes[targetIndex] = createNeutralMorphAttribute(
+            mesh,
+            semantic,
+            attributes,
+            targetIndex
+          );
+          paddedChannels[semantic] = (paddedChannels[semantic] ?? 0) + 1;
+          continue;
+        }
+        if (attribute.count !== positionCount || attribute.itemSize !== expectedItemSize) {
+          throw new Error(
+            `Mesh "${mesh.name || mesh.uuid}" has an invalid morph ${semantic}[${targetIndex}] (count=${attribute.count}, itemSize=${attribute.itemSize}; expected count=${positionCount}, itemSize=${expectedItemSize}).`
+          );
+        }
+      }
+    }
+    const influences = mesh.morphTargetInfluences ?? [];
+    const paddedInfluences = targetCount - influences.length;
+    while (influences.length < targetCount) {
+      influences.push(0);
+    }
+    mesh.morphTargetInfluences = influences;
+    if (removedEmptyChannels.length > 0 || Object.keys(paddedChannels).length > 0 || paddedInfluences > 0) {
+      repairs.push({
+        meshName: mesh.name || mesh.uuid,
+        paddedChannels,
+        removedEmptyChannels,
+        paddedInfluences
+      });
+    }
+  });
+  return repairs;
+}
+function assertRenderableCharacterMorphAttributes(model) {
+  model.traverse((object) => {
+    const mesh = object;
+    if (!mesh.isMesh) return;
+    const morphAttributes = mesh.geometry?.morphAttributes;
+    const primary = morphAttributes?.position ?? morphAttributes?.normal ?? morphAttributes?.color;
+    const targetCount = primary?.length ?? 0;
+    if (targetCount === 0) return;
+    const positionCount = mesh.geometry.getAttribute("position")?.count;
+    const invalidSemantics = THREE_RENDERED_MORPH_SEMANTICS.filter((semantic) => {
+      const attributes = morphAttributes[semantic];
+      if (semantic === "position" && !attributes) return true;
+      if (!attributes) return false;
+      const expectedItemSize = mesh.geometry.getAttribute(semantic)?.itemSize ?? attributes.find(Boolean)?.itemSize;
+      return attributes.length !== targetCount || Array.from({ length: targetCount }, (_, index) => attributes[index]).some((attribute) => !attribute || attribute.count !== positionCount || attribute.itemSize !== expectedItemSize);
+    });
+    const influenceCount = mesh.morphTargetInfluences?.length ?? 0;
+    if (invalidSemantics.length > 0 || influenceCount !== targetCount) {
+      const channelCounts = THREE_RENDERED_MORPH_SEMANTICS.map((semantic) => `${semantic}=${morphAttributes[semantic]?.length ?? 0}`).join(", ");
+      throw new Error(
+        `Mesh "${mesh.name || mesh.uuid}" has an invalid Three.js morph layout (${channelCounts}, influences=${influenceCount}, expected=${targetCount}).`
+      );
+    }
+  });
+}
 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 } },
@@ -8684,6 +9088,7 @@ function constructDefaultCharacterScene(container, options, renderer, disposeRen
   lifetime.add(disposeRenderer);
   try {
     const sceneType = CHARACTER_SCENE_TYPES[options.type] ?? CHARACTER_SCENE_TYPES.studio;
+    let currentSceneType = sceneType.id;
     const width = Math.max(1, container.clientWidth || globalThis.innerWidth || 1);
     const height = Math.max(1, container.clientHeight || globalThis.innerHeight || 1);
     const ratio = () => Math.min(globalThis.devicePixelRatio || 1, options.pixelRatioCap ?? 1.5);
@@ -8699,12 +9104,32 @@ function constructDefaultCharacterScene(container, options, renderer, disposeRen
     const preset = DEFAULT_CHARACTER_LIGHTING_PRESETS[options.lightingPreset ?? sceneType.lightingPreset]?.settings ?? DEFAULT_CHARACTER_LIGHTING_SETTINGS;
     const lighting = createLighting(scene, { ...preset, ...options.lighting });
     lifetime.add(() => lighting.dispose());
-    const shadowPlane = options.shadowPlane ?? sceneType.shadowPlane ? createShadowPlane(scene, { opacity: lighting.getSettings().shadowOpacity }) : null;
-    if (shadowPlane) {
-      lifetime.add(() => shadowPlane.material.dispose());
-      lifetime.add(() => shadowPlane.geometry.dispose());
-      lifetime.add(() => scene.remove(shadowPlane));
-    }
+    let shadowPlane = null;
+    const ensureShadowPlane = () => {
+      if (shadowPlane) return shadowPlane;
+      const plane = createShadowPlane(scene, { opacity: lighting.getSettings().shadowOpacity });
+      lifetime.add(() => plane.material.dispose());
+      lifetime.add(() => plane.geometry.dispose());
+      lifetime.add(() => scene.remove(plane));
+      shadowPlane = plane;
+      return plane;
+    };
+    if (options.shadowPlane ?? sceneType.shadowPlane) ensureShadowPlane();
+    const setSceneSettings = (value) => {
+      if (lifetime.isDisposed()) return;
+      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);
+      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];
+      lighting.setSettings({ ...preset2.settings, ...value.lighting });
+      renderer.shadowMap.enabled = value.shadows ?? true;
+      const showPlane = value.shadowPlane ?? type.shadowPlane;
+      if (showPlane) ensureShadowPlane();
+      if (shadowPlane) shadowPlane.visible = showPlane;
+    };
     const resize = () => {
       if (lifetime.isDisposed()) return;
       const w = Math.max(1, container.clientWidth || globalThis.innerWidth || 1);
@@ -8714,7 +9139,11 @@ function constructDefaultCharacterScene(container, options, renderer, disposeRen
       renderer.setPixelRatio(ratio());
       renderer.setSize(w, h, false);
     };
-    const handle = { container, scene, renderer, camera, lighting, shadowPlane, sceneType: sceneType.id, ownsScene: true, resize, dispose: lifetime.dispose };
+    const handle = { container, scene, renderer, camera, lighting, get shadowPlane() {
+      return shadowPlane;
+    }, get sceneType() {
+      return currentSceneType;
+    }, ownsScene: true, resize, setSceneSettings, dispose: lifetime.dispose };
     const attach = () => {
       lifetime.add(() => {
         if (renderer.domElement.parentElement === container) container.removeChild(renderer.domElement);
@@ -8847,6 +9276,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
   const lifetime = createDisposer();
   try {
     const sceneType = CHARACTER_SCENE_TYPES[options.type] ?? CHARACTER_SCENE_TYPES.studio;
+    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);
@@ -8854,12 +9284,18 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
     const preset = DEFAULT_CHARACTER_LIGHTING_PRESETS[options.lightingPreset ?? sceneType.lightingPreset]?.settings ?? DEFAULT_CHARACTER_LIGHTING_SETTINGS;
     const lighting = createMutableCharacterLighting(scene, { ...preset, ...options.lighting });
     lifetime.add(lighting.controller.dispose);
-    const shadowPlane = options.shadowPlane ?? sceneType.shadowPlane ? createShadowPlane(scene, { opacity: lighting.controller.getSettings().shadowOpacity }) : null;
-    if (shadowPlane) {
-      lifetime.add(() => shadowPlane.material.dispose());
-      lifetime.add(() => shadowPlane.geometry.dispose());
-      lifetime.add(() => scene.remove(shadowPlane));
-    }
+    let shadowsEnabled = options.shadows ?? true;
+    let shadowPlane = null;
+    const ensureShadowPlane = () => {
+      if (shadowPlane) return shadowPlane;
+      const plane = createShadowPlane(scene, { opacity: lighting.controller.getSettings().shadowOpacity });
+      lifetime.add(() => plane.material.dispose());
+      lifetime.add(() => plane.geometry.dispose());
+      lifetime.add(() => scene.remove(plane));
+      shadowPlane = plane;
+      return plane;
+    };
+    if (options.shadowPlane ?? sceneType.shadowPlane) ensureShadowPlane();
     let settings = { preference: rendererPreference(options.rendering?.preference ?? options.renderer ?? "auto") };
     let active = null;
     let candidateInUse = null;
@@ -8964,7 +9400,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
           candidateInUse = candidate;
           const renderer = candidate.renderer;
           sizeRenderer(renderer, true);
-          renderer.shadowMap.enabled = options.shadows ?? true;
+          renderer.shadowMap.enabled = shadowsEnabled;
           renderer.shadowMap.type = candidate.backend === "webgl" ? PCFShadowMap : PCFSoftShadowMap;
           Object.assign(renderer.domElement.style, { display: "block", width: "100%", height: "100%" });
           if (leaseCount) await leaseBarrier;
@@ -9171,14 +9607,34 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
       else cleanup();
       return disposal;
     };
+    const setSceneSettings = (value) => {
+      if (disposed) return;
+      shadowsEnabled = value.shadows ?? true;
+      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);
+      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];
+      lighting.controller.setSettings({ ...preset2.settings, ...value.lighting });
+      if (active) active.renderer.shadowMap.enabled = value.shadows ?? true;
+      const showPlane = value.shadowPlane ?? type.shadowPlane;
+      if (showPlane) ensureShadowPlane();
+      if (shadowPlane) shadowPlane.visible = showPlane;
+    };
     const ready = setSettings(settings);
     return {
       container,
       scene,
       camera,
       lighting: lighting.controller,
-      shadowPlane,
-      sceneType: sceneType.id,
+      get shadowPlane() {
+        return shadowPlane;
+      },
+      get sceneType() {
+        return currentSceneType;
+      },
       ownsScene: true,
       rendering,
       ready,
@@ -9189,6 +9645,7 @@ function createDefaultCharacterSceneRuntime(container, options = {}) {
         return active?.backend ?? null;
       },
       resize,
+      setSceneSettings,
       dispose
     };
   } catch (failure) {
@@ -9204,7 +9661,9 @@ async function createDefaultCharacterSceneAsync(container, options = {}) {
     const handle = snapshot2.backend === "webgl" ? { ...runtime, renderer: snapshot2.renderer, backend: "webgl" } : { ...runtime, renderer: snapshot2.renderer, backend: "webgpu" };
     Object.defineProperties(handle, {
       renderer: { get: () => runtime.renderer },
-      backend: { get: () => runtime.backend }
+      backend: { get: () => runtime.backend },
+      shadowPlane: { get: () => runtime.shadowPlane },
+      sceneType: { get: () => runtime.sceneType }
     });
     return handle;
   } catch (failure) {
@@ -9224,24 +9683,94 @@ async function createCharacterHost(options) {
   let state;
   let engine;
   let controller;
+  let host;
   let disposed = false;
   let disposal;
   let switching = Promise.resolve();
+  let activeChange;
+  let request3 = 0;
   let mountedCanvas;
-  const aborted = () => new DOMException("Character host creation was aborted", "AbortError");
-  const checkCreation = () => {
-    if (options.signal?.aborted) throw aborted();
+  const previousBackground = options.container.style?.background ?? "";
+  let backgroundRevision = 0;
+  const applyCharacterBackground = (value, character) => {
+    const revision = ++backgroundRevision;
+    const settings = sceneSettings(character);
+    const usePalette = !options.external && settings.background === void 0 && (settings.type === void 0 || settings.type === "studio");
+    if (options.container.style) options.container.style.background = previousBackground;
+    if (!usePalette) return;
+    const background = createSceneInkBackground((css) => {
+      if (!disposed && revision === backgroundRevision && options.container.style) options.container.style.background = css;
+    });
+    const key = character.modelUrl;
+    const materialPalette = resolveCharacterMaterialPalette(value.model, key);
+    background.setPalette(materialPalette);
+    void resolveCharacterTexturePalette(value.model, key).then((palette) => {
+      background.setPalette(palette ?? materialPalette);
+      background.dispose();
+    });
+  };
+  const visibility = /* @__PURE__ */ new WeakMap();
+  const lifetime = new AbortController();
+  const initial = new AbortController();
+  activeChange = initial;
+  const aborted = () => new DOMException("Character host request was cancelled", "AbortError");
+  const cancel = () => {
+    lifetime.abort();
+    activeChange?.abort();
+  };
+  const cancelCreation = () => initial.abort();
+  options.signal?.addEventListener("abort", cancelCreation, { once: true });
+  if (options.signal?.aborted) cancelCreation();
+  const check = (signal) => {
+    if (disposed || lifetime.signal.aborted || signal.aborted) throw aborted();
   };
   const releaseModel = async (value) => {
     const release = () => disposeCharacterModel(state?.scene ?? null, value.model);
     if (state?.rendering) await state.rendering.releaseSceneResources(release);
     else release();
   };
+  const acquireModel = (character, loader, signal) => (options.loadModel ?? loadCharacterModel)(character.modelUrl, { ...loader, signal });
+  const sceneSettings = (character) => {
+    const { background, ...value } = { ...options.scene, ...character.scene };
+    return { ...value, ...background === void 0 ? {} : {
+      background: background && typeof background === "object" ? background.getHex() : background
+    } };
+  };
+  const acquireRenderer = async (signal) => {
+    const rendering = state?.rendering;
+    if (!rendering) return void 0;
+    try {
+      await rendering.setSettings(rendering.getSettings());
+    } catch (error) {
+      if (!rendering.getSnapshot().renderer) throw error;
+    }
+    check(signal);
+    return rendering.acquireRenderer();
+  };
   const makeEngine = (value, character) => {
-    const next = new Embody({ ...options.embody, presetType: character.presetType ?? options.embody?.presetType, profile: character.profile ?? options.embody?.profile });
+    let profile = character.profile ?? options.embody?.profile;
+    let annotationConfig = character.annotationConfig;
+    if (profile) {
+      const bones = [];
+      value.model.traverse((object) => {
+        if (object.isBone && object.name) bones.push({ name: object.name });
+      });
+      const validation = validateMappings(value.meshes, { bones }, profile, { suggestCorrections: true, useResolvedNames: true, minConfidence: 0.8 });
+      if (validation.suggestedConfig && validation.corrections?.some((correction) => correction.applied)) {
+        profile = { ...profile, ...validation.suggestedConfig };
+        if (annotationConfig) annotationConfig = { ...annotationConfig, ...validation.suggestedConfig };
+      }
+    }
+    const resolvedCharacter = { ...character, profile, annotationConfig };
+    const next = new Embody({ ...options.embody, presetType: character.presetType ?? options.embody?.presetType, profile });
     try {
-      next.onReady(value);
-      return next;
+      next.onReady({
+        model: value.model,
+        meshes: value.meshes,
+        ...options.registerEmbeddedAnimations === false ? {} : { animations: value.animations }
+      });
+      next.stop();
+      return { next, character: resolvedCharacter };
     } catch (error) {
       try {
         next.dispose();
@@ -9253,6 +9782,10 @@ async function createCharacterHost(options) {
   const dispose = () => {
     if (disposal) return disposal;
     disposed = true;
+    backgroundRevision += 1;
+    if (options.container.style) options.container.style.background = previousBackground;
+    cancel();
+    options.signal?.removeEventListener("abort", cancelCreation);
     disposal = (async () => {
       let failure;
       const attempt = async (release) => {
@@ -9268,24 +9801,57 @@ async function createCharacterHost(options) {
       await attempt(() => engine?.dispose());
       const ownedScene = !options.external && state && "dispose" in state ? state : void 0;
       if (ownedScene) await attempt(() => ownedScene.dispose());
-      const lastModel = loaded;
-      if (lastModel) await attempt(() => releaseModel(lastModel));
+      if (loaded) await attempt(() => releaseModel(loaded));
       mountedCanvas?.remove();
       if (failure !== void 0) throw failure;
     })();
     return disposal;
   };
+  const prepare2 = async (value, next, character, signal) => {
+    check(signal);
+    state?.setSceneSettings?.(sceneSettings(character));
+    visibility.set(value.model, value.model.visible);
+    value.model.visible = false;
+    value.model.userData.embodyCharacterModel = true;
+    await options.prepareCharacter?.({ ...value, engine: next, character, signal });
+    check(signal);
+    normalizeRenderableCharacterMorphAttributes(value.model);
+    assertRenderableCharacterMorphAttributes(value.model);
+    if (options.prepareCharacter) next.bindModel();
+    value.model.updateMatrixWorld(true);
+    state.scene.add(value.model);
+    if (controller) await controller.prepareModelForRender(value.model, { signal });
+    check(signal);
+  };
+  const frameCharacter = async (value, character) => {
+    if (!controller) return;
+    controller.setModel(value.model);
+    if (character.annotationConfig) controller.prepareRegionsForReveal(character.annotationConfig);
+    else if (options.autoFrame !== false) await controller.focusFullBody(0);
+  };
+  const ready = async (value, next, character, signal) => {
+    await frameCharacter(value, character);
+    check(signal);
+    await options.onCharacterReady?.({
+      ...value,
+      engine: next,
+      character,
+      signal,
+      scene: state.scene,
+      camera: state.camera,
+      cameraController: controller ?? null,
+      rendering: state.rendering ?? null
+    });
+    check(signal);
+  };
   try {
-    checkCreation();
-    loaded = await loadCharacterModel(options.character.modelUrl, options.loader);
-    checkCreation();
-    state = options.external ?? await createDefaultCharacterSceneAsync(options.container, { ...options.scene, signal: options.signal });
-    checkCreation();
+    check(initial.signal);
+    loaded = await acquireModel(options.character, options.loader, initial.signal);
+    check(initial.signal);
+    state = options.external ?? await createDefaultCharacterSceneAsync(options.container, { ...options.scene, ...options.character.scene, signal: initial.signal });
+    check(initial.signal);
     await initEmbodyCore();
-    checkCreation();
-    applyCharacterModelTransform(loaded.model, options.character);
-    state.scene.add(loaded.model);
-    engine = makeEngine(loaded, options.character);
+    check(initial.signal);
     if (options.external?.mountCanvas && !state.renderer.domElement.parentElement) {
       mountedCanvas = state.renderer.domElement;
       options.container.appendChild(mountedCanvas);
@@ -9293,25 +9859,36 @@ async function createCharacterHost(options) {
     if (options.renderLoop ?? !options.external) {
       if (!(state.camera instanceof PerspectiveCamera)) throw new Error("Character host rendering requires a PerspectiveCamera");
       controller = new DPthreeCameraController({
+        ...options.camera,
         scene: state.scene,
         camera: state.camera,
         domElement: state.renderer.domElement,
         ...state.rendering ? { rendering: state.rendering } : { renderer: state.renderer },
-        showDOMControls: false
+        showDOMControls: options.camera?.showDOMControls ?? false
       });
-      controller.setModel(loaded.model);
-      await controller.prepareModelForRender(loaded.model, { signal: options.signal });
-      if (options.autoFrame !== false) await controller.focusFullBody(0);
     }
-    checkCreation();
-    if (options.autoStart === false) engine.stop();
-    else engine.start();
+    applyCharacterModelTransform(loaded.model, options.character);
+    loaded.model.updateMatrixWorld(true);
+    const first = makeEngine(loaded, options.character);
+    engine = first.next;
+    let currentCharacter = first.character;
+    const initialLease = await acquireRenderer(initial.signal);
+    try {
+      await prepare2(loaded, engine, first.character, initial.signal);
+      await ready(loaded, engine, first.character, initial.signal);
+      loaded.model.visible = visibility.get(loaded.model) ?? true;
+      applyCharacterBackground(loaded, first.character);
+    } finally {
+      initialLease?.release();
+    }
+    if (options.autoStart !== false) engine.start();
     const sceneState = state;
     const rendering = state.rendering ?? null;
-    const host = {
+    host = {
       engine,
       scene: state.scene,
       camera: state.camera,
+      cameraController: controller ?? null,
       get renderer() {
         return rendering ? rendering.getSnapshot().renderer : sceneState.renderer;
       },
@@ -9322,68 +9899,92 @@ async function createCharacterHost(options) {
       model: loaded.model,
       meshes: loaded.meshes,
       animations: loaded.animations,
+      gltf: loaded.gltf,
       lighting: "lighting" in state ? state.lighting : null,
       ownsScene: !options.external,
       container: options.container,
       resize() {
         if ("resize" in sceneState) sceneState.resize();
       },
-      setCharacter(character, loader = options.loader) {
-        if (disposed) return Promise.reject(new Error("Character host is disposed"));
+      setCharacter(character, loader = options.loader, signal) {
+        if (disposed || lifetime.signal.aborted) return Promise.reject(aborted());
+        if (!character.modelUrl) return Promise.reject(new Error("setCharacter requires character.modelUrl"));
+        activeChange?.abort();
+        const operation = new AbortController();
+        const abort = () => operation.abort();
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted) abort();
+        activeChange = operation;
+        const generation = ++request3;
         const change = switching.catch(() => {
         }).then(async () => {
-          if (disposed) throw new Error("Character host is disposed");
-          const next = await loadCharacterModel(character.modelUrl, loader);
+          check(operation.signal);
+          if (generation !== request3) throw aborted();
+          const next = await acquireModel(character, loader, operation.signal);
           let nextEngine;
+          let lease = void 0;
+          let cameraChanged = false;
+          let previous;
           try {
-            if (disposed) throw new Error("Character host is disposed");
+            check(operation.signal);
+            lease = await acquireRenderer(operation.signal);
             applyCharacterModelTransform(next.model, character);
-            nextEngine = makeEngine(next, character);
-            nextEngine.stop();
-            sceneState.scene.add(next.model);
-            if (controller) await controller.prepareModelForRender(next.model);
-            if (disposed) throw new Error("Character host is disposed");
-          } catch (error) {
-            try {
-              nextEngine?.dispose();
-            } catch {
-            }
-            try {
-              await releaseModel(next);
-            } catch {
-            }
-            throw error;
-          }
-          const previous = loaded;
-          try {
+            next.model.updateMatrixWorld(true);
+            const prepared = makeEngine(next, character);
+            nextEngine = prepared.next;
+            await prepare2(next, nextEngine, prepared.character, operation.signal);
+            cameraChanged = true;
+            await ready(next, nextEngine, prepared.character, operation.signal);
+            check(operation.signal);
+            previous = loaded;
             engine.dispose();
+            engine = nextEngine;
+            loaded = next;
+            currentCharacter = prepared.character;
+            applyCharacterBackground(next, currentCharacter);
+            host.engine = engine;
+            host.model = next.model;
+            host.meshes = next.meshes;
+            host.animations = next.animations;
+            host.gltf = next.gltf;
+            previous.model.visible = false;
+            next.model.visible = visibility.get(next.model) ?? true;
+            if (options.autoStart !== false) engine.start();
           } catch (error) {
-            try {
-              nextEngine?.dispose();
-            } catch {
-            }
-            try {
-              await releaseModel(next);
-            } catch {
+            if (loaded !== next) {
+              try {
+                state?.setSceneSettings?.(sceneSettings(currentCharacter));
+              } catch {
+              }
+              if (cameraChanged && !disposed && controller && loaded) {
+                try {
+                  await frameCharacter(loaded, currentCharacter);
+                } catch {
+                }
+              }
+              try {
+                nextEngine?.dispose();
+              } catch {
+              }
+              lease?.release();
+              lease = void 0;
+              try {
+                await releaseModel(next);
+              } catch {
+              }
             }
             throw error;
+          } finally {
+            lease?.release();
           }
-          engine = nextEngine;
-          loaded = next;
-          host.engine = engine;
-          host.model = next.model;
-          host.meshes = next.meshes;
-          host.animations = next.animations;
-          controller?.setModel(next.model);
-          if (options.autoStart !== false) engine.start();
-          await releaseModel(previous);
-          if (controller && options.autoFrame !== false) await controller.focusFullBody(0);
+          if (previous) await releaseModel(previous);
         });
-        switching = change;
-        return change;
+        switching = change.finally(() => signal?.removeEventListener("abort", abort));
+        return switching;
       },
       dispose
     };
+    options.signal?.removeEventListener("abort", cancelCreation);
     return host;
   } catch (error) {
     try {
@@ -9393,6 +9994,1072 @@ async function createCharacterHost(options) {
     throw error;
   }
 }
+var COLORS = {
+  mapped: 4889258,
+  unmapped: 5925498,
+  highlighted: 13934656,
+  selected: 6534125
+};
+var OPACITY = {
+  mapped: 0.58,
+  unmapped: 0.38,
+  highlighted: 0.7,
+  selected: 0.8,
+  context: 0.46,
+  muted: 0.16
+};
+var AXIS_GIZMO_COLORS = {
+  pitch: 16743004,
+  yaw: 6410389,
+  roll: 6924543
+};
+var AXIS_GIZMO_IDLE_OPACITY = 0.72;
+var AXIS_GIZMO_MUTED_OPACITY = 0.26;
+var AXIS_GIZMO_ACTIVE_OPACITY = 0.96;
+var AXIS_GIZMO_RADIUS_FACTOR = 0.48;
+var AXIS_GIZMO_MIN_RADIUS = 0.025;
+var AXIS_GIZMO_MAX_RADIUS = 0.14;
+var AXIS_GIZMO_SCREEN_RADIUS_PX = 54;
+var AXIS_GIZMO_ACTIVE_SCALE = 1.05;
+var AXIS_GIZMO_HIT_TUBE = 0.15;
+var VISIBILITY_FADE_MS = 180;
+var VISIBILITY_EPSILON = 0.01;
+var LEAF_BONE_LENGTH = 0.02;
+var WIDTH_RATIO = 0.1;
+var MID_POSITION = 0.2;
+var ROOT_HELPER_NAME_PATTERN = /armature|bone.?root|rootjoint|(?:^|[_\W])root(?:$|[_\W])/i;
+var HIP_NAME_PATTERN = /(?:^|[_\W])hip(?:$|[_\W]|\d)/i;
+var PELVIS_NAME_PATTERN = /(?:^|[_\W])pelvis(?:$|[_\W]|\d)/i;
+var POSITION_EPSILON = 1e-4;
+var DEFAULT_AXIS_CHANNELS = {
+  pitch: "rx",
+  yaw: "ry",
+  roll: "rz"
+};
+function createOctahedralBoneGeometry() {
+  const w = WIDTH_RATIO;
+  const positions = new Float32Array([
+    // Face 0: root → mid1 → mid2
+    0,
+    0,
+    0,
+    w,
+    w,
+    MID_POSITION,
+    -w,
+    w,
+    MID_POSITION,
+    // Face 1: root → mid2 → mid3
+    0,
+    0,
+    0,
+    -w,
+    w,
+    MID_POSITION,
+    -w,
+    -w,
+    MID_POSITION,
+    // Face 2: root → mid3 → mid4
+    0,
+    0,
+    0,
+    -w,
+    -w,
+    MID_POSITION,
+    w,
+    -w,
+    MID_POSITION,
+    // Face 3: root → mid4 → mid1
+    0,
+    0,
+    0,
+    w,
+    -w,
+    MID_POSITION,
+    w,
+    w,
+    MID_POSITION,
+    // Face 4: tip → mid2 → mid1
+    0,
+    0,
+    1,
+    -w,
+    w,
+    MID_POSITION,
+    w,
+    w,
+    MID_POSITION,
+    // Face 5: tip → mid3 → mid2
+    0,
+    0,
+    1,
+    -w,
+    -w,
+    MID_POSITION,
+    -w,
+    w,
+    MID_POSITION,
+    // Face 6: tip → mid4 → mid3
+    0,
+    0,
+    1,
+    w,
+    -w,
+    MID_POSITION,
+    -w,
+    -w,
+    MID_POSITION,
+    // Face 7: tip → mid1 → mid4
+    0,
+    0,
+    1,
+    w,
+    w,
+    MID_POSITION,
+    w,
+    -w,
+    MID_POSITION
+  ]);
+  const geometry = new THREE3.BufferGeometry();
+  geometry.setAttribute("position", new THREE3.BufferAttribute(positions, 3));
+  geometry.computeVertexNormals();
+  return geometry;
+}
+function collectBones(root) {
+  const bones = /* @__PURE__ */ new Set();
+  root.traverse((obj) => {
+    if (obj.isBone) {
+      bones.add(obj);
+    }
+    if (obj.isSkinnedMesh) {
+      const skinned = obj;
+      skinned.skeleton?.bones?.forEach((bone) => bones.add(bone));
+    }
+  });
+  return Array.from(bones);
+}
+function isBone2(obj) {
+  return !!obj && obj.isBone;
+}
+function countBoneSubtree(bone) {
+  let count = 1;
+  for (const child of bone.children) {
+    if (isBone2(child)) {
+      count += countBoneSubtree(child);
+    }
+  }
+  return count;
+}
+function resolveTopLevelHelperRoot(root) {
+  const topLevelBones = collectBones(root).filter((bone) => !isBone2(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);
+    if (boneChildren.length !== 1) break;
+    const onlyChild = boneChildren[0];
+    if (!ROOT_HELPER_NAME_PATTERN.test(onlyChild.name)) break;
+    helperRoot = onlyChild;
+  }
+  return ROOT_HELPER_NAME_PATTERN.test(helperRoot.name) ? helperRoot : null;
+}
+function resolveBodyDisplayRoot(root) {
+  const helperRoot = resolveTopLevelHelperRoot(root);
+  if (!helperRoot) return null;
+  const boneChildren = helperRoot.children.filter(isBone2);
+  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);
+  const [largest, secondLargest] = subtreeSizes;
+  if (!largest || largest.size < 3) return null;
+  if (!secondLargest || secondLargest.size <= 2 || largest.size >= secondLargest.size * 3) {
+    return largest.child;
+  }
+  return null;
+}
+function collectBoneChildren(bone) {
+  return bone.children.filter(isBone2);
+}
+function hasZeroLengthConnection(parentBone, childBone) {
+  parentBone.getWorldPosition(_parentPos);
+  childBone.getWorldPosition(_childPos);
+  return _parentPos.distanceToSquared(_childPos) <= POSITION_EPSILON * POSITION_EPSILON;
+}
+function hasRootHelperAncestor(bone) {
+  let current = bone.parent;
+  while (isBone2(current)) {
+    if (ROOT_HELPER_NAME_PATTERN.test(current.name)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+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;
+    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);
+}
+function setRayFromPointer(clientX, clientY, camera, domElement) {
+  const rect = domElement.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) return false;
+  _mouse.x = (clientX - rect.left) / rect.width * 2 - 1;
+  _mouse.y = -((clientY - rect.top) / rect.height) * 2 + 1;
+  _raycaster.setFromCamera(_mouse, camera);
+  return true;
+}
+var _parentPos = new THREE3.Vector3();
+var _childPos = new THREE3.Vector3();
+var _direction = new THREE3.Vector3();
+var _zAxis = new THREE3.Vector3(0, 0, 1);
+var _quaternion = new THREE3.Quaternion();
+var _bonePos = new THREE3.Vector3();
+var _boneQuat = new THREE3.Quaternion();
+var _boneEuler = new THREE3.Euler();
+var _mouse = new THREE3.Vector2();
+var _raycaster = new THREE3.Raycaster();
+var _cameraSpacePosition = new THREE3.Vector3();
+var _planeNormal = new THREE3.Vector3();
+var _dragPlane = new THREE3.Plane();
+var _planeHit = new THREE3.Vector3();
+function resolveSkeletonOverlayStartBoneName(root) {
+  return resolveBodyDisplayRoot(root)?.name ?? null;
+}
+var SkeletonOverlay = class {
+  constructor(scene, mappedBoneNames, semanticKeyMap, options = {}) {
+    __publicField(this, "scene");
+    __publicField(this, "group");
+    __publicField(this, "visualizations", []);
+    __publicField(this, "boneTree", []);
+    __publicField(this, "mappedBoneNames");
+    __publicField(this, "semanticKeyMap");
+    // boneName → semanticKey
+    __publicField(this, "boneLookup", /* @__PURE__ */ new Map());
+    // Shared geometry and materials
+    __publicField(this, "sharedGeometry");
+    __publicField(this, "mappedMaterial");
+    __publicField(this, "unmappedMaterial");
+    __publicField(this, "highlightMaterial");
+    __publicField(this, "selectedMaterial");
+    __publicField(this, "contextMaterial");
+    __publicField(this, "mutedMaterial");
+    __publicField(this, "axisRingGeometry");
+    __publicField(this, "axisRingHitGeometry");
+    __publicField(this, "axisCenterGeometry");
+    __publicField(this, "pitchRingMaterial");
+    __publicField(this, "yawRingMaterial");
+    __publicField(this, "rollRingMaterial");
+    __publicField(this, "axisHitMaterial");
+    __publicField(this, "axisCenterMaterial");
+    __publicField(this, "axisGizmoGroup");
+    __publicField(this, "axisGizmoMeshes");
+    __publicField(this, "axisGizmoHitMeshes");
+    // Sentinel mesh for per-frame updates (stored for disposal)
+    __publicField(this, "sentinelMesh", null);
+    // State
+    __publicField(this, "highlightedBone", null);
+    __publicField(this, "selectedBone", null);
+    __publicField(this, "activeAxis", null);
+    __publicField(this, "opacityScale");
+    __publicField(this, "focusSelectedBone");
+    __publicField(this, "visibilityAlpha", 0);
+    __publicField(this, "visibilityTarget", 0);
+    __publicField(this, "visibilityLastFrameAt", 0);
+    this.scene = scene;
+    this.mappedBoneNames = mappedBoneNames;
+    this.semanticKeyMap = semanticKeyMap;
+    this.opacityScale = THREE3.MathUtils.clamp(options.opacityScale ?? 1, 0, 1);
+    this.focusSelectedBone = options.focusSelectedBone ?? false;
+    this.group = new THREE3.Group();
+    this.group.name = "SkeletonOverlay";
+    this.group.renderOrder = 999;
+    this.group.visible = false;
+    this.sharedGeometry = createOctahedralBoneGeometry();
+    const materialOpts = {
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      side: THREE3.DoubleSide
+    };
+    this.mappedMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: COLORS.mapped, opacity: OPACITY.mapped });
+    this.unmappedMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: COLORS.unmapped, opacity: OPACITY.unmapped });
+    this.highlightMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: COLORS.highlighted, opacity: OPACITY.highlighted });
+    this.selectedMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: COLORS.selected, opacity: OPACITY.selected });
+    this.contextMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: COLORS.selected, opacity: OPACITY.context });
+    this.mutedMaterial = new THREE3.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 THREE3.TorusGeometry(1, 0.032, 10, 120);
+    this.axisRingHitGeometry = new THREE3.TorusGeometry(1, AXIS_GIZMO_HIT_TUBE, 8, 64);
+    this.axisCenterGeometry = new THREE3.SphereGeometry(0.082, 12, 8);
+    this.pitchRingMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.pitch, opacity: AXIS_GIZMO_IDLE_OPACITY });
+    this.yawRingMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.yaw, opacity: AXIS_GIZMO_IDLE_OPACITY });
+    this.rollRingMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: AXIS_GIZMO_COLORS.roll, opacity: AXIS_GIZMO_IDLE_OPACITY });
+    this.axisHitMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, opacity: 0 });
+    this.axisHitMaterial.colorWrite = false;
+    this.axisCenterMaterial = new THREE3.MeshBasicMaterial({ ...materialOpts, color: 16119802, opacity: 0.92 });
+    this.axisGizmoGroup = new THREE3.Group();
+    this.axisGizmoGroup.name = "SelectedBoneAxisGizmo";
+    this.axisGizmoGroup.visible = false;
+    this.axisGizmoGroup.renderOrder = 1e3;
+    const pitchRing = new THREE3.Mesh(this.axisRingGeometry, this.pitchRingMaterial);
+    pitchRing.renderOrder = 1e3;
+    pitchRing.userData.axis = "pitch";
+    const pitchHit = new THREE3.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
+    pitchHit.userData.axis = "pitch";
+    const yawRing = new THREE3.Mesh(this.axisRingGeometry, this.yawRingMaterial);
+    yawRing.renderOrder = 1e3;
+    yawRing.userData.axis = "yaw";
+    const yawHit = new THREE3.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
+    yawHit.userData.axis = "yaw";
+    const rollRing = new THREE3.Mesh(this.axisRingGeometry, this.rollRingMaterial);
+    rollRing.renderOrder = 1e3;
+    rollRing.userData.axis = "roll";
+    const rollHit = new THREE3.Mesh(this.axisRingHitGeometry, this.axisHitMaterial);
+    rollHit.rotation.copy(rollRing.rotation);
+    rollHit.userData.axis = "roll";
+    const center = new THREE3.Mesh(this.axisCenterGeometry, this.axisCenterMaterial);
+    center.renderOrder = 1001;
+    this.axisGizmoMeshes = {
+      pitch: pitchRing,
+      yaw: yawRing,
+      roll: rollRing
+    };
+    this.axisGizmoHitMeshes = {
+      pitch: pitchHit,
+      yaw: yawHit,
+      roll: rollHit
+    };
+    Object.values(this.axisGizmoMeshes).forEach((mesh) => {
+      mesh.frustumCulled = false;
+      this.axisGizmoGroup.add(mesh);
+    });
+    Object.values(this.axisGizmoHitMeshes).forEach((mesh) => {
+      mesh.frustumCulled = false;
+      this.axisGizmoGroup.add(mesh);
+    });
+    center.frustumCulled = false;
+    this.axisGizmoGroup.add(center);
+    this.syncAxisGizmoChannels();
+    this.syncVisibilityOpacity();
+    this.updateAxisGizmoAppearance();
+  }
+  /**
+   * Build the skeleton visualization from a scene root.
+   * Traverses to find all THREE.Bone instances and creates octahedral meshes.
+   */
+  loadSkeleton(root) {
+    this.clear();
+    root.updateWorldMatrix(true, true);
+    const allBones = collectSkeletonBones(root);
+    const includedBones = new Set(allBones);
+    this.boneLookup = new Map(allBones.map((bone) => [bone.name, bone]));
+    if (allBones.length === 0) return;
+    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;
+      let depth = 0;
+      let current = bone.parent;
+      while (current && isBone2(current) && includedBones.has(current)) {
+        depth++;
+        current = current.parent;
+      }
+      return {
+        name: bone.name,
+        depth,
+        parent: parentName,
+        children: boneChildren,
+        isMapped,
+        semanticKey,
+        boneObject: bone
+      };
+    });
+    for (const bone of allBones) {
+      const boneChildren = bone.children.filter(
+        (c) => isBone2(c) && includedBones.has(c)
+      );
+      if (boneChildren.length > 0) {
+        if (shouldSkipRootHelperConnection(bone, boneChildren)) {
+          continue;
+        }
+        for (const child of boneChildren) {
+          this.createBoneMesh(bone, child);
+        }
+      } else {
+        this.createBoneMesh(bone, null);
+      }
+    }
+    this.group.add(this.axisGizmoGroup);
+    const sentinelGeo = new THREE3.SphereGeometry(1e-6, 4, 2);
+    const sentinelMat = new THREE3.MeshBasicMaterial({
+      transparent: true,
+      opacity: 0,
+      depthWrite: false,
+      depthTest: false
+    });
+    sentinelMat.colorWrite = false;
+    const sentinel = new THREE3.Mesh(sentinelGeo, sentinelMat);
+    sentinel.visible = true;
+    sentinel.frustumCulled = false;
+    sentinel.onBeforeRender = (renderer, _scene, camera) => this.update(camera, renderer.domElement);
+    this.sentinelMesh = sentinel;
+    this.group.add(sentinel);
+    this.scene.add(this.group);
+    this.update();
+  }
+  createBoneMesh(parentBone, childBone) {
+    const isMapped = this.mappedBoneNames.has(parentBone.name);
+    const material = isMapped ? this.mappedMaterial : this.unmappedMaterial;
+    const mesh = new THREE3.Mesh(this.sharedGeometry, material);
+    mesh.name = `bone_vis_${parentBone.name}${childBone ? `_${childBone.name}` : "_leaf"}`;
+    mesh.frustumCulled = false;
+    mesh.renderOrder = 999;
+    mesh.userData.boneName = parentBone.name;
+    this.visualizations.push({
+      mesh,
+      parentBone,
+      childBone,
+      boneName: parentBone.name,
+      isMapped
+    });
+    this.group.add(mesh);
+  }
+  /** Called each frame via onBeforeRender. Updates all bone mesh transforms. */
+  update(camera, domElement) {
+    this.advanceVisibility();
+    for (const vis of this.visualizations) {
+      vis.parentBone.getWorldPosition(_parentPos);
+      if (vis.childBone) {
+        vis.childBone.getWorldPosition(_childPos);
+      } else {
+        _childPos.set(0, LEAF_BONE_LENGTH, 0);
+        vis.parentBone.localToWorld(_childPos);
+      }
+      _direction.subVectors(_childPos, _parentPos);
+      const length = _direction.length();
+      if (length < 1e-4) {
+        vis.mesh.visible = false;
+        continue;
+      }
+      vis.mesh.visible = this.visibilityAlpha > VISIBILITY_EPSILON;
+      _direction.normalize();
+      _quaternion.setFromUnitVectors(_zAxis, _direction);
+      vis.mesh.position.copy(_parentPos);
+      vis.mesh.quaternion.copy(_quaternion);
+      vis.mesh.scale.set(length, length, length);
+    }
+    this.updateAxisGizmo(camera, domElement);
+  }
+  syncVisibilityOpacity() {
+    const alpha = this.visibilityAlpha * this.opacityScale;
+    this.mappedMaterial.opacity = OPACITY.mapped * alpha;
+    this.unmappedMaterial.opacity = OPACITY.unmapped * alpha;
+    this.highlightMaterial.opacity = OPACITY.highlighted * alpha;
+    this.selectedMaterial.opacity = OPACITY.selected * alpha;
+    this.contextMaterial.opacity = OPACITY.context * alpha;
+    this.mutedMaterial.opacity = OPACITY.muted * alpha;
+  }
+  syncGroupVisibility() {
+    this.group.visible = this.visualizations.length > 0 && (this.visibilityTarget > 0 || this.visibilityAlpha > VISIBILITY_EPSILON || this.selectedBone != null);
+  }
+  advanceVisibility() {
+    const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const deltaMs = this.visibilityLastFrameAt > 0 ? now - this.visibilityLastFrameAt : 16;
+    this.visibilityLastFrameAt = now;
+    if (Math.abs(this.visibilityAlpha - this.visibilityTarget) > VISIBILITY_EPSILON) {
+      const step = deltaMs / VISIBILITY_FADE_MS;
+      if (this.visibilityTarget > this.visibilityAlpha) {
+        this.visibilityAlpha = Math.min(this.visibilityTarget, this.visibilityAlpha + step);
+      } else {
+        this.visibilityAlpha = Math.max(this.visibilityTarget, this.visibilityAlpha - step);
+      }
+    } else {
+      this.visibilityAlpha = this.visibilityTarget;
+    }
+    if (this.visibilityAlpha <= VISIBILITY_EPSILON && this.visibilityTarget === 0) {
+      this.visibilityAlpha = 0;
+    }
+    this.syncVisibilityOpacity();
+    this.syncGroupVisibility();
+  }
+  resolveSelectedBoneObject() {
+    if (!this.selectedBone) return null;
+    return this.boneLookup.get(this.selectedBone) ?? null;
+  }
+  resolveBoneRelativeAxisGizmoRadius(bone) {
+    bone.getWorldPosition(_parentPos);
+    let referenceLength = 0;
+    for (const child of bone.children) {
+      if (!isBone2(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)) {
+      bone.parent.getWorldPosition(_childPos);
+      referenceLength = _parentPos.distanceTo(_childPos);
+    }
+    if (referenceLength <= 1e-4) {
+      referenceLength = LEAF_BONE_LENGTH;
+    }
+    return THREE3.MathUtils.clamp(
+      referenceLength * AXIS_GIZMO_RADIUS_FACTOR,
+      AXIS_GIZMO_MIN_RADIUS,
+      AXIS_GIZMO_MAX_RADIUS
+    );
+  }
+  resolveScreenSpaceAxisGizmoRadius(origin, camera, domElement) {
+    if (!camera || !domElement) return null;
+    const rect = domElement.getBoundingClientRect();
+    const viewportHeight = domElement.clientHeight || rect.height;
+    if (viewportHeight <= 0) return null;
+    if (camera.isPerspectiveCamera) {
+      const perspectiveCamera = camera;
+      _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(THREE3.MathUtils.degToRad(perspectiveCamera.getEffectiveFOV()) / 2);
+      return visibleWorldHeight * (AXIS_GIZMO_SCREEN_RADIUS_PX / viewportHeight);
+    }
+    if (camera.isOrthographicCamera) {
+      const orthographicCamera = camera;
+      const visibleWorldHeight = (orthographicCamera.top - orthographicCamera.bottom) / orthographicCamera.zoom;
+      return visibleWorldHeight * (AXIS_GIZMO_SCREEN_RADIUS_PX / viewportHeight);
+    }
+    return null;
+  }
+  resolveAxisGizmoRadius(bone, origin, camera, domElement) {
+    return this.resolveScreenSpaceAxisGizmoRadius(origin, camera, domElement) ?? this.resolveBoneRelativeAxisGizmoRadius(bone);
+  }
+  updateAxisGizmoAppearance() {
+    const hasSelection = !!this.selectedBone;
+    this.axisGizmoGroup.visible = hasSelection && this.group.visible;
+    const meshes = [
+      ["pitch", this.axisGizmoMeshes.pitch, this.axisGizmoHitMeshes.pitch],
+      ["yaw", this.axisGizmoMeshes.yaw, this.axisGizmoHitMeshes.yaw],
+      ["roll", this.axisGizmoMeshes.roll, this.axisGizmoHitMeshes.roll]
+    ];
+    meshes.forEach(([axis, mesh, hitMesh]) => {
+      const material = mesh.material;
+      const isActive = this.activeAxis === axis;
+      const baseOpacity = this.activeAxis == null ? AXIS_GIZMO_IDLE_OPACITY : isActive ? AXIS_GIZMO_ACTIVE_OPACITY : AXIS_GIZMO_MUTED_OPACITY;
+      material.opacity = hasSelection ? baseOpacity : 0;
+      const scale = isActive ? AXIS_GIZMO_ACTIVE_SCALE : 1;
+      mesh.scale.setScalar(scale);
+      hitMesh.scale.setScalar(scale);
+    });
+    this.axisCenterMaterial.opacity = hasSelection ? 0.92 : 0;
+  }
+  updateAxisGizmo(camera, domElement) {
+    const selectedBone = this.resolveSelectedBoneObject();
+    if (!selectedBone || !this.group.visible) {
+      this.axisGizmoGroup.visible = false;
+      return;
+    }
+    selectedBone.getWorldPosition(_bonePos);
+    selectedBone.getWorldQuaternion(_boneQuat);
+    const radius = this.resolveAxisGizmoRadius(selectedBone, _bonePos, camera, domElement);
+    this.axisGizmoGroup.visible = true;
+    this.axisGizmoGroup.position.copy(_bonePos);
+    this.axisGizmoGroup.quaternion.copy(_boneQuat);
+    this.axisGizmoGroup.scale.setScalar(radius);
+    this.updateAxisGizmoAppearance();
+    this.axisGizmoGroup.updateWorldMatrix(true, true);
+  }
+  applyAxisRingChannel(mesh, hitMesh, axis) {
+    const channel = DEFAULT_AXIS_CHANNELS[axis];
+    mesh.rotation.set(0, 0, 0);
+    hitMesh.rotation.set(0, 0, 0);
+    if (channel === "rx") {
+      mesh.rotation.y = Math.PI / 2;
+      hitMesh.rotation.y = Math.PI / 2;
+      return;
+    }
+    if (channel === "ry") {
+      mesh.rotation.x = Math.PI / 2;
+      hitMesh.rotation.x = Math.PI / 2;
+    }
+  }
+  syncAxisGizmoChannels() {
+    Object.keys(this.axisGizmoMeshes).forEach((axis) => {
+      this.applyAxisRingChannel(
+        this.axisGizmoMeshes[axis],
+        this.axisGizmoHitMeshes[axis],
+        axis
+      );
+    });
+  }
+  getSelectedBonePointerData() {
+    const bone = this.resolveSelectedBoneObject();
+    if (!bone || !this.selectedBone) return null;
+    bone.getWorldPosition(_bonePos);
+    bone.getWorldQuaternion(_boneQuat);
+    return {
+      boneName: this.selectedBone,
+      origin: _bonePos.clone(),
+      quaternion: _boneQuat.clone()
+    };
+  }
+  getAxisPlaneNormal(axis, quaternion) {
+    const channel = DEFAULT_AXIS_CHANNELS[axis];
+    if (channel === "rx") {
+      return _planeNormal.set(1, 0, 0).applyQuaternion(quaternion).normalize();
+    }
+    if (channel === "ry") {
+      return _planeNormal.set(0, 1, 0).applyQuaternion(quaternion).normalize();
+    }
+    return _planeNormal.set(0, 0, 1).applyQuaternion(quaternion).normalize();
+  }
+  // ── Public API ─────────────────────────────────────────────────────────
+  getBoneTree() {
+    return this.boneTree;
+  }
+  setVisible(visible) {
+    this.visibilityTarget = visible ? 1 : 0;
+    this.visibilityLastFrameAt = 0;
+    this.syncGroupVisibility();
+    this.advanceVisibility();
+    this.updateAxisGizmoAppearance();
+  }
+  isVisible() {
+    return this.visibilityTarget > 0;
+  }
+  setHighlighted(boneName) {
+    this.highlightedBone = boneName;
+    this.refreshBoneMaterials();
+  }
+  setSelected(boneName) {
+    this.selectedBone = boneName;
+    this.refreshBoneMaterials();
+    this.syncGroupVisibility();
+    this.updateAxisGizmo();
+  }
+  setActiveAxis(axis) {
+    this.activeAxis = axis;
+    this.updateAxisGizmoAppearance();
+  }
+  /** Get world position and rotation for a bone by name */
+  getBoneTransform(boneName) {
+    const node = this.boneTree.find((b) => b.name === boneName);
+    if (!node) return null;
+    const bone = node.boneObject;
+    bone.getWorldPosition(_bonePos);
+    bone.getWorldQuaternion(_boneQuat);
+    _boneEuler.setFromQuaternion(_boneQuat);
+    return {
+      position: [_bonePos.x, _bonePos.y, _bonePos.z],
+      rotation: [
+        THREE3.MathUtils.radToDeg(_boneEuler.x),
+        THREE3.MathUtils.radToDeg(_boneEuler.y),
+        THREE3.MathUtils.radToDeg(_boneEuler.z)
+      ]
+    };
+  }
+  pickBone(clientX, clientY, camera, domElement) {
+    if (!this.group.visible || this.visibilityTarget <= 0 || this.visibilityAlpha <= 0.35) {
+      return null;
+    }
+    if (!setRayFromPointer(clientX, clientY, camera, domElement)) {
+      return null;
+    }
+    const hits = _raycaster.intersectObjects(
+      this.visualizations.map((visualization) => visualization.mesh),
+      false
+    );
+    const hit = hits[0];
+    if (!hit) return null;
+    return typeof hit.object.userData.boneName === "string" ? hit.object.userData.boneName : null;
+  }
+  pickAxisGizmo(clientX, clientY, camera, domElement) {
+    if (!this.axisGizmoGroup.visible || !this.selectedBone) return null;
+    this.updateAxisGizmo(camera, domElement);
+    if (!this.axisGizmoGroup.visible) return null;
+    if (!setRayFromPointer(clientX, clientY, camera, domElement)) {
+      return null;
+    }
+    const hits = _raycaster.intersectObjects(Object.values(this.axisGizmoHitMeshes), false);
+    const hit = hits[0];
+    if (!hit) return null;
+    const axis = hit.object.userData.axis;
+    if (axis !== "pitch" && axis !== "yaw" && axis !== "roll") {
+      return null;
+    }
+    const base = this.getSelectedBonePointerData();
+    if (!base) return null;
+    return {
+      ...base,
+      axis,
+      channel: DEFAULT_AXIS_CHANNELS[axis],
+      point: hit.point.clone()
+    };
+  }
+  projectPointerToAxisPlane(clientX, clientY, camera, domElement, axis) {
+    if (!this.axisGizmoGroup.visible || !this.selectedBone) {
+      return null;
+    }
+    this.updateAxisGizmo(camera, domElement);
+    if (!this.axisGizmoGroup.visible) return null;
+    const base = this.getSelectedBonePointerData();
+    if (!base) return null;
+    if (!setRayFromPointer(clientX, clientY, camera, domElement)) {
+      return null;
+    }
+    const normal = this.getAxisPlaneNormal(axis, base.quaternion);
+    _dragPlane.setFromNormalAndCoplanarPoint(normal, base.origin);
+    const hit = _raycaster.ray.intersectPlane(_dragPlane, _planeHit);
+    if (!hit) return null;
+    return {
+      ...base,
+      axis,
+      channel: DEFAULT_AXIS_CHANNELS[axis],
+      point: hit.clone()
+    };
+  }
+  isSelectedContextBone(boneName) {
+    if (!this.selectedBone || boneName === this.selectedBone) return false;
+    const selectedBone = this.boneLookup.get(this.selectedBone);
+    const bone = this.boneLookup.get(boneName);
+    if (!selectedBone || !bone) return false;
+    return bone.parent === selectedBone || selectedBone.parent === bone;
+  }
+  resolveBoneMaterial(boneName, isMapped) {
+    if (boneName === this.selectedBone) {
+      return this.selectedMaterial;
+    }
+    if (boneName === this.highlightedBone) {
+      return this.highlightMaterial;
+    }
+    if (this.focusSelectedBone && this.selectedBone) {
+      return this.isSelectedContextBone(boneName) ? this.contextMaterial : this.mutedMaterial;
+    }
+    return isMapped ? this.mappedMaterial : this.unmappedMaterial;
+  }
+  refreshBoneMaterials() {
+    for (const vis of this.visualizations) {
+      vis.mesh.material = this.resolveBoneMaterial(vis.boneName, vis.isMapped);
+    }
+  }
+  clear() {
+    if (this.sentinelMesh) {
+      this.sentinelMesh.geometry.dispose();
+      this.sentinelMesh.material.dispose();
+      this.sentinelMesh = null;
+    }
+    while (this.group.children.length > 0) {
+      this.group.remove(this.group.children[0]);
+    }
+    this.visualizations = [];
+    this.boneTree = [];
+    this.boneLookup.clear();
+    this.axisGizmoGroup.visible = false;
+    this.group.visible = false;
+  }
+  dispose() {
+    this.scene.remove(this.group);
+    this.clear();
+    this.sharedGeometry.dispose();
+    this.mappedMaterial.dispose();
+    this.unmappedMaterial.dispose();
+    this.highlightMaterial.dispose();
+    this.selectedMaterial.dispose();
+    this.contextMaterial.dispose();
+    this.mutedMaterial.dispose();
+    this.axisRingGeometry.dispose();
+    this.axisRingHitGeometry.dispose();
+    this.axisCenterGeometry.dispose();
+    this.pitchRingMaterial.dispose();
+    this.yawRingMaterial.dispose();
+    this.rollRingMaterial.dispose();
+    this.axisHitMaterial.dispose();
+    this.axisCenterMaterial.dispose();
+  }
+};
+function collectSkeletonBones(root) {
+  const startBone = resolveBodyDisplayRoot(root);
+  return collectBones(startBone ?? root);
+}
+function findModelRoot(scene) {
+  const roots = {};
+  scene.traverse((obj) => {
+    if (!roots.tagged && (obj.userData?.embodyCharacterModel === true || obj.userData?.loomlargeCharacterModel === true)) {
+      roots.tagged = obj;
+    }
+    if (!roots.bone && obj.isBone) {
+      roots.bone = obj;
+    }
+    if (!roots.skinned && obj.isSkinnedMesh) {
+      roots.skinned = obj;
+    }
+  });
+  if (roots.tagged) return roots.tagged;
+  const anchor = roots.bone ?? roots.skinned;
+  if (!anchor) return null;
+  let current = anchor;
+  while (current && current.parent && current.parent !== scene) {
+    current = current.parent;
+  }
+  return current;
+}
+function buildMappedBoneInfo(profile, actualBoneNames = []) {
+  const mappedNames = /* @__PURE__ */ new Set();
+  const semanticKeyMap = /* @__PURE__ */ new Map();
+  const semanticKeysMap = /* @__PURE__ */ new Map();
+  const actualNames = Array.from(new Set(actualBoneNames));
+  const boneNodes = profile.boneNodes || {};
+  const prefix = profile.bonePrefix || "";
+  const suffix = profile.boneSuffix || "";
+  const addSemanticKey = (boneName, semanticKey) => {
+    mappedNames.add(boneName);
+    if (!semanticKeyMap.has(boneName)) {
+      semanticKeyMap.set(boneName, semanticKey);
+    }
+    const existing = semanticKeysMap.get(boneName) ?? [];
+    if (!existing.includes(semanticKey)) {
+      semanticKeysMap.set(boneName, [...existing, semanticKey]);
+    }
+  };
+  for (const [semanticKey, nodeName] of Object.entries(boneNodes)) {
+    const fullName = prefix + nodeName + suffix;
+    addSemanticKey(fullName, semanticKey);
+    if (fullName !== nodeName) {
+      addSemanticKey(nodeName, semanticKey);
+    }
+    actualNames.forEach((actualName) => {
+      if (fuzzyNameMatch(actualName, fullName, profile.suffixPattern) || fuzzyNameMatch(actualName, nodeName, profile.suffixPattern)) {
+        addSemanticKey(actualName, semanticKey);
+      }
+    });
+  }
+  return { mappedNames, semanticKeyMap, semanticKeysMap };
+}
+var DEFAULT_THRESHOLD = 1e-4;
+var DEFAULT_MAX_POINTS = 12e3;
+var COLOR_LOW = { r: 1, g: 0.78, b: 0.28 };
+var COLOR_HIGH = { r: 1, g: 0.36, b: 0.16 };
+function getMorphPositionAttribute2(mesh, morphName) {
+  const morphIndex = mesh.morphTargetDictionary?.[morphName];
+  if (morphIndex == null) return null;
+  const morphPositions = mesh.geometry.morphAttributes.position;
+  return morphPositions?.[morphIndex] ?? null;
+}
+function getDeltaMagnitudeAtIndex(mesh, morphAttribute, index) {
+  const geometry = mesh.geometry;
+  const relative = geometry.morphTargetsRelative;
+  const basePositions = geometry.getAttribute("position");
+  if (!basePositions) return 0;
+  const dx = morphAttribute.getX(index) - (relative ? 0 : basePositions.getX(index));
+  const dy = morphAttribute.getY(index) - (relative ? 0 : basePositions.getY(index));
+  const dz = morphAttribute.getZ(index) - (relative ? 0 : basePositions.getZ(index));
+  return Math.hypot(dx, dy, dz);
+}
+function resolveMorphPreviewMeshes(root, morphName, meshNames) {
+  const nameFilter = meshNames?.length ? new Set(meshNames) : null;
+  const meshes = [];
+  root.traverse((obj) => {
+    const mesh = obj;
+    if (!mesh.isMesh) return;
+    if (nameFilter && !nameFilter.has(mesh.name)) return;
+    if (mesh.morphTargetDictionary?.[morphName] == null) return;
+    meshes.push(mesh);
+  });
+  return meshes;
+}
+function buildMorphVertexPreviewSample(mesh, morphName, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const maxPoints = options.maxPoints ?? DEFAULT_MAX_POINTS;
+  const morphAttribute = getMorphPositionAttribute2(mesh, morphName);
+  if (!morphAttribute) return null;
+  const candidateIndices = [];
+  const magnitudes = [];
+  for (let index = 0; index < morphAttribute.count; index += 1) {
+    const magnitude = getDeltaMagnitudeAtIndex(mesh, morphAttribute, index);
+    if (magnitude <= threshold) continue;
+    candidateIndices.push(index);
+    magnitudes.push(magnitude);
+  }
+  if (candidateIndices.length === 0) return null;
+  const stride = candidateIndices.length > maxPoints ? Math.ceil(candidateIndices.length / maxPoints) : 1;
+  const sampleCount = Math.ceil(candidateIndices.length / stride);
+  const indices = new Uint32Array(sampleCount);
+  const intensities = new Float32Array(sampleCount);
+  let maxMagnitude = 0;
+  let cursor = 0;
+  for (let i = 0; i < candidateIndices.length; i += stride) {
+    const magnitude = magnitudes[i] ?? 0;
+    indices[cursor] = candidateIndices[i] ?? 0;
+    intensities[cursor] = magnitude;
+    maxMagnitude = Math.max(maxMagnitude, magnitude);
+    cursor += 1;
+  }
+  const normalizer = maxMagnitude > 0 ? 1 / maxMagnitude : 1;
+  for (let i = 0; i < intensities.length; i += 1) {
+    intensities[i] *= normalizer;
+  }
+  return { indices, intensities };
+}
+function writePointColor(colors, offset, intensity2) {
+  colors[offset] = COLOR_LOW.r + (COLOR_HIGH.r - COLOR_LOW.r) * 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 = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const maxPoints = options.maxPoints ?? DEFAULT_MAX_POINTS;
+  const sampledMeshes = [];
+  let pointCount = 0;
+  for (const mesh of meshes) {
+    const cacheKey = `${mesh.uuid}:${morphName}:${threshold}:${maxPoints}`;
+    let sample = cache.get(cacheKey) ?? null;
+    if (!sample) {
+      sample = buildMorphVertexPreviewSample(mesh, morphName, { threshold, maxPoints });
+      if (sample) cache.set(cacheKey, sample);
+    }
+    if (!sample) continue;
+    sampledMeshes.push({ mesh, sample });
+    pointCount += sample.indices.length;
+  }
+  if (pointCount === 0) return null;
+  const positions = new Float32Array(pointCount * 3);
+  const colors = new Float32Array(pointCount * 3);
+  const vertex = new THREE3.Vector3();
+  let cursor = 0;
+  for (const { mesh, sample } of sampledMeshes) {
+    mesh.updateWorldMatrix(true, false);
+    const skinnedMesh = mesh;
+    if (skinnedMesh.isSkinnedMesh && skinnedMesh.skeleton) {
+      skinnedMesh.skeleton.update();
+    }
+    for (let i = 0; i < sample.indices.length; i += 1) {
+      mesh.getVertexPosition(sample.indices[i] ?? 0, vertex);
+      vertex.applyMatrix4(mesh.matrixWorld);
+      const offset = cursor * 3;
+      positions[offset] = vertex.x;
+      positions[offset + 1] = vertex.y;
+      positions[offset + 2] = vertex.z;
+      writePointColor(colors, offset, sample.intensities[i] ?? 0);
+      cursor += 1;
+    }
+  }
+  return {
+    positions,
+    colors,
+    pointCount,
+    meshCount: sampledMeshes.length
+  };
+}
+var previewRenderBindings = /* @__PURE__ */ new WeakMap();
+function bindPreviewRender(scene, update) {
+  let binding = previewRenderBindings.get(scene);
+  if (!binding) {
+    const previous = scene.onBeforeRender;
+    const callbacks = /* @__PURE__ */ new Set();
+    const render = function(...args) {
+      previous.apply(scene, args);
+      callbacks.forEach((callback) => callback());
+    };
+    binding = { callbacks, previous, render };
+    scene.onBeforeRender = render;
+    previewRenderBindings.set(scene, binding);
+  }
+  binding.callbacks.add(update);
+  const current = binding;
+  return () => {
+    current.callbacks.delete(update);
+    if (current.callbacks.size > 0) return;
+    if (scene.onBeforeRender === current.render) scene.onBeforeRender = current.previous;
+    if (previewRenderBindings.get(scene) === current) previewRenderBindings.delete(scene);
+  };
+}
+var MorphVertexPreview = class {
+  constructor(scene, options = {}) {
+    this.scene = scene;
+    this.options = options;
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "points", null);
+    __publicField(this, "active", null);
+    __publicField(this, "disposed", false);
+    __publicField(this, "unbindRender", null);
+  }
+  show(morphName, meshNames) {
+    if (this.disposed) return;
+    if (meshNames?.length === 0) {
+      this.hide();
+      return;
+    }
+    this.active = { morphName, meshNames: meshNames?.slice() };
+    this.unbindRender ?? (this.unbindRender = bindPreviewRender(this.scene, () => this.update()));
+    this.update();
+  }
+  hide() {
+    this.active = null;
+    this.unbindRender?.();
+    this.unbindRender = null;
+    if (this.points) this.points.visible = false;
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.hide();
+    this.cache.clear();
+    if (!this.points) return;
+    this.points.removeFromParent();
+    this.points.geometry.dispose();
+    this.points.material.dispose();
+    this.points = null;
+  }
+  createPoints() {
+    const points = new THREE3.Points(new THREE3.BufferGeometry(), new THREE3.PointsMaterial({
+      size: 0.012,
+      sizeAttenuation: true,
+      transparent: true,
+      opacity: 0.9,
+      depthWrite: false,
+      vertexColors: true,
+      toneMapped: false
+    }));
+    points.name = "MorphVertexPreviewPoints";
+    points.renderOrder = 500;
+    points.frustumCulled = false;
+    points.visible = false;
+    this.scene.add(points);
+    this.points = points;
+    return points;
+  }
+  update() {
+    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);
+    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);
+    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 THREE3.BufferAttribute(values, 3));
+      return;
+    }
+    attribute.array.set(values);
+    attribute.needsUpdate = true;
+  }
+};
 
 // three/index.ts
 var THREE_BLENDING_MODES = {
@@ -9404,7 +11071,7 @@ var THREE_BLENDING_MODES = {
 };
 var BLENDING_MODES = THREE_BLENDING_MODES;
 var MORPH_ATTRIBUTE_SEMANTICS = ["position", "normal", "tangent", "color"];
-var createNeutralMorphAttribute = (geometry, semantic, name) => {
+var createNeutralMorphAttribute2 = (geometry, semantic, name) => {
   const base = geometry.getAttribute(semantic);
   if (!base) throw new Error(`Cannot create ${semantic} morph data without a base attribute`);
   const values = new Float32Array(base.count * base.itemSize);
@@ -9915,7 +11582,7 @@ var ThreeFrameApplier = class {
             sourceIsRelative
           );
         } else if (!attributes[targetIndex] || targetIndex === index) {
-          attributes[targetIndex] = createNeutralMorphAttribute(
+          attributes[targetIndex] = createNeutralMorphAttribute2(
             geometry,
             semantic,
             targetIndex === index ? target.name : `morph_${targetIndex}`
@@ -9958,6 +11625,6 @@ var collectMorphMeshes = (root) => {
   return meshes;
 };
 
-export { BLENDING_MODES, CHARACTER_SCENE_TYPES, CHARACTER_SCENE_TYPE_IDS, DPthreeCameraController as CameraController, CameraDOMControls, CameraDOMControls as Controls, DEFAULT_CHARACTER_LIGHTING_PRESETS, DEFAULT_CHARACTER_LIGHTING_PRESET_ID, DEFAULT_CHARACTER_LIGHTING_PRESET_IDS, DEFAULT_CHARACTER_LIGHTING_SETTINGS, DEFAULT_CHARACTER_SCENE_TYPE_ID, DEFAULT_MARKER_AUTO_HIDE_MS, DEFAULT_PREVIEW_AUTO_CLEAR_MS, DPthree, DPthree3DMarkers, DPthreeCameraController, DPthreeHTMLMarkers, DPthreeMarkers, Embody, DPthree3DMarkers as Markers3D, DPthreeHTMLMarkers as MarkersHTML, RUNTIME_ANNOTATION_REGION_PREFIX, RustAnnotationCameraCore, THREE_BLENDING_MODES, ThreeFrameApplier, ThreeModelInspector, ThreeNativePlaybackConnector, analyzeModel, applyAUBoneBindingUpdate, applyBilateralAxisBindingUpdate, applyBoneAxisBindingUpdate, applyCharacterModelTransform, bindModelReferencePose, boneResolutionProfile, buildBoneAuOptions, buildRegionDisplayOptions, captureModelReferencePose, classifyAuAsJointControl, collectMorphMeshes, computeHumanoidSkeletonTemplateRestBounds, createAnimationClipFromClipIR, createBilateralBoneAxisAu, createBoneAxisAu, createCharacterHost, createDefaultCharacterLighting, createDefaultCharacterScene, createDefaultCharacterSceneAsync, createDefaultCharacterSceneRuntime, createMarkerLifecycleRevealOptions, createMarkerVisibilityLifecycle, createRuntimeAnnotationPreviewLifecycle, createRustAnnotationCameraCore, createRustEmbodyHost, createRustEmbodyHostUnbound, createScenePlaybackFrame, createShadowPlane, createValidationSkeletonFromHumanoidTemplate, detectAnnotationLaterality, disposeCharacterModel, ensureBilateralBoneNodeKeys, ensureBoneNodeKey, extendCharacterConfigWithPreset, extendModelReferencePose, extractHumanoidSkeletonTemplateFromModel, extractModelData, extractProfileOverrides, filterCameraViewRegions, findNodeKeyForBone, formatAxisDirectionLabel, formatAxisLabel, fuzzyNameMatch, getAUBoneBindingState, getAxisFromChannel, getBilateralAxisBindingState, getBoneAxisBindingState, getDefaultAnnotationLaterality, getHumanoidSkeletonTemplate, getHumanoidSkeletonTemplateBoneNames, getHumanoidSpecification, getMeshNamesForAUProfile, getModelLocalOrbitAngle, getPreset, getRuntimeAUMeshSideOffset, getRuntimeAUMorphAnchorPoint, getRuntimeAnnotationSide, getSemanticHorizontalSign, getSemanticHorizontalSignForSide, getWorldDirectionForCameraAngle, hasLeftRightMorphs, inferChiralBoneNamePair, inferEyeControlFamily, inferEyeControlScope, inferRuntimeAnnotationPreviewSide, isJointControlAuInfo, isMaxDegreesOnlyAxisBindingUpdate, isMixedAU, isRuntimeAnnotationRegionName, loadCharacterModel, mergeCharacterRegionsByName, normalizeDefaultCharacterLightingSettings, normalizeHairColorAppearance, parseCharacterModel, passesMarkerCameraAngleGate, pickContinuumAnnotationAuId, renderScenePlayback, resolveAnnotationCharacterConfig, resolveBoneAxisChannel, resolveBoneNameForNodeKey, resolveBoneNames, resolveContinuumDisplayLabel, resolveFaceCenter, resolveHumanoidCharacterization, resolveMarkerAnchorRegion, resolveRegionCameraAngle, resolveRegionVisibilityCameraAngle, resolveVisemeProfile, serializeAnimationClips, setAUMorphTargets, setHumanoidRoleBinding, shouldProjectMarkerAnchorToSurface, shouldUseFaceCenterForMarkerAnchor, stripConfiguredBoneAffixes, supportsRustEmbodyPreset, toWorldDirection, validateHumanoidCharacterization, validateMappings };
+export { BLENDING_MODES, CHARACTER_SCENE_TYPES, CHARACTER_SCENE_TYPE_IDS, DPthreeCameraController as CameraController, CameraDOMControls, CameraDOMControls as Controls, DEFAULT_CHARACTER_LIGHTING_PRESETS, DEFAULT_CHARACTER_LIGHTING_PRESET_ID, DEFAULT_CHARACTER_LIGHTING_PRESET_IDS, DEFAULT_CHARACTER_LIGHTING_SETTINGS, DEFAULT_CHARACTER_SCENE_TYPE_ID, DEFAULT_MARKER_AUTO_HIDE_MS, DEFAULT_PREVIEW_AUTO_CLEAR_MS, DPthree, DPthree3DMarkers, DPthreeCameraController, DPthreeHTMLMarkers, DPthreeMarkers, Embody, DPthree3DMarkers as Markers3D, DPthreeHTMLMarkers as MarkersHTML, MorphVertexPreview, RUNTIME_ANNOTATION_REGION_PREFIX, RustAnnotationCameraCore, SkeletonOverlay, THREE_BLENDING_MODES, 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 };
 //# sourceMappingURL=three.js.map
 //# sourceMappingURL=three.js.map