talking-head-studio 0.2.8 → 0.3.0

package/dist/filament/FilamentAvatar.js

@@ -0,0 +1,737 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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.FilamentAvatar = exports.CAMERA_FOCAL_PIP = exports.CAMERA_FOCAL_FULL = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+/* eslint-disable react-hooks/refs */
+/**
+ * FilamentAvatar — native Filament-based avatar renderer.
+ *
+ * Replaces the TalkingHead WebView on iOS/Android with direct Filament
+ * morph target writes — no WebView bridge, no JS→native→JS roundtrip,
+ * visemes applied at 60fps in React Native JS.
+ *
+ * Implements the full TalkingHeadRef interface so it can be swapped in
+ * transparently for the WebView renderer.
+ */
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const react_native_filament_1 = require("react-native-filament");
+const useAuthedFilamentUri_1 = require("./useAuthedFilamentUri");
+const expo_asset_1 = require("expo-asset");
+const faceSqueezeAssets_1 = require("./faceSqueezeAssets");
+const morphTables_1 = require("./morphTables");
+// ---------------------------------------------------------------------------
+// Material keyword lists for color tinting
+// ---------------------------------------------------------------------------
+const SKIN_MATERIAL_KEYWORDS = ['skin', 'body', 'flesh', 'face', 'head'];
+const HAIR_MATERIAL_KEYWORDS = ['hair', 'beard', 'eyebrow', 'eyelash', 'brow', 'lash'];
+const EYE_MATERIAL_KEYWORDS = ['eye', 'iris', 'cornea', 'sclera', 'pupil'];
+// ---------------------------------------------------------------------------
+// Idle blink timing
+// ---------------------------------------------------------------------------
+const BLINK_INTERVAL_MIN_MS = 2800;
+const BLINK_INTERVAL_MAX_MS = 6000;
+const BLINK_HOLD_MS = 80;
+// ---------------------------------------------------------------------------
+// Idle emotion bursts — matches FaceSqueezeEditor's weighted random system
+// ---------------------------------------------------------------------------
+const IDLE_EMOTION_PRESETS = {
+    happy: { mouthSmileLeft: 0.85, mouthSmileRight: 0.85, cheekSquintLeft: 0.6, cheekSquintRight: 0.6, mouthDimpleLeft: 0.4, mouthDimpleRight: 0.4 },
+    surprised: { eyeWideLeft: 0.9, eyeWideRight: 0.9, browInnerUp: 0.8, browOuterUpLeft: 0.7, browOuterUpRight: 0.7, jawOpen: 0.4, mouthFunnel: 0.3 },
+    smirk: { mouthSmileLeft: 0.9, mouthSmileRight: 0.1, cheekSquintLeft: 0.5, mouthDimpleLeft: 0.35 },
+    sad: { browInnerUp: 0.9, browDownLeft: 0.3, browDownRight: 0.3, mouthFrownLeft: 0.8, mouthFrownRight: 0.8, eyeLookDownLeft: 0.5, eyeLookDownRight: 0.5 },
+    wink: { eyeBlinkLeft: 1.0, mouthSmileLeft: 0.5, mouthSmileRight: 0.3, cheekSquintLeft: 0.4 },
+    sleepy: { eyeBlinkLeft: 0.7, eyeBlinkRight: 0.7, browDownLeft: 0.4, browDownRight: 0.4, mouthShrugLower: 0.3, jawOpen: 0.15 },
+    contempt: { mouthSmileLeft: 0.6, mouthPressRight: 0.5, mouthStretchRight: 0.3, browDownRight: 0.4, eyeSquintRight: 0.3 },
+};
+const IDLE_EMOTIONS_WEIGHTED = [
+    { key: 'happy', weight: 5 }, { key: 'surprised', weight: 2 },
+    { key: 'smirk', weight: 2 }, { key: 'sad', weight: 1 },
+    { key: 'wink', weight: 2 }, { key: 'sleepy', weight: 1 },
+    { key: 'contempt', weight: 1 },
+];
+const IDLE_EMOTION_INTERVAL_MS = 6000;
+const IDLE_EMOTION_INITIAL_DELAY_MS = 2000;
+const IDLE_EMOTION_BLEND_MS = 300;
+const IDLE_EMOTION_HOLD_MS = 1500;
+function pickIdleEmotion() {
+    const total = IDLE_EMOTIONS_WEIGHTED.reduce((s, e) => s + e.weight, 0);
+    let r = Math.random() * total;
+    for (const e of IDLE_EMOTIONS_WEIGHTED) {
+        r -= e.weight;
+        if (r <= 0)
+            return e.key;
+    }
+    return 'happy';
+}
+// ---------------------------------------------------------------------------
+// Camera presets — tight head framing matching TalkingHead cameraView='head'
+// Avatar head is at approximately y=1.62 in Ready Player Me scale.
+// ---------------------------------------------------------------------------
+// z=1.4 gives head+shoulders framing at 50mm; z=1.05 was too tight (face only).
+const CAMERA_POSITION = [0, 1.55, 1.4];
+const CAMERA_TARGET = [0, 1.55, 0];
+const CAMERA_UP = [0, 1, 0];
+// Full/assistant view: 50mm is a natural portrait focal length — head is not distorted.
+// Pip: 85mm telephoto for a tight face crop in the small bubble.
+exports.CAMERA_FOCAL_FULL = 28;
+exports.CAMERA_FOCAL_PIP = 50;
+// ---------------------------------------------------------------------------
+// Idle micro-expression cycles (MotionEngine-style procedural layer)
+// Runs at ~60ms ticks, drives subtle head/face movement independent of speech
+// ---------------------------------------------------------------------------
+// Micro-sway: slow sinusoidal variation on subtle morphs to suggest breathing/life
+const IDLE_BREATHE_PERIOD_MS = 4200; // one breath cycle
+// ---------------------------------------------------------------------------
+// Morph helpers
+// ---------------------------------------------------------------------------
+function normalizeName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function hexToFloat4(hex) {
+    const cleaned = hex.replace('#', '').padEnd(6, '0');
+    return [
+        parseInt(cleaned.slice(0, 2), 16) / 255,
+        parseInt(cleaned.slice(2, 4), 16) / 255,
+        parseInt(cleaned.slice(4, 6), 16) / 255,
+        1.0,
+    ];
+}
+function buildVisemeMorphCache(dispatchMap) {
+    const cache = new Map();
+    for (const [visemeKey, aliases] of Object.entries(morphTables_1.VISEME_MORPH_ALIASES)) {
+        if (visemeKey === 'sil')
+            continue;
+        for (const alias of aliases) {
+            const entries = dispatchMap.get(alias) ?? dispatchMap.get(normalizeName(alias));
+            if (entries && entries.length > 0) {
+                cache.set(visemeKey, entries);
+                break;
+            }
+        }
+    }
+    return cache;
+}
+function FilamentAvatarInner({ localUri, mood: initialMood = 'neutral', hairColor: initialHairColor, skinColor: initialSkinColor, eyeColor: initialEyeColor, onReady, onError: _onError, // eslint-disable-line @typescript-eslint/no-unused-vars
+innerRef, aspect, focalLength = exports.CAMERA_FOCAL_FULL, }) {
+    // When localUri is empty (model not yet downloaded), pass a stable placeholder
+    // so useModel doesn't error. ModelRenderer is gated on model.state === 'loaded'
+    // so nothing will render until the real URI arrives.
+    const model = (0, react_native_filament_1.useModel)({ uri: localUri || '' });
+    const modelRef = (0, react_1.useRef)(model);
+    modelRef.current = model;
+    const { renderableManager } = (0, react_native_filament_1.useFilamentContext)();
+    // morph dispatch map — keyed by name and normalized name
+    const dispatchMap = (0, react_1.useRef)(new Map());
+    const visemeCacheRef = (0, react_1.useRef)(new Map());
+    const weightsMap = (0, react_1.useRef)(new Map());
+    const entityById = (0, react_1.useRef)(new Map());
+    // viseme scheduler state
+    const visemeState = (0, react_1.useRef)({});
+    const visemeTimers = (0, react_1.useRef)([]);
+    const visemeModeUntil = (0, react_1.useRef)(0);
+    const activeScheduleId = (0, react_1.useRef)(0);
+    const tickIntervalRef = (0, react_1.useRef)(null);
+    // last received schedule — replayed if model loads after the schedule arrives
+    const lastScheduleRef = (0, react_1.useRef)(null);
+    // stable ref to scheduleVisemes so the model-load effect can call it after definition
+    const scheduleVisemesRef = (0, react_1.useRef)(null);
+    // amplitude fallback
+    const amplitudeRef = (0, react_1.useRef)(0);
+    // mood baseline weights
+    const moodWeightsRef = (0, react_1.useRef)(morphTables_1.MOOD_MORPHS[initialMood] ?? {});
+    // idle breathing phase (radians, incremented per tick)
+    const breathPhaseRef = (0, react_1.useRef)(0);
+    // blink
+    const blinkTimerRef = (0, react_1.useRef)(null);
+    const isBlinkingRef = (0, react_1.useRef)(false);
+    // idle emotion burst — blended overlay on top of mood baseline
+    const idleEmotionWeightsRef = (0, react_1.useRef)({});
+    const idleEmotionTimerRef = (0, react_1.useRef)(null);
+    const idleEmotionIntervalRef = (0, react_1.useRef)(null);
+    // mounted guard — prevents renderableManager calls after unmount.
+    // useLayoutEffect so it fires synchronously before any pending timers/intervals.
+    const mountedRef = (0, react_1.useRef)(true);
+    (0, react_1.useLayoutEffect)(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+            // Synchronous cleanup — kill timers immediately on unmount
+            for (const id of visemeTimers.current)
+                clearTimeout(id);
+            visemeTimers.current = [];
+            if (tickIntervalRef.current) {
+                clearInterval(tickIntervalRef.current);
+                tickIntervalRef.current = null;
+            }
+            if (blinkTimerRef.current) {
+                clearTimeout(blinkTimerRef.current);
+                blinkTimerRef.current = null;
+            }
+            if (idleEmotionIntervalRef.current) {
+                clearInterval(idleEmotionIntervalRef.current);
+                idleEmotionIntervalRef.current = null;
+            }
+            if (idleEmotionTimerRef.current) {
+                clearTimeout(idleEmotionTimerRef.current);
+                idleEmotionTimerRef.current = null;
+            }
+            if (blendIntervalRef.current) {
+                clearInterval(blendIntervalRef.current);
+                blendIntervalRef.current = null;
+            }
+        };
+    }, []);
+    // ---------------------------------------------------------------------------
+    // Apply weights to Filament meshes
+    // ---------------------------------------------------------------------------
+    // Entities that were non-zero last tick — must be flushed even if zero this tick
+    const prevDirtyRef = (0, react_1.useRef)(new Set());
+    /**
+     * Zero all weight arrays, compose layers, flush to Filament once.
+     * Always flushes entities that were dirty last tick so zeroed values
+     * actually reach the GPU (prevents one-frame stale morph flashes).
+     */
+    const flushWeights = (0, react_1.useCallback)((morphTargets, visemeTargets) => {
+        if (!mountedRef.current)
+            return;
+        // Zero all weight arrays
+        for (const arr of weightsMap.current.values())
+            arr.fill(0);
+        const dirty = new Set(prevDirtyRef.current);
+        // Helper: write a morph-name keyed entry (direct dispatchMap lookup)
+        const writeMorph = (name, weight) => {
+            const dispatch = dispatchMap.current.get(name) ?? dispatchMap.current.get(normalizeName(name));
+            if (!dispatch)
+                return;
+            const clamped = Math.max(0, Math.min(1, weight));
+            for (const entry of dispatch) {
+                const arr = weightsMap.current.get(entry.entityId);
+                if (!arr)
+                    continue;
+                arr[entry.index] = Math.max(arr[entry.index], clamped);
+                dirty.add(entry.entityId);
+            }
+        };
+        // Layer 1+2: mood + breathe + blink (morph target names)
+        for (const [name, weight] of Object.entries(morphTargets)) {
+            writeMorph(name, weight);
+        }
+        // Layer 3: viseme state (viseme keys → viseme cache)
+        for (const [visemeKey, weight] of Object.entries(visemeTargets)) {
+            if (weight <= 0)
+                continue;
+            const entries = visemeCacheRef.current.get(visemeKey);
+            if (!entries)
+                continue;
+            const clamped = Math.min(1, weight);
+            for (const entry of entries) {
+                const arr = weightsMap.current.get(entry.entityId);
+                if (!arr)
+                    continue;
+                arr[entry.index] = Math.max(arr[entry.index], clamped);
+                dirty.add(entry.entityId);
+            }
+        }
+        // Single flush per entity — includes prev-dirty so zeroed morphs reach GPU
+        for (const id of dirty) {
+            const entity = entityById.current.get(id);
+            const arr = weightsMap.current.get(id);
+            if (entity && arr) {
+                try {
+                    renderableManager.setMorphWeights(entity, arr, 0);
+                }
+                catch { /* noop */ }
+            }
+        }
+        prevDirtyRef.current = dirty;
+    }, [renderableManager]);
+    // ---------------------------------------------------------------------------
+    // Apply material color tint to a keyword-matched set of materials
+    // ---------------------------------------------------------------------------
+    const applyMaterialColor = (0, react_1.useCallback)((keywords, color) => {
+        const m = modelRef.current;
+        if (m.state !== 'loaded')
+            return;
+        const float4 = hexToFloat4(color);
+        const entities = m.asset.getRenderableEntities();
+        let matched = false;
+        for (const entity of entities) {
+            const count = renderableManager.getPrimitiveCount(entity);
+            for (let i = 0; i < count; i++) {
+                try {
+                    const mi = renderableManager.getMaterialInstanceAt(entity, i);
+                    const lower = (mi.name ?? '').toLowerCase();
+                    if (keywords.some((k) => lower.includes(k))) {
+                        mi.setFloat4Parameter('baseColorFactor', float4);
+                        matched = true;
+                    }
+                }
+                catch { /* noop — some entities may not have materials */ }
+            }
+        }
+        // Fallback: tint everything if no keyword match
+        if (!matched) {
+            for (const entity of entities) {
+                const count = renderableManager.getPrimitiveCount(entity);
+                for (let i = 0; i < count; i++) {
+                    try {
+                        const mi = renderableManager.getMaterialInstanceAt(entity, i);
+                        mi.setFloat4Parameter('baseColorFactor', float4);
+                    }
+                    catch { /* noop */ }
+                }
+            }
+        }
+    }, [renderableManager]);
+    // ---------------------------------------------------------------------------
+    // Build morph cache when model loads
+    // ---------------------------------------------------------------------------
+    (0, react_1.useEffect)(() => {
+        const m = modelRef.current;
+        if (m.state !== 'loaded') {
+            // Model is unloading or reloading — clear stale entity refs immediately so
+            // the 16ms tick interval never calls setMorphWeights on freed entities.
+            // Leaving stale entity IDs in the maps causes use-after-free in FEngine::loop.
+            dispatchMap.current = new Map();
+            weightsMap.current = new Map();
+            entityById.current = new Map();
+            visemeCacheRef.current = new Map();
+            visemeState.current = {};
+            prevDirtyRef.current = new Set();
+            return;
+        }
+        const newDispatchMap = new Map();
+        const newWeightsMap = new Map();
+        const newEntityById = new Map();
+        const entities = m.asset.getRenderableEntities();
+        for (const entity of entities) {
+            let count = 0;
+            try {
+                count = m.asset.getMorphTargetCountAt(entity);
+            }
+            catch { /* noop */ }
+            if (count <= 0) {
+                try {
+                    count = renderableManager.getMorphTargetCount(entity);
+                }
+                catch { /* noop */ }
+            }
+            if (count === 0)
+                continue;
+            newWeightsMap.set(entity.id, new Array(count).fill(0));
+            newEntityById.set(entity.id, entity);
+            for (let i = 0; i < count; i++) {
+                let name = '';
+                try {
+                    name = m.asset.getMorphTargetNameAt(entity, i) ?? '';
+                }
+                catch { /* noop */ }
+                if (!name) {
+                    try {
+                        name = renderableManager.getMorphTargetNameAt(entity, i) ?? '';
+                    }
+                    catch { /* noop */ }
+                }
+                if (!name)
+                    continue;
+                const entry = { entityId: entity.id, index: i };
+                const addEntry = (key) => {
+                    const list = newDispatchMap.get(key);
+                    if (list)
+                        list.push(entry);
+                    else
+                        newDispatchMap.set(key, [entry]);
+                };
+                addEntry(name);
+                addEntry(normalizeName(name));
+            }
+        }
+        dispatchMap.current = newDispatchMap;
+        weightsMap.current = newWeightsMap;
+        entityById.current = newEntityById;
+        visemeCacheRef.current = buildVisemeMorphCache(newDispatchMap);
+        visemeState.current = {};
+        // Apply initial appearance
+        if (initialSkinColor)
+            applyMaterialColor(SKIN_MATERIAL_KEYWORDS, initialSkinColor);
+        if (initialHairColor)
+            applyMaterialColor(HAIR_MATERIAL_KEYWORDS, initialHairColor);
+        if (initialEyeColor)
+            applyMaterialColor(EYE_MATERIAL_KEYWORDS, initialEyeColor);
+        onReady?.();
+        // Replay any pending schedule that arrived before the model was ready.
+        // (scheduleVisemes stores to lastScheduleRef even when morphMapSize is 0)
+        const pending = lastScheduleRef.current;
+        if (pending && pending.cues && pending.cues.length > 0) {
+            const startedAt = pending.startedAtMs ?? Date.now();
+            const durationMs = pending.durationMs ?? 0;
+            const ageMs = Date.now() - startedAt;
+            // Only replay if audio is likely still playing
+            if (durationMs <= 0 || ageMs < durationMs + 300) {
+                __DEV__ && console.log('[FilamentAvatar] replaying pending schedule after model load', {
+                    requestId: pending.requestId ?? null,
+                    ageMs,
+                    cues: pending.cues.length,
+                });
+                const scheduleToReplay = pending;
+                lastScheduleRef.current = null;
+                // scheduleVisemesRef.current is populated during render (before effects run)
+                scheduleVisemesRef.current?.(scheduleToReplay);
+            }
+            else {
+                lastScheduleRef.current = null;
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [model.state]);
+    // ---------------------------------------------------------------------------
+    // Viseme tick — runs every 16ms, decays state and writes to morphs
+    // ---------------------------------------------------------------------------
+    const tickViseme = (0, react_1.useCallback)(() => {
+        const state = visemeState.current;
+        const now = Date.now();
+        const isScheduled = now < visemeModeUntil.current;
+        if (!isScheduled) {
+            // Amplitude fallback: jaw bobble when no viseme schedule active
+            const amp = amplitudeRef.current;
+            if (amp > 0.01) {
+                state['aa'] = amp * 0.6;
+            }
+            else {
+                for (const key of Object.keys(state)) {
+                    const decayed = (state[key] ?? 0) * 0.82;
+                    state[key] = decayed < 0.01 ? 0 : decayed;
+                }
+            }
+        }
+        // Idle breathing — subtle cheek/nose puff on inhale
+        breathPhaseRef.current += (2 * Math.PI * 16) / IDLE_BREATHE_PERIOD_MS;
+        const breathe = Math.max(0, Math.sin(breathPhaseRef.current)) * 0.06;
+        // Mood baseline + breathe + blink (morph target names)
+        const morphTargets = { ...moodWeightsRef.current };
+        if (breathe > 0.005) {
+            morphTargets['noseSneerLeft'] = Math.max(morphTargets['noseSneerLeft'] ?? 0, breathe);
+            morphTargets['noseSneerRight'] = Math.max(morphTargets['noseSneerRight'] ?? 0, breathe);
+            morphTargets['cheekPuff'] = Math.max(morphTargets['cheekPuff'] ?? 0, breathe * 0.5);
+        }
+        if (isBlinkingRef.current) {
+            morphTargets['eyeBlinkLeft'] = 1;
+            morphTargets['eyeBlinkRight'] = 1;
+        }
+        // Idle emotion overlay — blend on top of mood baseline
+        for (const [name, weight] of Object.entries(idleEmotionWeightsRef.current)) {
+            if (weight > 0)
+                morphTargets[name] = Math.max(morphTargets[name] ?? 0, weight);
+        }
+        // Single flush: zeros all arrays, writes mood/breathe, writes visemes on top, pushes to GPU once
+        flushWeights(morphTargets, state);
+    }, [flushWeights]);
+    (0, react_1.useEffect)(() => {
+        tickIntervalRef.current = setInterval(tickViseme, 16);
+        return () => {
+            if (tickIntervalRef.current)
+                clearInterval(tickIntervalRef.current);
+        };
+    }, [tickViseme]);
+    // ---------------------------------------------------------------------------
+    // Viseme scheduler
+    // ---------------------------------------------------------------------------
+    const clearScheduledVisemes = (0, react_1.useCallback)(() => {
+        for (const id of visemeTimers.current)
+            clearTimeout(id);
+        visemeTimers.current = [];
+        visemeModeUntil.current = 0;
+        visemeState.current = {};
+    }, []);
+    const scheduleVisemes = (0, react_1.useCallback)((schedule) => {
+        const modelLoaded = modelRef.current.state === 'loaded';
+        const morphMapSize = dispatchMap.current.size;
+        __DEV__ && console.log('[FilamentAvatar] scheduleVisemes', {
+            cues: schedule.cues?.length ?? 0,
+            modelLoaded,
+            morphMapSize,
+            requestId: schedule.requestId ?? null,
+        });
+        // Always save — if model isn't loaded yet, we replay when it loads
+        lastScheduleRef.current = schedule;
+        clearScheduledVisemes();
+        activeScheduleId.current += 1;
+        const myId = activeScheduleId.current;
+        if (!schedule.cues || schedule.cues.length === 0)
+            return;
+        const startedAt = schedule.startedAtMs ?? Date.now();
+        const durationMs = schedule.durationMs ?? 0;
+        const now = Date.now();
+        const elapsedMs = Math.max(0, now - startedAt);
+        visemeModeUntil.current = now + Math.max(0, durationMs - elapsedMs) + 200;
+        for (const cue of schedule.cues) {
+            const delay = cue.startMs - elapsedMs;
+            // Skip cues that are more than one cue-duration in the past
+            if (delay < -(cue.endMs - cue.startMs) - 50)
+                continue;
+            const visemeKey = morphTables_1.RHUBARB_TO_VISEME[cue.viseme] ?? 'sil';
+            const weight = morphTables_1.VISEME_WEIGHTS[visemeKey] ?? morphTables_1.DEFAULT_VISEME_WEIGHT;
+            const applyId = setTimeout(() => {
+                if (activeScheduleId.current !== myId)
+                    return;
+                for (const k of Object.keys(visemeState.current))
+                    visemeState.current[k] = 0;
+                if (visemeKey !== 'sil')
+                    visemeState.current[visemeKey] = weight;
+            }, Math.max(0, delay));
+            const clearId = setTimeout(() => {
+                if (activeScheduleId.current !== myId)
+                    return;
+                if (visemeState.current[visemeKey] !== undefined)
+                    visemeState.current[visemeKey] = 0;
+            }, Math.max(0, delay + (cue.endMs - cue.startMs)));
+            visemeTimers.current.push(applyId, clearId);
+        }
+        // Silence at end — always schedule a hard reset
+        const endDelay = durationMs > 0
+            ? Math.max(0, durationMs - (Date.now() - startedAt)) + 100
+            : (schedule.cues[schedule.cues.length - 1]?.endMs ?? 0) - elapsedMs + 100;
+        visemeTimers.current.push(setTimeout(() => {
+            if (activeScheduleId.current !== myId)
+                return;
+            // Hard reset: zero all viseme state and exit scheduled mode
+            visemeState.current = {};
+            visemeModeUntil.current = 0;
+        }, Math.max(0, endDelay)));
+    }, [clearScheduledVisemes]);
+    // Keep ref in sync so the model-load effect can call scheduleVisemes
+    scheduleVisemesRef.current = scheduleVisemes;
+    // Single-shot viseme (for real-time streaming TTS like ElevenLabs)
+    const sendViseme = (0, react_1.useCallback)((viseme, weight = morphTables_1.DEFAULT_VISEME_WEIGHT) => {
+        for (const k of Object.keys(visemeState.current))
+            visemeState.current[k] = 0;
+        if (viseme !== 'sil')
+            visemeState.current[viseme] = morphTables_1.VISEME_WEIGHTS[viseme] ?? weight;
+        visemeModeUntil.current = Date.now() + 120; // hold for ~120ms
+    }, []);
+    // ---------------------------------------------------------------------------
+    // Idle blink
+    // ---------------------------------------------------------------------------
+    const scheduleBlink = (0, react_1.useCallback)(() => {
+        const delay = BLINK_INTERVAL_MIN_MS + Math.random() * (BLINK_INTERVAL_MAX_MS - BLINK_INTERVAL_MIN_MS);
+        blinkTimerRef.current = setTimeout(() => {
+            isBlinkingRef.current = true;
+            setTimeout(() => {
+                isBlinkingRef.current = false;
+                scheduleBlink();
+            }, BLINK_HOLD_MS);
+        }, delay);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (model.state !== 'loaded')
+            return;
+        scheduleBlink();
+        return () => {
+            if (blinkTimerRef.current)
+                clearTimeout(blinkTimerRef.current);
+        };
+    }, [model.state, scheduleBlink]);
+    // ---------------------------------------------------------------------------
+    // Idle emotion bursts — weighted random expressions matching FaceSqueezeEditor
+    // ---------------------------------------------------------------------------
+    // Tracks the active blend-in/blend-out intervals so they can be cleaned up on unmount
+    const blendIntervalRef = (0, react_1.useRef)(null);
+    const playIdleEmotion = (0, react_1.useCallback)((key) => {
+        if (!mountedRef.current)
+            return;
+        const target = IDLE_EMOTION_PRESETS[key] ?? {};
+        const steps = Math.max(1, Math.round(IDLE_EMOTION_BLEND_MS / 16));
+        // Clear any in-flight blend interval from a previous emotion
+        if (blendIntervalRef.current) {
+            clearInterval(blendIntervalRef.current);
+            blendIntervalRef.current = null;
+        }
+        // Blend in
+        let step = 0;
+        blendIntervalRef.current = setInterval(() => {
+            if (!mountedRef.current) {
+                clearInterval(blendIntervalRef.current);
+                blendIntervalRef.current = null;
+                return;
+            }
+            step++;
+            const t = Math.min(1, step / steps);
+            const blended = {};
+            for (const [k, v] of Object.entries(target))
+                blended[k] = v * t;
+            idleEmotionWeightsRef.current = blended;
+            if (step >= steps) {
+                clearInterval(blendIntervalRef.current);
+                blendIntervalRef.current = null;
+            }
+        }, 16);
+        // Hold then blend out
+        idleEmotionTimerRef.current = setTimeout(() => {
+            if (!mountedRef.current)
+                return;
+            // Clear blend-in if it somehow outlasted the hold period
+            if (blendIntervalRef.current) {
+                clearInterval(blendIntervalRef.current);
+                blendIntervalRef.current = null;
+            }
+            let outStep = 0;
+            blendIntervalRef.current = setInterval(() => {
+                if (!mountedRef.current) {
+                    clearInterval(blendIntervalRef.current);
+                    blendIntervalRef.current = null;
+                    return;
+                }
+                outStep++;
+                const t = Math.max(0, 1 - outStep / steps);
+                const blended = {};
+                for (const [k, v] of Object.entries(target))
+                    blended[k] = v * t;
+                idleEmotionWeightsRef.current = blended;
+                if (outStep >= steps) {
+                    clearInterval(blendIntervalRef.current);
+                    blendIntervalRef.current = null;
+                    idleEmotionWeightsRef.current = {};
+                }
+            }, 16);
+        }, IDLE_EMOTION_HOLD_MS);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (model.state !== 'loaded')
+            return;
+        const initial = setTimeout(() => playIdleEmotion(pickIdleEmotion()), IDLE_EMOTION_INITIAL_DELAY_MS);
+        idleEmotionIntervalRef.current = setInterval(() => playIdleEmotion(pickIdleEmotion()), IDLE_EMOTION_INTERVAL_MS);
+        return () => {
+            clearTimeout(initial);
+            if (idleEmotionIntervalRef.current)
+                clearInterval(idleEmotionIntervalRef.current);
+            if (idleEmotionTimerRef.current)
+                clearTimeout(idleEmotionTimerRef.current);
+            if (blendIntervalRef.current) {
+                clearInterval(blendIntervalRef.current);
+                blendIntervalRef.current = null;
+            }
+            idleEmotionWeightsRef.current = {};
+        };
+    }, [model.state, playIdleEmotion]);
+    // ---------------------------------------------------------------------------
+    // Imperative ref — full TalkingHeadRef parity
+    // ---------------------------------------------------------------------------
+    (0, react_1.useImperativeHandle)(innerRef, () => ({
+        sendViseme,
+        scheduleVisemes,
+        clearVisemes: clearScheduledVisemes,
+        sendAmplitude: (amp) => { amplitudeRef.current = amp; },
+        setMood: (mood) => { moodWeightsRef.current = morphTables_1.MOOD_MORPHS[mood] ?? {}; },
+        setHairColor: (color) => applyMaterialColor(HAIR_MATERIAL_KEYWORDS, color),
+        setSkinColor: (color) => applyMaterialColor(SKIN_MATERIAL_KEYWORDS, color),
+        setEyeColor: (color) => applyMaterialColor(EYE_MATERIAL_KEYWORDS, color),
+        setAccessories: (_accessories) => {
+            // Future: load accessory GLBs and attach to skeleton bones
+        },
+    }), [sendViseme, scheduleVisemes, clearScheduledVisemes, applyMaterialColor]);
+    // ---------------------------------------------------------------------------
+    // Cleanup
+    // ---------------------------------------------------------------------------
+    (0, react_1.useEffect)(() => {
+        return () => {
+            clearScheduledVisemes();
+            if (blinkTimerRef.current)
+                clearTimeout(blinkTimerRef.current);
+            if (tickIntervalRef.current)
+                clearInterval(tickIntervalRef.current);
+        };
+    }, [clearScheduledVisemes]);
+    // Pause Filament render loop when app backgrounds to prevent native
+    // render thread from accessing freed GPU/surface resources → SIGSEGV.
+    const filamentViewRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        const sub = react_native_1.AppState.addEventListener('change', (state) => {
+            if (!filamentViewRef.current)
+                return;
+            if (state === 'background' || state === 'inactive') {
+                filamentViewRef.current.pause?.();
+            }
+            else if (state === 'active') {
+                filamentViewRef.current.resume?.();
+            }
+        });
+        return () => sub.remove();
+    }, []);
+    return ((0, jsx_runtime_1.jsxs)(react_native_filament_1.FilamentView, { ref: filamentViewRef, style: react_native_1.StyleSheet.absoluteFill, children: [(0, jsx_runtime_1.jsx)(react_native_filament_1.DefaultLight, {}), (0, jsx_runtime_1.jsx)(react_native_filament_1.Camera, { cameraPosition: CAMERA_POSITION, cameraTarget: CAMERA_TARGET, cameraUp: CAMERA_UP, aspect: aspect ?? 1, focalLengthInMillimeters: focalLength }), model.state === 'loaded' && ((0, jsx_runtime_1.jsx)(react_native_filament_1.ModelRenderer, { model: model, multiplyWithCurrentTransform: false }))] }));
+}
+// ---------------------------------------------------------------------------
+// Outer component — handles URL resolution + FilamentScene wrapper
+// ---------------------------------------------------------------------------
+let _fallbackGlbUri = null;
+async function getFallbackGlbUri() {
+    if (_fallbackGlbUri)
+        return _fallbackGlbUri;
+    const asset = expo_asset_1.Asset.fromModule(faceSqueezeAssets_1.FACE_SQUEEZE_LOCAL_MODULE);
+    await asset.downloadAsync();
+    _fallbackGlbUri = asset.localUri ?? asset.uri ?? '';
+    return _fallbackGlbUri;
+}
+exports.FilamentAvatar = (0, react_1.forwardRef)(({ style, avatarUrl, aspect, focalLength, mood, hairColor, skinColor, eyeColor, accessories, onReady, onError }, ref) => {
+    const fileResult = (0, useAuthedFilamentUri_1.useAuthedFilamentUri)(avatarUrl ?? null);
+    const currentUri = fileResult?.uri ?? null;
+    const [fallbackUri, setFallbackUri] = react_1.default.useState(_fallbackGlbUri);
+    react_1.default.useEffect(() => {
+        getFallbackGlbUri().then(setFallbackUri).catch((e) => console.error('[FilamentAvatar] fallback uri failed:', e));
+    }, []);
+    // Stabilize localUri: once a valid file URI resolves, keep it until a new one
+    // arrives. Never let it drop to null between URL transitions — that would cause
+    // the conditional below to unmount FilamentScene mid-render.
+    const stableUriRef = react_1.default.useRef(null);
+    if (currentUri)
+        stableUriRef.current = currentUri;
+    const localUri = stableUriRef.current ?? fallbackUri;
+    // FilamentScene MUST stay mounted for the lifetime of this component.
+    // Unmounting it disposes GPU assets on the JS thread while Filament's native
+    // render thread (FEngine::loop) and surface thread (JNISurfaceTextu) still hold
+    // references to those objects → SIGSEGV / corrupted-PC use-after-free crashes.
+    // We always render FilamentScene and conditionally render FilamentAvatarInner
+    // inside it once the local file URI is ready.
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: [style, styles.fill], children: (0, jsx_runtime_1.jsx)(react_native_filament_1.FilamentScene, { children: (0, jsx_runtime_1.jsx)(FilamentAvatarInner, { localUri: localUri ?? '', avatarUrl: avatarUrl, aspect: aspect, focalLength: focalLength, mood: mood, hairColor: hairColor, skinColor: skinColor, eyeColor: eyeColor, accessories: accessories, innerRef: ref, onReady: onReady, onError: onError }) }) }));
+});
+exports.FilamentAvatar.displayName = 'FilamentAvatar';
+const styles = react_native_1.StyleSheet.create({
+    fill: { flex: 1 },
+    empty: { backgroundColor: 'transparent' },
+    center: { alignItems: 'center', justifyContent: 'center' },
+    label: { color: 'rgba(226,232,240,0.6)', fontSize: 13 },
+});