talking-head-studio 0.4.11 → 0.4.12

package/dist/wgpu/blobShim.js

@@ -0,0 +1,191 @@
+"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.blobBytesStore = void 0;
+// MUST be the very first import in any file that uses GLTFLoader on native.
+// Installed before @react-three/fiber is evaluated so the BlobShim is in place
+// before R3F's polyfills() runs its createObjectURL smoke-test.
+/* eslint-disable @typescript-eslint/no-explicit-any -- This polyfills missing React Native Blob and Three.js globals with dynamic host objects. */
+const react_native_1 = require("react-native");
+const base64_js_1 = require("base64-js");
+const THREE = __importStar(require("three"));
+// ─── Shim legacy THREE APIs removed in three.webgpu.js ───────────────────────
+// three-stdlib (Sky, etc.) calls THREE.UniformsUtils.clone() at module init time.
+// three.webgpu.js dropped UniformsUtils — add it back so three-stdlib doesn't crash.
+if (!THREE.UniformsUtils) {
+    function cloneUniforms(src) {
+        const dst = {};
+        for (const u in src) {
+            dst[u] = {};
+            for (const p in src[u]) {
+                const v = src[u][p];
+                if (v && typeof v.clone === 'function') {
+                    dst[u][p] = v.clone();
+                }
+                else if (Array.isArray(v)) {
+                    dst[u][p] = v.slice();
+                }
+                else {
+                    dst[u][p] = v;
+                }
+            }
+        }
+        return dst;
+    }
+    THREE.UniformsUtils = {
+        clone: cloneUniforms,
+        merge: (uniforms) => {
+            const merged = {};
+            for (const u of uniforms)
+                Object.assign(merged, cloneUniforms(u));
+            return merged;
+        },
+    };
+}
+if (!THREE.UniformsLib) {
+    THREE.UniformsLib = {};
+}
+/** Exported so patchThreeForRN can use the same store when re-patching URL.createObjectURL. */
+exports.blobBytesStore = new WeakMap();
+if (react_native_1.Platform.OS !== 'web') {
+    const _OrigBlob = globalThis.Blob;
+    const _blobBytes = exports.blobBytesStore;
+    const encoder = new TextEncoder();
+    function toBytes(part) {
+        if (part instanceof ArrayBuffer) {
+            return new Uint8Array(part);
+        }
+        if (ArrayBuffer.isView(part)) {
+            return new Uint8Array(part.buffer, part.byteOffset, part.byteLength);
+        }
+        if (typeof part === 'string') {
+            return encoder.encode(part);
+        }
+        return null;
+    }
+    function concatBytes(parts) {
+        const chunks = parts.map(toBytes);
+        if (chunks.some((chunk) => chunk == null))
+            return null;
+        const total = chunks.reduce((sum, chunk) => sum + (chunk?.byteLength ?? 0), 0);
+        const out = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            out.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return out;
+    }
+    function createFallbackBlob(parts, options) {
+        const bytes = concatBytes(parts);
+        if (!bytes) {
+            throw new Error('[BlobShim] Unable to synthesize Blob from unsupported parts');
+        }
+        const blob = Object.create(_OrigBlob.prototype ?? Object.prototype);
+        Object.defineProperties(blob, {
+            type: {
+                value: options?.type ?? '',
+                enumerable: true,
+            },
+            size: {
+                value: bytes.byteLength,
+                enumerable: true,
+            },
+            arrayBuffer: {
+                value: async () => {
+                    const buffer = new ArrayBuffer(bytes.byteLength);
+                    new Uint8Array(buffer).set(bytes);
+                    return buffer;
+                },
+            },
+            text: {
+                value: async () => new TextDecoder().decode(bytes),
+            },
+            slice: {
+                value: (start, end, contentType) => {
+                    return new Blob([bytes.slice(start ?? 0, end ?? bytes.byteLength)], {
+                        type: contentType ?? options?.type ?? '',
+                    });
+                },
+            },
+        });
+        _blobBytes.set(blob, bytes);
+        return blob;
+    }
+    function BlobShim(parts, options) {
+        const hasBinaryPart = !!parts?.some((p) => p instanceof ArrayBuffer || ArrayBuffer.isView(p));
+        let blob;
+        let usedFallback = false;
+        try {
+            blob = new _OrigBlob(parts, options);
+        }
+        catch (error) {
+            if (!hasBinaryPart)
+                throw error;
+            blob = createFallbackBlob(parts ?? [], options);
+            usedFallback = true;
+        }
+        if (parts) {
+            let stashed = usedFallback;
+            if (!usedFallback) {
+                for (const p of parts) {
+                    const bytes = toBytes(p);
+                    if (bytes) {
+                        _blobBytes.set(blob, bytes);
+                        stashed = true;
+                        break;
+                    }
+                }
+            }
+            void stashed;
+        }
+        return blob;
+    }
+    BlobShim.prototype = _OrigBlob.prototype;
+    Object.defineProperty(BlobShim, Symbol.hasInstance, {
+        value: (v) => v instanceof _OrigBlob,
+    });
+    globalThis.Blob = BlobShim;
+    URL.createObjectURL = (blob) => {
+        const bytes = _blobBytes.get(blob);
+        if (bytes) {
+            const mime = blob.type || 'application/octet-stream';
+            const b64 = (0, base64_js_1.fromByteArray)(bytes);
+            return `data:${mime};base64,${b64}`;
+        }
+        throw new Error('[BlobShim] createObjectURL: no bytes stashed for this Blob');
+    };
+    URL.revokeObjectURL = (_url) => { };
+}

package/dist/wgpu/index.d.ts

@@ -1,2 +1,3 @@
 export { WgpuAvatar } from './WgpuAvatar';
 export type { WgpuAvatarRef } from './WgpuAvatar';
+export { snapDefaultForCategory, BONE_SNAP_DEFAULTS } from './accessoryDefaults';

package/dist/wgpu/index.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WgpuAvatar = void 0;
+exports.BONE_SNAP_DEFAULTS = exports.snapDefaultForCategory = exports.WgpuAvatar = void 0;
 var WgpuAvatar_1 = require("./WgpuAvatar");
 Object.defineProperty(exports, "WgpuAvatar", { enumerable: true, get: function () { return WgpuAvatar_1.WgpuAvatar; } });
+var accessoryDefaults_1 = require("./accessoryDefaults");
+Object.defineProperty(exports, "snapDefaultForCategory", { enumerable: true, get: function () { return accessoryDefaults_1.snapDefaultForCategory; } });
+Object.defineProperty(exports, "BONE_SNAP_DEFAULTS", { enumerable: true, get: function () { return accessoryDefaults_1.BONE_SNAP_DEFAULTS; } });

package/dist/wgpu/loadGLTFFromUri.d.ts

@@ -0,0 +1,2 @@
+import type { GLTF } from 'three-stdlib';
+export declare function loadGLTFFromUri(uri: string): Promise<GLTF>;

package/dist/wgpu/loadGLTFFromUri.js

@@ -0,0 +1,75 @@
+"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.loadGLTFFromUri = loadGLTFFromUri;
+const react_native_1 = require("react-native");
+const base64_js_1 = require("base64-js");
+const FileSystem = __importStar(require("expo-file-system/legacy"));
+const three_stdlib_1 = require("three-stdlib");
+function toArrayBuffer(bytes) {
+    const buffer = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(buffer).set(bytes);
+    return buffer;
+}
+function decodeDataUri(uri) {
+    const marker = ';base64,';
+    const markerIndex = uri.indexOf(marker);
+    if (markerIndex < 0) {
+        throw new Error('Unsupported data URI encoding for GLB');
+    }
+    const base64 = uri.slice(markerIndex + marker.length);
+    return toArrayBuffer((0, base64_js_1.toByteArray)(base64));
+}
+async function parseArrayBuffer(buffer, path = '') {
+    const loader = new three_stdlib_1.GLTFLoader();
+    return await new Promise((resolve, reject) => {
+        loader.parse(buffer, path, resolve, (error) => {
+            reject(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+}
+async function loadGLTFFromUri(uri) {
+    if (react_native_1.Platform.OS !== 'web' && uri.startsWith('data:')) {
+        return await parseArrayBuffer(decodeDataUri(uri));
+    }
+    if (react_native_1.Platform.OS !== 'web' && uri.startsWith('file://')) {
+        const base64 = await FileSystem.readAsStringAsync(uri, {
+            encoding: FileSystem.EncodingType.Base64,
+        });
+        return await parseArrayBuffer(toArrayBuffer((0, base64_js_1.toByteArray)(base64)));
+    }
+    const loader = new three_stdlib_1.GLTFLoader();
+    return await loader.loadAsync(uri);
+}

package/dist/wgpu/morphTables.js

@@ -55,6 +55,27 @@ exports.MOOD_MORPHS = {
         noseSneerLeft: 0.3, noseSneerRight: 0.3,
         eyeSquintLeft: 0.2, eyeSquintRight: 0.2,
     },
+    fear: {
+        eyeWideLeft: 0.6, eyeWideRight: 0.6,
+        browInnerUp: 0.7, browOuterUpLeft: 0.3, browOuterUpRight: 0.3,
+        mouthStretchLeft: 0.2, mouthStretchRight: 0.2,
+    },
+    disgust: {
+        noseSneerLeft: 0.6, noseSneerRight: 0.6,
+        browDownLeft: 0.4, browDownRight: 0.4,
+        mouthShrugUpper: 0.3,
+    },
+    love: {
+        mouthSmileLeft: 0.45, mouthSmileRight: 0.45,
+        cheekSquintLeft: 0.28, cheekSquintRight: 0.28,
+        eyeSquintLeft: 0.12, eyeSquintRight: 0.12,
+        browOuterUpLeft: 0.18, browOuterUpRight: 0.18,
+    },
+    sleep: {
+        eyeBlinkLeft: 0.7, eyeBlinkRight: 0.7,
+        browInnerUp: 0.12,
+        mouthClose: 0.25,
+    },
     surprised: {
         eyeWideLeft: 0.5, eyeWideRight: 0.5,
         browInnerUp: 0.5, browOuterUpLeft: 0.4, browOuterUpRight: 0.4,
@@ -75,16 +96,6 @@ exports.MOOD_MORPHS = {
         browInnerUp: 0.45, browDownLeft: 0.25, browDownRight: 0.25,
         mouthFrownLeft: 0.2, mouthFrownRight: 0.2,
     },
-    disgust: {
-        noseSneerLeft: 0.6, noseSneerRight: 0.6,
-        browDownLeft: 0.4, browDownRight: 0.4,
-        mouthShrugUpper: 0.3,
-    },
-    fear: {
-        eyeWideLeft: 0.6, eyeWideRight: 0.6,
-        browInnerUp: 0.7, browOuterUpLeft: 0.3, browOuterUpRight: 0.3,
-        mouthStretchLeft: 0.2, mouthStretchRight: 0.2,
-    },
     exhausted: {
         eyeBlinkLeft: 0.4, eyeBlinkRight: 0.4,
         browDownLeft: 0.3, browDownRight: 0.3,

package/dist/wgpu/motionState.d.ts

@@ -0,0 +1,20 @@
+import type { MotionBoneKey, MotionKey } from '../core/avatar/motion';
+import { type MotionBone, type Quat } from '../core/avatar/motionRuntime';
+/**
+ * Procedural motion state, shared between the imperative handle and the
+ * in-scene frame loop that lazily maps skeleton bones.
+ */
+export interface MotionState {
+    /** Active motion key, or null when at rest. */
+    key: MotionKey | null;
+    /** performance.now() ms when the active motion started. */
+    startTime: number;
+    /** Lazily-scanned bones for the loaded skeleton. */
+    bones: Partial<Record<MotionBoneKey, MotionBone>> | null;
+    rest: Partial<Record<MotionBoneKey, Quat>> | null;
+    /** Timer id for pose-like motions that auto-revert to rest. */
+    autoReturnTimer: ReturnType<typeof setTimeout> | null;
+}
+export declare function createMotionState(): MotionState;
+export declare function stopMotionState(motion: MotionState): void;
+export declare function resetMotionStateForAvatarSwap(motion: MotionState): void;

package/dist/wgpu/motionState.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMotionState = createMotionState;
+exports.stopMotionState = stopMotionState;
+exports.resetMotionStateForAvatarSwap = resetMotionStateForAvatarSwap;
+const motionRuntime_1 = require("../core/avatar/motionRuntime");
+function createMotionState() {
+    return {
+        key: null,
+        startTime: 0,
+        bones: null,
+        rest: null,
+        autoReturnTimer: null,
+    };
+}
+function stopMotionState(motion) {
+    if (motion.autoReturnTimer) {
+        clearTimeout(motion.autoReturnTimer);
+        motion.autoReturnTimer = null;
+    }
+    if (motion.bones && motion.rest) {
+        (0, motionRuntime_1.restoreMotionBones)(motion.bones, motion.rest);
+    }
+    motion.key = null;
+    motion.startTime = 0;
+}
+function resetMotionStateForAvatarSwap(motion) {
+    stopMotionState(motion);
+    motion.bones = null;
+    motion.rest = null;
+}

package/dist/wgpu/patchThreeForRN.d.ts

@@ -0,0 +1,28 @@
+/**
+ * patchThreeForRN — patches Three.js loaders for React Native compatibility.
+ *
+ * Problem: GLTFLoader (three-stdlib) calls URL.createObjectURL(blob) when
+ * extracting embedded textures from a GLB's buffer views. React Native's
+ * Hermes / JSC runtime does not implement URL.createObjectURL, so every
+ * texture inside the GLB fails with "Cannot create URL for blob!".
+ *
+ * Fix strategy (3 layers):
+ *
+ *  Layer 1 — URL.createObjectURL polyfill
+ *    Instead of throwing, store the Blob in a module-level Map under a
+ *    synthetic "rnblob://<id>" key and return that key as the "URL".
+ *    URL.revokeObjectURL deletes the entry.
+ *
+ *  Layer 2 — THREE.ImageLoader patch
+ *    When ImageLoader.load() receives an "rnblob://" URL, retrieve the
+ *    stored Blob, read it as base64 via FileReader, build a "data:" URI,
+ *    then set it as img.src so expo-gl can decode it natively.
+ *
+ *  Layer 3 — THREE.TextureLoader / THREE.FileLoader safety net
+ *    Same interception for any direct TextureLoader usage and for
+ *    FileLoader which is also used internally by GLTFLoader.
+ *
+ * Call installThreeRNPatches() once at module load time, before any
+ * useGLTF / GLTFLoader usage.  Pass debug=true for verbose logging.
+ */
+export declare function installThreeRNPatches(debug?: boolean): void;