talking-head-studio 0.4.10 → 0.4.12

package/dist/core/avatar/schema.d.ts

@@ -0,0 +1,78 @@
+import type { OculusViseme } from './visemes';
+export type VisemeTier = 'oculus' | 'arkit' | 'minimal' | 'none';
+/** @deprecated Use VisemeTier. */
+export type VísemeTier = VisemeTier;
+export interface MorphCoverage {
+    /** All morph target names found across all meshes in the scene. */
+    all: string[];
+    /** Oculus viseme morph targets present (subset of OCULUS_VISEMES). */
+    oculusVisemes: OculusViseme[];
+    /** Whether the full Oculus set (all 15) is present. */
+    hasFullOculusSet: boolean;
+    /** ARKit blend shape names found (jawOpen, mouthFunnel, etc.). */
+    arkitShapes: string[];
+    /** Whether a meaningful ARKit set is present (≥10 mouth shapes). */
+    hasArkitSet: boolean;
+    /** Best lip-sync strategy available for this model. */
+    visemeTier: VisemeTier;
+}
+export interface SkeletonInfo {
+    /** Whether a skeleton (SkinnedMesh) was found. */
+    hasRig: boolean;
+    /** All bone names found in the scene. */
+    bones: string[];
+    /** Whether the standard humanoid bones are present (hips → spine → head). */
+    isHumanoid: boolean;
+    /** Missing standard humanoid bones (if any). */
+    missingHumanoidBones: string[];
+}
+export interface MeshStats {
+    /** Total triangle count across all meshes. */
+    triangles: number;
+    /** Number of distinct mesh primitives. */
+    meshCount: number;
+    /** Estimated LOD tier based on triangle count. */
+    lodTier: 'high' | 'medium' | 'low' | 'very-low';
+}
+export interface AvatarSchemaReport {
+    morphs: MorphCoverage;
+    skeleton: SkeletonInfo;
+    mesh: MeshStats;
+    /** Whether this model is ready for full-quality talking-head rendering. */
+    isReadyForLipSync: boolean;
+}
+/** Minimal scene shape needed by the GLB schema walker. */
+interface AvatarSchemaScene {
+    traverse: (cb: (obj: AvatarSchemaObject) => void) => void;
+}
+/** Minimal traversed object shape used to avoid depending on runtime Three.js classes. */
+interface AvatarSchemaObject {
+    isSkinnedMesh?: boolean;
+    isBone?: boolean;
+    isMesh?: boolean;
+    name?: string;
+    skeleton?: {
+        bones?: Array<{
+            name?: string;
+        }>;
+    };
+    morphTargetDictionary?: Record<string, unknown>;
+    geometry?: {
+        index?: {
+            count: number;
+        };
+        attributes?: {
+            position?: {
+                count: number;
+            };
+        };
+    };
+}
+/**
+ * Scan a loaded Three.js Object3D scene and return a structured compatibility
+ * report for lip-sync, skeleton, and mesh quality.
+ *
+ * @param scene - The root Object3D from a GLTFLoader result (gltf.scene)
+ */
+export declare function walkAvatarSchema(scene: AvatarSchemaScene): AvatarSchemaReport;
+export {};

package/dist/core/avatar/schema.js

@@ -0,0 +1,134 @@
+"use strict";
+// src/core/avatar/schema.ts
+// GLB schema walker — scan any loaded Three.js scene and report morph target
+// coverage, skeleton bones, viseme tier, and LOD stats.
+//
+// Use this to gate rendering decisions ("does this model need the ARKit remap?"),
+// power the avatar creator's "compatibility report", and feed the Unity/Unreal
+// SDK manifests.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkAvatarSchema = walkAvatarSchema;
+const visemes_1 = require("./visemes");
+// ─── Constants ───────────────────────────────────────────────────────────────
+// Minimum humanoid bones expected on any rigged avatar.
+const REQUIRED_HUMANOID_BONES = [
+    'Hips', 'Spine', 'Head', 'Neck',
+    'LeftUpperArm', 'RightUpperArm',
+    'LeftUpperLeg', 'RightUpperLeg',
+];
+// ARKit mouth shapes that indicate a real ARKit rig (not just jawOpen).
+const ARKIT_MOUTH_SHAPES = [
+    'jawOpen', 'mouthFunnel', 'mouthPucker', 'mouthSmileLeft', 'mouthSmileRight',
+    'mouthFrownLeft', 'mouthFrownRight', 'mouthStretchLeft', 'mouthStretchRight',
+    'mouthRollLower', 'mouthRollUpper', 'mouthShrugLower', 'mouthShrugUpper',
+    'mouthLowerDownLeft', 'mouthLowerDownRight', 'mouthUpperUpLeft', 'mouthUpperUpRight',
+    'mouthClose', 'mouthDimpleLeft', 'mouthDimpleRight', 'mouthPressLeft', 'mouthPressRight',
+];
+// ─── Walker ──────────────────────────────────────────────────────────────────
+/**
+ * Scan a loaded Three.js Object3D scene and return a structured compatibility
+ * report for lip-sync, skeleton, and mesh quality.
+ *
+ * @param scene - The root Object3D from a GLTFLoader result (gltf.scene)
+ */
+function walkAvatarSchema(scene) {
+    const allMorphNames = new Set();
+    const boneNames = new Set();
+    let hasRig = false;
+    let totalTris = 0;
+    let meshCount = 0;
+    scene.traverse((obj) => {
+        // Collect bone names from SkinnedMesh skeletons
+        if (obj.isSkinnedMesh) {
+            hasRig = true;
+            if (obj.skeleton?.bones) {
+                for (const bone of obj.skeleton.bones) {
+                    if (bone.name)
+                        boneNames.add(bone.name);
+                }
+            }
+        }
+        // Also collect from Bone objects directly
+        if (obj.isBone && obj.name) {
+            boneNames.add(obj.name);
+        }
+        // Collect morph targets and mesh stats
+        if (obj.isMesh && obj.morphTargetDictionary) {
+            for (const name of Object.keys(obj.morphTargetDictionary)) {
+                allMorphNames.add(name);
+            }
+        }
+        if (obj.isMesh && obj.geometry) {
+            meshCount++;
+            const geo = obj.geometry;
+            if (geo.index) {
+                totalTris += geo.index.count / 3;
+            }
+            else if (geo.attributes?.position) {
+                totalTris += geo.attributes.position.count / 3;
+            }
+        }
+    });
+    // ── Morph analysis ───────────────────────────────────────────────────────
+    const allMorphList = Array.from(allMorphNames);
+    const allLower = allMorphList.map(n => n.toLowerCase());
+    // Oculus visemes: look for viseme_PP, viseme_aa, etc.
+    const oculusFound = [];
+    for (const v of visemes_1.OCULUS_VISEMES) {
+        const target = `viseme_${v}`.toLowerCase();
+        if (allLower.some(n => n === target || n === v.toLowerCase())) {
+            oculusFound.push(v);
+        }
+    }
+    const hasFullOculusSet = oculusFound.length === visemes_1.OCULUS_VISEMES.length;
+    // ARKit shapes
+    const arkitFound = ARKIT_MOUTH_SHAPES.filter(shape => allLower.some(n => n === shape.toLowerCase()));
+    const hasArkitSet = arkitFound.length >= 10;
+    // Minimal: just jawOpen or mouthOpen
+    const hasMinimal = allLower.some(n => n === 'jawopen' || n === 'mouthopen' || n === 'viseme_aa');
+    let visemeTier;
+    if (hasFullOculusSet)
+        visemeTier = 'oculus';
+    else if (hasArkitSet)
+        visemeTier = 'arkit';
+    else if (hasMinimal)
+        visemeTier = 'minimal';
+    else
+        visemeTier = 'none';
+    // ── Skeleton analysis ────────────────────────────────────────────────────
+    const bonesLower = Array.from(boneNames).map(b => b.toLowerCase());
+    const missingHumanoidBones = REQUIRED_HUMANOID_BONES.filter(required => !bonesLower.some(b => b.includes(required.toLowerCase())));
+    const isHumanoid = hasRig && missingHumanoidBones.length === 0;
+    // ── Mesh stats ───────────────────────────────────────────────────────────
+    let lodTier;
+    if (totalTris > 70000)
+        lodTier = 'high';
+    else if (totalTris > 30000)
+        lodTier = 'medium';
+    else if (totalTris > 8000)
+        lodTier = 'low';
+    else
+        lodTier = 'very-low';
+    return {
+        morphs: {
+            all: allMorphList,
+            oculusVisemes: oculusFound,
+            hasFullOculusSet,
+            arkitShapes: arkitFound,
+            hasArkitSet,
+            visemeTier,
+        },
+        skeleton: {
+            hasRig,
+            bones: Array.from(boneNames),
+            isHumanoid,
+            missingHumanoidBones,
+        },
+        mesh: {
+            triangles: Math.round(totalTris),
+            meshCount,
+            lodTier,
+        },
+        isReadyForLipSync: visemeTier === 'oculus' || visemeTier === 'arkit',
+    };
+}

package/dist/core/avatar/visemes.d.ts

@@ -2,11 +2,12 @@
  * Standard viseme keys supported by the avatar (Oculus set).
  */
 export type OculusViseme = 'sil' | 'PP' | 'FF' | 'TH' | 'DD' | 'kk' | 'CH' | 'SS' | 'nn' | 'RR' | 'aa' | 'ee' | 'ih' | 'oh' | 'ou';
+export type RhubarbViseme = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'X';
 /** Rhubarb mouth shape cue (Preston Blair set: A-H, X) */
 export interface VisemeCue {
     startMs: number;
     endMs: number;
-    viseme: 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'X';
+    viseme: RhubarbViseme;
     weight?: number;
 }
 /**
@@ -31,3 +32,48 @@ export interface AgentVisemePayload {
     cues: VisemeCue[];
 }
 export declare const OCULUS_VISEMES: OculusViseme[];
+export declare const RHUBARB_VISEMES: RhubarbViseme[];
+export declare const OCULUS_MORPH_TARGET_NAMES: Record<OculusViseme, string>;
+export type OculusVisemeWeights = Partial<Record<OculusViseme, number>>;
+export declare const RHUBARB_TO_OCULUS: Record<RhubarbViseme, OculusVisemeWeights>;
+export type ArkitBlendShape = 'jawOpen' | 'jawForward' | 'jawLeft' | 'jawRight' | 'mouthClose' | 'mouthFunnel' | 'mouthPucker' | 'mouthLeft' | 'mouthRight' | 'mouthSmileLeft' | 'mouthSmileRight' | 'mouthFrownLeft' | 'mouthFrownRight' | 'mouthDimpleLeft' | 'mouthDimpleRight' | 'mouthStretchLeft' | 'mouthStretchRight' | 'mouthRollLower' | 'mouthRollUpper' | 'mouthShrugLower' | 'mouthShrugUpper' | 'mouthPressLeft' | 'mouthPressRight' | 'mouthLowerDownLeft' | 'mouthLowerDownRight' | 'mouthUpperUpLeft' | 'mouthUpperUpRight' | 'tongueOut';
+/**
+ * Each Oculus viseme expressed as a weighted combination of ARKit blend shapes.
+ * Weights are in 0–1 range. Apply by multiplying each ARKit shape's influence.
+ *
+ * Sources:
+ * - OVR LipSync viseme reference (phonetic articulation targets)
+ * - Empirical tuning against RPM and face-squeeze avatars
+ */
+export declare const ARKIT_TO_OCULUS: Record<OculusViseme, Partial<Record<ArkitBlendShape, number>>>;
+export type EngineVisemeMappingArtifact = {
+    schemaVersion: 1;
+    rhubarbVisemes: RhubarbViseme[];
+    oculusVisemes: OculusViseme[];
+    oculusMorphTargetNames: Record<OculusViseme, string>;
+    rhubarbToOculus: Record<RhubarbViseme, OculusVisemeWeights>;
+    oculusToArkit: Record<OculusViseme, Partial<Record<ArkitBlendShape, number>>>;
+};
+export declare const ENGINE_VISEME_MAPPING: EngineVisemeMappingArtifact;
+export declare function oculusWeightsForRhubarbCue(cue: Pick<VisemeCue, 'viseme' | 'weight'>): Record<OculusViseme, number>;
+/**
+ * Remap a set of ARKit blend shape weights to Oculus viseme weights.
+ *
+ * Given current ARKit influences (e.g. from face tracking or morph target state),
+ * returns the equivalent Oculus viseme weights. Each viseme's output weight is the
+ * weighted average of its constituent ARKit shapes, clamped to 0–1.
+ *
+ * Use cases:
+ * - Runtime: drive Oculus viseme morphs from ARKit face tracking data
+ * - Bake-time: compute Oculus morph target deltas from ARKit shape keys in a GLB
+ */
+export declare function remapArkitToOculus(arkitWeights: Partial<Record<ArkitBlendShape, number>>): Record<OculusViseme, number>;
+/**
+ * For a given Oculus viseme, return the ARKit blend shape weights that produce it.
+ * This is the "forward" direction — useful when baking Oculus morph targets into
+ * a GLB that only has ARKit shapes.
+ *
+ * Returns the raw recipe weights (not normalized). To bake into a morph target,
+ * set each ARKit shape to the returned weight and snapshot the mesh delta.
+ */
+export declare function getArkitWeightsForViseme(viseme: OculusViseme): Partial<Record<ArkitBlendShape, number>>;

package/dist/core/avatar/visemes.js

@@ -1,6 +1,119 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OCULUS_VISEMES = void 0;
+exports.ENGINE_VISEME_MAPPING = exports.ARKIT_TO_OCULUS = exports.RHUBARB_TO_OCULUS = exports.OCULUS_MORPH_TARGET_NAMES = exports.RHUBARB_VISEMES = exports.OCULUS_VISEMES = void 0;
+exports.oculusWeightsForRhubarbCue = oculusWeightsForRhubarbCue;
+exports.remapArkitToOculus = remapArkitToOculus;
+exports.getArkitWeightsForViseme = getArkitWeightsForViseme;
 exports.OCULUS_VISEMES = [
     'sil', 'PP', 'FF', 'TH', 'DD', 'kk', 'CH', 'SS', 'nn', 'RR', 'aa', 'ee', 'ih', 'oh', 'ou',
 ];
+exports.RHUBARB_VISEMES = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'X'];
+exports.OCULUS_MORPH_TARGET_NAMES = {
+    sil: 'viseme_sil',
+    PP: 'viseme_PP',
+    FF: 'viseme_FF',
+    TH: 'viseme_TH',
+    DD: 'viseme_DD',
+    kk: 'viseme_kk',
+    CH: 'viseme_CH',
+    SS: 'viseme_SS',
+    nn: 'viseme_nn',
+    RR: 'viseme_RR',
+    aa: 'viseme_aa',
+    ee: 'viseme_ee',
+    ih: 'viseme_ih',
+    oh: 'viseme_oh',
+    ou: 'viseme_ou',
+};
+exports.RHUBARB_TO_OCULUS = {
+    A: { aa: 0.72 },
+    B: { PP: 0.85 },
+    C: { ih: 0.68 },
+    D: { FF: 0.78 },
+    E: { ee: 0.72 },
+    F: { oh: 0.62 },
+    G: { ou: 0.58 },
+    H: { nn: 0.72 },
+    X: { sil: 1 },
+};
+/**
+ * Each Oculus viseme expressed as a weighted combination of ARKit blend shapes.
+ * Weights are in 0–1 range. Apply by multiplying each ARKit shape's influence.
+ *
+ * Sources:
+ * - OVR LipSync viseme reference (phonetic articulation targets)
+ * - Empirical tuning against RPM and face-squeeze avatars
+ */
+exports.ARKIT_TO_OCULUS = {
+    sil: { mouthClose: 0.1 },
+    PP: { mouthClose: 0.8, mouthPucker: 0.3 },
+    FF: { mouthLowerDownLeft: 0.5, mouthLowerDownRight: 0.5, mouthRollLower: 0.4 },
+    TH: { tongueOut: 0.6, jawOpen: 0.15, mouthLowerDownLeft: 0.2, mouthLowerDownRight: 0.2 },
+    DD: { mouthShrugUpper: 0.5, jawOpen: 0.2, mouthUpperUpLeft: 0.3, mouthUpperUpRight: 0.3 },
+    kk: { jawOpen: 0.25, mouthStretchLeft: 0.4, mouthStretchRight: 0.4, mouthShrugUpper: 0.2 },
+    CH: { mouthStretchLeft: 0.5, mouthStretchRight: 0.5, jawOpen: 0.3, mouthFunnel: 0.2 },
+    SS: { mouthStretchLeft: 0.35, mouthStretchRight: 0.35, mouthClose: 0.3 },
+    nn: { jawOpen: 0.15, mouthDimpleLeft: 0.4, mouthDimpleRight: 0.4, mouthShrugLower: 0.2 },
+    RR: { mouthPucker: 0.4, mouthFunnel: 0.3, jawOpen: 0.15, mouthRollLower: 0.2 },
+    aa: { jawOpen: 0.7, mouthLowerDownLeft: 0.4, mouthLowerDownRight: 0.4 },
+    ee: { mouthSmileLeft: 0.6, mouthSmileRight: 0.6, jawOpen: 0.2 },
+    ih: { mouthSmileLeft: 0.4, mouthSmileRight: 0.4, jawOpen: 0.1 },
+    oh: { jawOpen: 0.4, mouthFunnel: 0.8 },
+    ou: { mouthPucker: 0.9, mouthRollLower: 0.3 },
+};
+exports.ENGINE_VISEME_MAPPING = {
+    schemaVersion: 1,
+    rhubarbVisemes: exports.RHUBARB_VISEMES,
+    oculusVisemes: exports.OCULUS_VISEMES,
+    oculusMorphTargetNames: exports.OCULUS_MORPH_TARGET_NAMES,
+    rhubarbToOculus: exports.RHUBARB_TO_OCULUS,
+    oculusToArkit: exports.ARKIT_TO_OCULUS,
+};
+function oculusWeightsForRhubarbCue(cue) {
+    const weight = Math.max(0, Math.min(1, cue.weight ?? 1));
+    const result = Object.fromEntries(exports.OCULUS_VISEMES.map((viseme) => [viseme, 0]));
+    const mapping = exports.RHUBARB_TO_OCULUS[cue.viseme];
+    for (const [viseme, value] of Object.entries(mapping)) {
+        result[viseme] = Math.max(0, Math.min(1, value * weight));
+    }
+    return result;
+}
+/**
+ * Remap a set of ARKit blend shape weights to Oculus viseme weights.
+ *
+ * Given current ARKit influences (e.g. from face tracking or morph target state),
+ * returns the equivalent Oculus viseme weights. Each viseme's output weight is the
+ * weighted average of its constituent ARKit shapes, clamped to 0–1.
+ *
+ * Use cases:
+ * - Runtime: drive Oculus viseme morphs from ARKit face tracking data
+ * - Bake-time: compute Oculus morph target deltas from ARKit shape keys in a GLB
+ */
+function remapArkitToOculus(arkitWeights) {
+    const result = {};
+    for (const viseme of exports.OCULUS_VISEMES) {
+        const recipe = exports.ARKIT_TO_OCULUS[viseme];
+        let sum = 0;
+        let coeffSum = 0;
+        for (const [shape, coeff] of Object.entries(recipe)) {
+            const input = arkitWeights[shape] ?? 0;
+            sum += input * coeff;
+            coeffSum += coeff;
+        }
+        // Normalize by total coefficient weight so recipes with more shapes
+        // don't produce disproportionately high output
+        result[viseme] = coeffSum > 0 ? Math.min(1, Math.max(0, sum / coeffSum)) : 0;
+    }
+    return result;
+}
+/**
+ * For a given Oculus viseme, return the ARKit blend shape weights that produce it.
+ * This is the "forward" direction — useful when baking Oculus morph targets into
+ * a GLB that only has ARKit shapes.
+ *
+ * Returns the raw recipe weights (not normalized). To bake into a morph target,
+ * set each ARKit shape to the returned weight and snapshot the mesh delta.
+ */
+function getArkitWeightsForViseme(viseme) {
+    return { ...exports.ARKIT_TO_OCULUS[viseme] };
+}

package/dist/editor/AvatarCanvas.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvatarCanvas = void 0;
+exports.AvatarCanvas = AvatarCanvas;
 const jsx_runtime_1 = require("react/jsx-runtime");
 // @ts-nocheck
+/* eslint-disable @typescript-eslint/no-explicit-any -- R3F pointer events and Three.js scene internals are intentionally dynamic in this editor bridge. */
 const drei_1 = require("@react-three/drei");
 const fiber_1 = require("@react-three/fiber");
 const react_1 = require("react");
@@ -10,6 +11,96 @@ const AvatarCanvasErrorBoundary_1 = require("./AvatarCanvasErrorBoundary");
 const AvatarModel_1 = require("./AvatarModel");
 const RigidAccessory_1 = require("./RigidAccessory");
 const SkinnedClothing_1 = require("./SkinnedClothing");
+function DirectTransform({ activeAssetId, placements, onPlacementChange }) {
+    const { gl } = (0, fiber_1.useThree)();
+    (0, react_1.useEffect)(() => {
+        const canvas = gl.domElement;
+        let dragging = false;
+        let lastX = 0;
+        let lastY = 0;
+        function isModified(e) {
+            return e.shiftKey || e.ctrlKey || e.metaKey;
+        }
+        function onPointerDown(e) {
+            if (!activeAssetId || !isModified(e))
+                return;
+            e.stopPropagation();
+            canvas.setPointerCapture(e.pointerId);
+            dragging = true;
+            lastX = e.clientX;
+            lastY = e.clientY;
+        }
+        function onPointerMove(e) {
+            if (!dragging || !activeAssetId || !onPlacementChange)
+                return;
+            const rect = canvas.getBoundingClientRect();
+            // Normalise deltas to canvas size so sensitivity is viewport-independent
+            const dx = (e.clientX - lastX) / rect.width;
+            const dy = (e.clientY - lastY) / rect.height;
+            lastX = e.clientX;
+            lastY = e.clientY;
+            const p = placements[activeAssetId];
+            if (!p)
+                return;
+            const TRANSLATE_SPEED = 2.0;
+            const ROTATE_SPEED = Math.PI * 2;
+            if (e.shiftKey && (e.altKey || e.metaKey)) {
+                // Shift+Alt/Meta drag → Y axis (lift/lower)
+                onPlacementChange(activeAssetId, {
+                    ...p,
+                    position: [p.position[0], p.position[1] - dy * TRANSLATE_SPEED, p.position[2]],
+                });
+            }
+            else if (e.shiftKey) {
+                // Shift drag → XZ plane (slide left/right/forward/back)
+                onPlacementChange(activeAssetId, {
+                    ...p,
+                    position: [
+                        p.position[0] + dx * TRANSLATE_SPEED,
+                        p.position[1],
+                        p.position[2] + dy * TRANSLATE_SPEED,
+                    ],
+                });
+            }
+            else if (e.ctrlKey || e.metaKey) {
+                // Ctrl/Cmd drag → Y-axis rotation (yaw)
+                onPlacementChange(activeAssetId, {
+                    ...p,
+                    rotation: [p.rotation[0], p.rotation[1] + dx * ROTATE_SPEED, p.rotation[2]],
+                });
+            }
+        }
+        function onPointerUp(e) {
+            if (dragging)
+                canvas.releasePointerCapture(e.pointerId);
+            dragging = false;
+        }
+        function onWheel(e) {
+            if (!e.shiftKey || !activeAssetId || !onPlacementChange)
+                return;
+            e.preventDefault();
+            const p = placements[activeAssetId];
+            if (!p)
+                return;
+            const factor = e.deltaY > 0 ? 0.95 : 1.05;
+            onPlacementChange(activeAssetId, {
+                ...p,
+                scale: Math.max(0.01, (p.scale ?? 1) * factor),
+            });
+        }
+        canvas.addEventListener('pointerdown', onPointerDown);
+        canvas.addEventListener('pointermove', onPointerMove);
+        canvas.addEventListener('pointerup', onPointerUp);
+        canvas.addEventListener('wheel', onWheel, { passive: false });
+        return () => {
+            canvas.removeEventListener('pointerdown', onPointerDown);
+            canvas.removeEventListener('pointermove', onPointerMove);
+            canvas.removeEventListener('pointerup', onPointerUp);
+            canvas.removeEventListener('wheel', onWheel);
+        };
+    }, [activeAssetId, placements, onPlacementChange, gl]);
+    return null;
+}
 /** Captures the R3F scene object (which contains everything) and passes it up. */
 function SceneRefCapture({ onSceneRef }) {
     const { scene } = (0, fiber_1.useThree)();
@@ -45,7 +136,7 @@ function AvatarCanvas({ avatarUrl, equipped = [], placements = {}, editingAssetI
     ]
         .filter(Boolean)
         .join(' ');
-    return ((0, jsx_runtime_1.jsxs)("div", { className: wrapperClass, style: style, children: [(0, jsx_runtime_1.jsx)("div", { className: "absolute inset-0 opacity-[0.04] pointer-events-none", style: { backgroundImage: 'linear-gradient(rgba(255,255,255,0.3) 1px,transparent 1px),linear-gradient(90deg,rgba(255,255,255,0.3) 1px,transparent 1px)', backgroundSize: '60px 60px' } }), avatarUrl ? ((0, jsx_runtime_1.jsx)(AvatarCanvasErrorBoundary_1.AvatarCanvasErrorBoundary, { children: (0, jsx_runtime_1.jsx)(fiber_1.Canvas, { ref: canvasRef, camera: { position: cameraPosition, fov: 45 }, style: { width: '100%', height: '100%' }, children: (0, jsx_runtime_1.jsxs)(react_1.Suspense, { fallback: null, children: [onSceneRef && (0, jsx_runtime_1.jsx)(SceneRefCapture, { onSceneRef: onSceneRef }), (0, jsx_runtime_1.jsx)("ambientLight", { intensity: 0.6 }), (0, jsx_runtime_1.jsx)("directionalLight", { position: [5, 5, 5], intensity: 0.8 }), (0, jsx_runtime_1.jsx)(drei_1.Environment, { preset: "studio" }), (0, jsx_runtime_1.jsx)(drei_1.OrbitControls, { target: cameraTarget, minDistance: 1, maxDistance: 10, enablePan: false, makeDefault: true, enabled: !editingId }), (0, jsx_runtime_1.jsx)(AvatarModel_1.AvatarModel, { url: avatarUrl, scale: 1, onSkeletonReady: handleSkeletonReady, onBoundsReady: handleBoundsReady }), equippedItems.map((asset) => {
+    return ((0, jsx_runtime_1.jsxs)("div", { className: wrapperClass, style: style, children: [(0, jsx_runtime_1.jsx)("div", { className: "absolute inset-0 opacity-[0.04] pointer-events-none", style: { backgroundImage: 'linear-gradient(rgba(255,255,255,0.3) 1px,transparent 1px),linear-gradient(90deg,rgba(255,255,255,0.3) 1px,transparent 1px)', backgroundSize: '60px 60px' } }), avatarUrl ? ((0, jsx_runtime_1.jsx)(AvatarCanvasErrorBoundary_1.AvatarCanvasErrorBoundary, { children: (0, jsx_runtime_1.jsx)(fiber_1.Canvas, { ref: canvasRef, camera: { position: cameraPosition, fov: 45 }, style: { width: '100%', height: '100%' }, children: (0, jsx_runtime_1.jsxs)(react_1.Suspense, { fallback: null, children: [onSceneRef && (0, jsx_runtime_1.jsx)(SceneRefCapture, { onSceneRef: onSceneRef }), (0, jsx_runtime_1.jsx)("ambientLight", { intensity: 0.6 }), (0, jsx_runtime_1.jsx)("directionalLight", { position: [5, 5, 5], intensity: 0.8 }), (0, jsx_runtime_1.jsx)(drei_1.Environment, { preset: "studio" }), (0, jsx_runtime_1.jsx)(drei_1.OrbitControls, { target: cameraTarget, minDistance: 1, maxDistance: 10, enablePan: false, makeDefault: true }), (0, jsx_runtime_1.jsx)(drei_1.GizmoHelper, { alignment: "bottom-right", margin: [60, 60], children: (0, jsx_runtime_1.jsx)(drei_1.GizmoViewport, { axisColors: ['#e24444', '#44cc44', '#4488ff'], labelColor: "white" }) }), (0, jsx_runtime_1.jsx)(DirectTransform, { activeAssetId: editingId, placements: placements, onPlacementChange: onPlacementChange }), (0, jsx_runtime_1.jsx)(AvatarModel_1.AvatarModel, { url: avatarUrl, scale: 1, onSkeletonReady: handleSkeletonReady, onBoundsReady: handleBoundsReady }), equippedItems.map((asset) => {
                                 if (!asset)
                                     return null;
                                 const llmPlacement = placements[asset.id];
@@ -68,4 +159,3 @@ function AvatarCanvas({ avatarUrl, equipped = [], placements = {}, editingAssetI
                                 return null;
                             })] }) }) })) : ((0, jsx_runtime_1.jsx)("div", { className: "flex items-center justify-center h-full text-muted-foreground", children: (0, jsx_runtime_1.jsx)("p", { children: "Select a base avatar to get started" }) }))] }));
 }
-exports.AvatarCanvas = AvatarCanvas;

package/dist/editor/AvatarEditor.native.js

@@ -15,21 +15,32 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvatarEditor = void 0;
+exports.AvatarEditor = AvatarEditor;
 const jsx_runtime_1 = require("react/jsx-runtime");
 /**
  * Native avatar placement editor.
  * Uses WgpuAvatar (R3F + expo-gl) as the render surface and Three.js raycasting
  * for gesture-driven accessory placement. Replaces the old FilamentEditor.
  */
+/* eslint-disable @typescript-eslint/no-explicit-any -- React Native gesture events and Three.js raycast payloads do not expose complete structural types here. */
 const react_1 = require("react");
 const react_native_1 = require("react-native");
 const THREE = __importStar(require("three"));
@@ -86,7 +97,6 @@ function AvatarEditor({ avatarUrl, activeAssetId = null, onPlacementChange, styl
     }, [activeAssetId, avatarScene, onPlacementChange]);
     return ((0, jsx_runtime_1.jsxs)(react_native_1.View, { style: [styles.container, style], onLayout: (e) => { layoutRef.current = e.nativeEvent.layout; }, children: [(0, jsx_runtime_1.jsx)(wgpu_1.WgpuAvatar, { avatarUrl: avatarUrl, style: react_native_1.StyleSheet.absoluteFill, onSceneReady: handleSceneReady }), (0, jsx_runtime_1.jsx)(react_native_1.View, { style: react_native_1.StyleSheet.absoluteFill, onTouchEnd: handleTap, pointerEvents: activeAssetId ? 'auto' : 'none' })] }));
 }
-exports.AvatarEditor = AvatarEditor;
 exports.default = AvatarEditor;
 const styles = react_native_1.StyleSheet.create({
     container: { flex: 1, overflow: 'hidden' },

package/dist/editor/AvatarModel.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvatarModel = void 0;
+exports.AvatarModel = AvatarModel;
 const jsx_runtime_1 = require("react/jsx-runtime");
 // @ts-nocheck
+/* eslint-disable @typescript-eslint/no-explicit-any -- R3F GLTF skeleton data is passed through from untyped loader internals. */
 const drei_1 = require("@react-three/drei");
 const fiber_1 = require("@react-three/fiber");
 const react_1 = require("react");
@@ -40,4 +41,3 @@ function AvatarModel({ url, scale = 1, onSkeletonReady, onBoundsReady, }) {
     });
     return (0, jsx_runtime_1.jsx)("primitive", { ref: groupRef, object: scene, scale: scale });
 }
-exports.AvatarModel = AvatarModel;

package/dist/editor/FaceSqueezeEditor.d.ts

@@ -10,8 +10,10 @@
  * Drop-in replacement: same FaceSqueezeEditorProps interface.
  * The .web.tsx stub is shared — import from FaceSqueezeEditor.web.tsx.
  */
+import '../wgpu/blobShim';
 export declare const FACE_SQUEEZE_LOCAL_MODULE: number;
 export interface FaceSqueezeEditorProps {
     onClose: () => void;
+    avatarModule?: unknown;
 }
-export declare function FaceSqueezeEditor({ onClose }: FaceSqueezeEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare function FaceSqueezeEditor({ onClose, avatarModule, }: FaceSqueezeEditorProps): import("react/jsx-runtime").JSX.Element;