talking-head-studio 0.3.9 → 0.4.1

package/dist/filament/FilamentAvatar.js

@@ -1,715 +0,0 @@
-"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 (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;
-};
-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 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, }) {
-    // localUri is either a file:// string (remote download) or a require() number (bundled fallback).
-    // useModel accepts both as BufferSource (number | { uri: string }) — cast to any since
-    // tsconfig resolves to an older type declaration that only shows { uri: string }.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const model = (0, react_native_filament_1.useModel)(typeof localUri === 'number' ? localUri : { 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
-// ---------------------------------------------------------------------------
-// The fallback is the bundled require() number — useModel accepts this directly
-// (BufferSource = number | { uri: string }), so no async asset resolution needed.
-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;
-    // Stabilize localUri: once a valid remote file URI resolves, keep it until a new
-    // one arrives. Falls back to the bundled require() number — always available sync.
-    const stableUriRef = react_1.default.useRef(null);
-    if (currentUri)
-        stableUriRef.current = currentUri;
-    const localUri = stableUriRef.current ?? faceSqueezeAssets_1.FACE_SQUEEZE_LOCAL_MODULE;
-    // 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.
-    // FilamentAvatarInner keeps FilamentView permanently mounted; only ModelRenderer
-    // is conditional on the model being 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 },
-});