@lovelace_lol/embody 0.0.8 → 0.0.10

package/dist/wasm/embody_wasm.js

@@ -177,6 +177,197 @@ export class HairPhysicsSolver {
 }
 if (Symbol.dispose) HairPhysicsSolver.prototype[Symbol.dispose] = HairPhysicsSolver.prototype.free;
 
+/**
+ * A command protocol for one bound model/profile, not an animation evaluator.
+ * Dispatch each returned batch in order, then feed native events to `notify`.
+ * Before `free`, dispatch `dispose` to release engine-owned resources.
+ */
+export class NativePlaybackSession {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NativePlaybackSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_nativeplaybacksession_free(ptr, 0);
+    }
+    /**
+     * @param {string} handle
+     * @param {string} control_json
+     * @returns {string}
+     */
+    control(handle, control_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(control_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.nativeplaybacksession_control(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    dispose() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.nativeplaybacksession_dispose(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    constructor() {
+        const ret = wasm.nativeplaybacksession_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        NativePlaybackSessionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Late/duplicate/foreign well-formed notifications return an empty batch.
+     * A native error after held completion releases resources without emitting
+     * a second terminal event.
+     * @param {string} native_event_json
+     * @returns {string}
+     */
+    notify(native_event_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(native_event_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.nativeplaybacksession_notify(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Takes concrete ClipIR from RuntimeCore compilation or baked-clip intake.
+     * Semantic strength must already be compiled into the clip; weight is the
+     * native action's contribution and never changes compiled samples.
+     * @param {string} clip_json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    play(clip_json, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(clip_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.nativeplaybacksession_play(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Always starts a new generation, even if the identity labels are reused.
+     * Hosts must call this on every model/profile replacement before new play.
+     * @param {string} model_key
+     * @param {string} profile_key
+     * @returns {string}
+     */
+    rebind(model_key, profile_key) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(model_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(profile_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.nativeplaybacksession_rebind(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Replace authored samples without resetting native time, loop progress or
+     * the request identity. A held request remains terminal after a pose edit.
+     * @param {string} handle
+     * @param {string} clip_json
+     * @returns {string}
+     */
+    replace_clip(handle, clip_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(clip_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.nativeplaybacksession_replace_clip(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) NativePlaybackSession.prototype[Symbol.dispose] = NativePlaybackSession.prototype.free;
+
 /**
  * Host-neutral live morph runtime. Owns AU/viseme/mix state and emits packed
  * morph frame deltas. Engine objects never enter this struct.
@@ -192,13 +383,6 @@ export class RuntimeCore {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_runtimecore_free(ptr, 0);
     }
-    /**
-     * @returns {number}
-     */
-    active_transition_count() {
-        const ret = wasm.runtimecore_active_transition_count(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * Validate every channel before replacing Body state. Other FACS state remains.
      * @param {string} json
@@ -218,6 +402,13 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_au_morph_binding_stride();
         return ret >>> 0;
     }
+    /**
+     * Begin one host command; its concrete destinations determine which native
+     * actions are replaced. Unrelated targets keep their existing playback.
+     */
+    begin_live_command() {
+        wasm.runtimecore_begin_live_command(this.__wbg_ptr);
+    }
     /**
      * @param {string} clip_name
      * @param {string} curves_json
@@ -248,6 +439,95 @@ export class RuntimeCore {
             wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
         }
     }
+    /**
+     * Compile the configured gravity response directly to concrete morph
+     * tracks. Three owns interpolation from the captured initial scene pose.
+     * @param {string} name
+     * @param {number} pitch
+     * @param {number} duration_seconds
+     * @param {string} options_json
+     * @returns {string}
+     */
+    build_hair_gravity_clip(name, pitch, duration_seconds, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_build_hair_gravity_clip(this.__wbg_ptr, ptr0, len0, pitch, duration_seconds, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Compile the current live semantic controls into ordinary native tracks.
+     * The connector captures inherited starts at play time; Rust never ticks
+     * or interpolates these samples. Empty output relinquishes all live tracks.
+     * @param {string} name
+     * @param {number} duration_seconds
+     * @returns {string}
+     */
+    build_live_clip(name, duration_seconds) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_build_live_clip(this.__wbg_ptr, ptr0, len0, duration_seconds);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Compile relinquished live targets back to their reference values. Run
+     * this clip with finalPose=release so native ownership ends at completion.
+     * @param {string} name
+     * @param {string} previous_clip_json
+     * @param {number} duration_seconds
+     * @returns {string}
+     */
+    build_live_release_clip(name, previous_clip_json, duration_seconds) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_clip_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_build_live_release_clip(this.__wbg_ptr, ptr0, len0, ptr1, len1, duration_seconds);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
     /**
      * Compile semantic motions and optional facial curves together without changing live state.
      * @param {string} name
@@ -338,9 +618,6 @@ export class RuntimeCore {
     clear() {
         wasm.runtimecore_clear(this.__wbg_ptr);
     }
-    clear_transitions() {
-        wasm.runtimecore_clear_transitions(this.__wbg_ptr);
-    }
     /**
      * Configure the core from the profile and model descriptor JSON hosts
      * already have. All binding compilation (mesh/morph/bone name resolution,
@@ -399,54 +676,13 @@ export class RuntimeCore {
         }
     }
     /**
-     * Host-owned crossfade marker. Rust does not lerp; the host mixer should fade.
-     * @param {string} clip_name
-     * @param {number} _duration
-     * @param {string} options_json
-     * @returns {string}
+     * Carry canonical controls across a renderer rebind. Model-local IDs and
+     * reference values belong to the new binding and are never copied.
+     * @param {RuntimeCore} previous
      */
-    crossfade_to(clip_name, _duration, options_json) {
-        let deferred4_0;
-        let deferred4_1;
-        try {
-            const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            const ret = wasm.runtimecore_crossfade_to(this.__wbg_ptr, ptr0, len0, _duration, ptr1, len1);
-            var ptr3 = ret[0];
-            var len3 = ret[1];
-            if (ret[3]) {
-                ptr3 = 0; len3 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred4_0 = ptr3;
-            deferred4_1 = len3;
-            return getStringFromWasm0(ptr3, len3);
-        } finally {
-            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    drain_animation_events() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.runtimecore_drain_animation_events(this.__wbg_ptr);
-            var ptr1 = ret[0];
-            var len1 = ret[1];
-            if (ret[3]) {
-                ptr1 = 0; len1 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred2_0 = ptr1;
-            deferred2_1 = len1;
-            return getStringFromWasm0(ptr1, len1);
-        } finally {
-            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-        }
+    copy_live_state_from(previous) {
+        _assertClass(previous, RuntimeCore);
+        wasm.runtimecore_copy_live_state_from(this.__wbg_ptr, previous.__wbg_ptr);
     }
     /**
      * Same rows as `evaluate_bone_frame_delta`, but only bones an active AU,
@@ -577,30 +813,6 @@ export class RuntimeCore {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
-    /**
-     * @param {string} clip_name
-     * @returns {string}
-     */
-    get_animation_state(clip_name) {
-        let deferred3_0;
-        let deferred3_1;
-        try {
-            const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.runtimecore_get_animation_state(this.__wbg_ptr, ptr0, len0);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
-            if (ret[3]) {
-                ptr2 = 0; len2 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
-        } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-        }
-    }
     /**
      * @param {number} id
      * @returns {number}
@@ -654,13 +866,15 @@ export class RuntimeCore {
         return ret;
     }
     /**
+     * Normalized hair configuration belongs to the selected profile, never an
+     * adapter fallback. Explicit empty/null mappings remain empty.
      * @returns {string}
      */
-    get_playing_animations() {
+    get_hair_config_json() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.runtimecore_get_playing_animations(this.__wbg_ptr);
+            const ret = wasm.runtimecore_get_hair_config_json(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -674,6 +888,30 @@ export class RuntimeCore {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * @param {string} available_json
+     * @returns {string}
+     */
+    get_missing_hair_morph_targets_json(available_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(available_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_get_missing_hair_morph_targets_json(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * Profile-derived motions and resolved model support for prompt/pose editors.
      * @returns {string}
@@ -709,6 +947,29 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_get_viseme_jaw_scale(this.__wbg_ptr, index);
         return ret;
     }
+    /**
+     * @param {number} au_id
+     * @returns {boolean}
+     */
+    has_left_right_bones(au_id) {
+        const ret = wasm.runtimecore_has_left_right_bones(this.__wbg_ptr, au_id);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    live_command_targets_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.runtimecore_live_command_targets_json(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * @param {string} clips_json
      */
@@ -731,7 +992,6 @@ export class RuntimeCore {
         wasm.runtimecore_load_au_morph_bindings(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Packed rows: `[bone_id, px, py, pz, qx, qy, qz, qw] * N`
      * @param {Float32Array} values
      */
     load_bone_rest_transforms(values) {
@@ -782,119 +1042,19 @@ export class RuntimeCore {
      * Packed rows: `[viseme_index, mesh_id, morph_target_id, weight] * N`
      * @param {Float32Array} values
      */
-    load_viseme_morph_bindings(values) {
-        const ptr0 = passArrayF32ToWasm0(values, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_load_viseme_morph_bindings(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @param {number} viseme_slot_count
-     */
-    constructor(viseme_slot_count) {
-        const ret = wasm.runtimecore_new(viseme_slot_count);
-        this.__wbg_ptr = ret;
-        RuntimeCoreFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    pause_all_animations() {
-        wasm.runtimecore_pause_all_animations(this.__wbg_ptr);
-    }
-    /**
-     * @param {string} clip_name
-     */
-    pause_animation(clip_name) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_pause_animation(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * Registry lookup only. Host animation libraries own play/lerp; this returns
-     * a host-owned action id marker when the clip exists in the registry.
-     * @param {string} clip_name
-     * @param {string} _options_json
-     * @returns {string}
-     */
-    play_animation(clip_name, _options_json) {
-        let deferred4_0;
-        let deferred4_1;
-        try {
-            const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(_options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            const ret = wasm.runtimecore_play_animation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-            var ptr3 = ret[0];
-            var len3 = ret[1];
-            if (ret[3]) {
-                ptr3 = 0; len3 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred4_0 = ptr3;
-            deferred4_1 = len3;
-            return getStringFromWasm0(ptr3, len3);
-        } finally {
-            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
-        }
-    }
-    /**
-     * @param {string} clip_name
-     * @param {string} curves_json
-     * @param {string} options_json
-     * @returns {string}
-     */
-    play_snippet(clip_name, curves_json, options_json) {
-        let deferred5_0;
-        let deferred5_1;
-        try {
-            const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(curves_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len2 = WASM_VECTOR_LEN;
-            const ret = wasm.runtimecore_play_snippet(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
-            var ptr4 = ret[0];
-            var len4 = ret[1];
-            if (ret[3]) {
-                ptr4 = 0; len4 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred5_0 = ptr4;
-            deferred5_1 = len4;
-            return getStringFromWasm0(ptr4, len4);
-        } finally {
-            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
-        }
+    load_viseme_morph_bindings(values) {
+        const ptr0 = passArrayF32ToWasm0(values, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.runtimecore_load_viseme_morph_bindings(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {string} clip_name
-     * @param {string} channels_json
-     * @param {string} options_json
-     * @returns {string}
+     * @param {number} viseme_slot_count
      */
-    play_typed_snippet(clip_name, channels_json, options_json) {
-        let deferred5_0;
-        let deferred5_1;
-        try {
-            const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(channels_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len2 = WASM_VECTOR_LEN;
-            const ret = wasm.runtimecore_play_typed_snippet(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
-            var ptr4 = ret[0];
-            var len4 = ret[1];
-            if (ret[3]) {
-                ptr4 = 0; len4 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred5_0 = ptr4;
-            deferred5_1 = len4;
-            return getStringFromWasm0(ptr4, len4);
-        } finally {
-            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
-        }
+    constructor(viseme_slot_count) {
+        const ret = wasm.runtimecore_new(viseme_slot_count);
+        this.__wbg_ptr = ret;
+        RuntimeCoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * @param {string} clip_json
@@ -975,110 +1135,33 @@ export class RuntimeCore {
     reset_procedural_frame_tracking() {
         wasm.runtimecore_reset_procedural_frame_tracking(this.__wbg_ptr);
     }
-    resume_all_animations() {
-        wasm.runtimecore_resume_all_animations(this.__wbg_ptr);
-    }
-    /**
-     * @param {string} clip_name
-     */
-    resume_animation(clip_name) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_resume_animation(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @param {string} clip_name
-     * @param {number} time
-     */
-    seek_animation(clip_name, time) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_seek_animation(this.__wbg_ptr, ptr0, len0, time);
-    }
-    /**
-     * @param {string} clip_name
-     * @param {string} blend_mode
-     */
-    set_animation_blend_mode(clip_name, blend_mode) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(blend_mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.runtimecore_set_animation_blend_mode(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @param {string} clip_name
-     * @param {string} easing
-     */
-    set_animation_easing(clip_name, easing) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(easing, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.runtimecore_set_animation_easing(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @param {string} clip_name
-     * @param {number} intensity
-     */
-    set_animation_intensity(clip_name, intensity) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_set_animation_intensity(this.__wbg_ptr, ptr0, len0, intensity);
-    }
     /**
-     * @param {string} clip_name
-     * @param {string} loop_mode
+     * The adapter supplies native quaternion samples and scene/reference
+     * transforms; the profile resolves which tracks represent head motion.
+     * @param {string} tracks_json
+     * @param {boolean} additive
+     * @returns {string}
      */
-    set_animation_loop_mode(clip_name, loop_mode) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(loop_mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.runtimecore_set_animation_loop_mode(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    resolve_hair_motion_json(tracks_json, additive) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(tracks_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_resolve_hair_motion_json(this.__wbg_ptr, ptr0, len0, additive);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
-    /**
-     * @param {string} clip_name
-     * @param {number} repeat_count
-     */
-    set_animation_repeat_count(clip_name, repeat_count) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_set_animation_repeat_count(this.__wbg_ptr, ptr0, len0, repeat_count);
-    }
-    /**
-     * @param {string} clip_name
-     * @param {boolean} reverse
-     */
-    set_animation_reverse(clip_name, reverse) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_set_animation_reverse(this.__wbg_ptr, ptr0, len0, reverse);
-    }
-    /**
-     * @param {string} clip_name
-     * @param {number} speed
-     */
-    set_animation_speed(clip_name, speed) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_set_animation_speed(this.__wbg_ptr, ptr0, len0, speed);
-    }
-    /**
-     * @param {number} time_scale
-     */
-    set_animation_time_scale(time_scale) {
-        wasm.runtimecore_set_animation_time_scale(this.__wbg_ptr, time_scale);
-    }
     /**
      * @param {number} id
      * @param {number} value
@@ -1114,6 +1197,30 @@ export class RuntimeCore {
     set_continuum(neg_au, pos_au, value, balance) {
         wasm.runtimecore_set_continuum(this.__wbg_ptr, neg_au, pos_au, value, balance);
     }
+    /**
+     * @param {string} update_json
+     * @returns {string}
+     */
+    set_hair_config_json(update_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(update_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_set_hair_config_json(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * @param {Uint32Array} ids
      */
@@ -1168,93 +1275,6 @@ export class RuntimeCore {
     set_viseme_slot_count(count) {
         wasm.runtimecore_set_viseme_slot_count(this.__wbg_ptr, count);
     }
-    stop_all_animations() {
-        wasm.runtimecore_stop_all_animations(this.__wbg_ptr);
-    }
-    /**
-     * @param {string} clip_name
-     */
-    stop_animation(clip_name) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.runtimecore_stop_animation(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * Set an AU immediately. Duration is ignored — host mixers own timed fades.
-     * @param {number} id
-     * @param {number} to
-     * @param {number} _duration_ms
-     * @param {number} balance
-     */
-    transition_au(id, to, _duration_ms, balance) {
-        wasm.runtimecore_transition_au(this.__wbg_ptr, id, to, _duration_ms, balance);
-    }
-    /**
-     * Set morph(s) immediately. Duration is ignored — host mixers own timed fades.
-     * @param {string} morph_name
-     * @param {number} to
-     * @param {number} _duration_ms
-     * @param {string} mesh_names_json
-     * @returns {number}
-     */
-    transition_morph(morph_name, to, _duration_ms, mesh_names_json) {
-        const ptr0 = passStringToWasm0(morph_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(mesh_names_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.runtimecore_transition_morph(this.__wbg_ptr, ptr0, len0, to, _duration_ms, ptr1, len1);
-        return ret >>> 0;
-    }
-    /**
-     * Set morph index target(s) immediately. Duration is ignored.
-     * @param {number} morph_index
-     * @param {number} to
-     * @param {number} _duration_ms
-     * @param {string} mesh_names_json
-     * @returns {number}
-     */
-    transition_morph_index(morph_index, to, _duration_ms, mesh_names_json) {
-        const ptr0 = passStringToWasm0(mesh_names_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.runtimecore_transition_morph_index(this.__wbg_ptr, morph_index, to, _duration_ms, ptr0, len0);
-        return ret >>> 0;
-    }
-    /**
-     * Set a viseme immediately. Duration is ignored — host mixers own timed fades.
-     * @param {number} index
-     * @param {number} to
-     * @param {number} _duration_ms
-     * @param {number} jaw_scale
-     */
-    transition_viseme(index, to, _duration_ms, jaw_scale) {
-        wasm.runtimecore_transition_viseme(this.__wbg_ptr, index, to, _duration_ms, jaw_scale);
-    }
-    /**
-     * Tick hook for hosts. Clip playback/lerp lives in the host animation
-     * library; Rust only exposes live AU/viseme state for packed frames.
-     * @param {number} _dt_seconds
-     * @returns {number}
-     */
-    update(_dt_seconds) {
-        const ret = wasm.runtimecore_update(this.__wbg_ptr, _dt_seconds);
-        return ret >>> 0;
-    }
-    /**
-     * @param {string} clip_name
-     * @param {string} params_json
-     * @returns {boolean}
-     */
-    update_clip_params(clip_name, params_json) {
-        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(params_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.runtimecore_update_clip_params(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] !== 0;
-    }
     /**
      * Compile and validate without registering a clip or changing live controls.
      * @param {string} json
@@ -2273,14 +2293,6 @@ export function sample_marker_bezier_curve(start, end, segments) {
     return v3;
 }
 
-/**
- * @returns {number}
- */
-export function screen_space_gaze_solution_stride() {
-    const ret = wasm.screen_space_gaze_solution_stride();
-    return ret >>> 0;
-}
-
 /**
  * Separates overlapping marker endpoints while preserving each marker's
  * surface anchor and leader-line length.
@@ -2437,193 +2449,6 @@ export function solve_morph_batch(values, balances, mix_weights) {
     return v4;
 }
 
-/**
- * Solve a screen-space eye target against rendered-camera and character-eye
- * geometry using the profile's authored AU rotation limits.
- *
- * Output layout (14 floats): combined target x/y, eye target x/y, head target
- * x/y, total yaw/pitch degrees, camera-center yaw/pitch degrees, eye-to-camera
- * distance, and viewer-target world x/y/z.
- *
- * The profile must describe the active rig and calibrated semantic yaw/pitch
- * axes: neutral forward is model +Z, up is +Y, and head yaw precedes pitch.
- * Bone availability/rest and optical-axis calibration are not encoded by this
- * ABI. Missing or morph-only AUs have no inferred angular capacity. Shared eye
- * outputs cannot represent vergence or independently calibrated eye ranges.
- * Head follow is participation from model-neutral +Z toward the shared target;
- * zero prefers neutral, with additional head movement allowed for eye overflow.
- * @param {string} profile_json
- * @param {Float32Array} screen_target
- * @param {Float32Array} camera_position
- * @param {Float32Array} camera_quaternion
- * @param {Float32Array} gaze_origin
- * @param {Float32Array} model_quaternion
- * @param {number} vertical_fov_degrees
- * @param {number} aspect
- * @param {boolean} eyes_enabled
- * @param {boolean} head_enabled
- * @param {number} head_follow_fraction
- * @returns {Float32Array}
- */
-export function solve_profile_screen_space_gaze(profile_json, screen_target, camera_position, camera_quaternion, gaze_origin, model_quaternion, vertical_fov_degrees, aspect, eyes_enabled, head_enabled, head_follow_fraction) {
-    const ptr0 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF32ToWasm0(screen_target, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArrayF32ToWasm0(camera_position, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArrayF32ToWasm0(camera_quaternion, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ptr4 = passArrayF32ToWasm0(gaze_origin, wasm.__wbindgen_malloc);
-    const len4 = WASM_VECTOR_LEN;
-    const ptr5 = passArrayF32ToWasm0(model_quaternion, wasm.__wbindgen_malloc);
-    const len5 = WASM_VECTOR_LEN;
-    const ret = wasm.solve_profile_screen_space_gaze(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, vertical_fov_degrees, aspect, eyes_enabled, head_enabled, head_follow_fraction);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v7 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v7;
-}
-
-/**
- * Normalized tracking controls span the active profile's signed head AU range
- * (or eye range with the head disabled). At full head participation, +/-1 on
- * an aligned display axis reaches the same rotation as its AU at intensity 1.
- * Zero input retains the camera bearing, bounded by that range. Camera roll
- * rotates display axes into the model frame. X/Y are clamped to [-1, 1]; Z is
- * finite-target depth in meters and does not attenuate angular movement.
- * Pass 1 for full head participation; smaller explicit fractions retain the
- * existing allocation policy. Output layout matches the physical gaze solvers.
- * @param {string} profile_json
- * @param {Float32Array} tracking_target
- * @param {Float32Array} camera_position
- * @param {Float32Array} camera_quaternion
- * @param {Float32Array} gaze_origin
- * @param {Float32Array} model_quaternion
- * @param {boolean} eyes_enabled
- * @param {boolean} head_enabled
- * @param {number} head_follow_fraction
- * @param {boolean} lock_head_to_camera
- * @param {number} world_units_per_meter
- * @returns {Float32Array}
- */
-export function solve_profile_tracking_gaze(profile_json, tracking_target, camera_position, camera_quaternion, gaze_origin, model_quaternion, eyes_enabled, head_enabled, head_follow_fraction, lock_head_to_camera, world_units_per_meter) {
-    const ptr0 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF32ToWasm0(tracking_target, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArrayF32ToWasm0(camera_position, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArrayF32ToWasm0(camera_quaternion, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ptr4 = passArrayF32ToWasm0(gaze_origin, wasm.__wbindgen_malloc);
-    const len4 = WASM_VECTOR_LEN;
-    const ptr5 = passArrayF32ToWasm0(model_quaternion, wasm.__wbindgen_malloc);
-    const len5 = WASM_VECTOR_LEN;
-    const ret = wasm.solve_profile_tracking_gaze(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, eyes_enabled, head_enabled, head_follow_fraction, lock_head_to_camera, world_units_per_meter);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v7 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v7;
-}
-
-/**
- * Solve a webcam/user target against the rendered camera. `viewer_target` is
- * x/y in webcam NDC and z as estimated viewer distance behind the rendered
- * camera in the same units as `camera_position` and `gaze_origin`. Hosts must
- * convert estimated meters to scene units before calling. Zero x/y extends the
- * eye-to-camera bearing; camera-right/up offsets retain the viewer projection
- * without making eye contact depend on where the eyes sit in the image.
- * `lock_head_to_camera` prefers the camera bearing while eyes can reach; it
- * allows head overflow correction and follows the viewer with eyes disabled.
- * Without that explicit lock, head follow participates from model-neutral +Z
- * toward the shared target. A zero follow fraction does not imply camera lock.
- * New consumers with metric viewer depth should use
- * `solve_profile_viewer_space_gaze_scaled` to supply the scene conversion.
- * @param {string} profile_json
- * @param {Float32Array} viewer_target
- * @param {Float32Array} camera_position
- * @param {Float32Array} camera_quaternion
- * @param {Float32Array} gaze_origin
- * @param {Float32Array} model_quaternion
- * @param {number} viewer_vertical_fov_degrees
- * @param {number} viewer_aspect
- * @param {boolean} eyes_enabled
- * @param {boolean} head_enabled
- * @param {number} head_follow_fraction
- * @param {boolean} lock_head_to_camera
- * @returns {Float32Array}
- */
-export function solve_profile_viewer_space_gaze(profile_json, viewer_target, camera_position, camera_quaternion, gaze_origin, model_quaternion, viewer_vertical_fov_degrees, viewer_aspect, eyes_enabled, head_enabled, head_follow_fraction, lock_head_to_camera) {
-    const ptr0 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF32ToWasm0(viewer_target, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArrayF32ToWasm0(camera_position, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArrayF32ToWasm0(camera_quaternion, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ptr4 = passArrayF32ToWasm0(gaze_origin, wasm.__wbindgen_malloc);
-    const len4 = WASM_VECTOR_LEN;
-    const ptr5 = passArrayF32ToWasm0(model_quaternion, wasm.__wbindgen_malloc);
-    const len5 = WASM_VECTOR_LEN;
-    const ret = wasm.solve_profile_viewer_space_gaze(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, viewer_vertical_fov_degrees, viewer_aspect, eyes_enabled, head_enabled, head_follow_fraction, lock_head_to_camera);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v7 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v7;
-}
-
-/**
- * Solve a webcam/user target with an explicit scene-unit conversion.
- * `viewer_target` x/y are normalized webcam coordinates and z is estimated
- * viewer distance in meters. `world_units_per_meter` converts both that depth
- * and its projected lateral offsets into the units of `camera_position` and
- * `gaze_origin`. Positive finite scales are accepted; malformed scales use 1.
- * The output layout and head/eye allocation match the unscaled export.
- * @param {string} profile_json
- * @param {Float32Array} viewer_target
- * @param {Float32Array} camera_position
- * @param {Float32Array} camera_quaternion
- * @param {Float32Array} gaze_origin
- * @param {Float32Array} model_quaternion
- * @param {number} viewer_vertical_fov_degrees
- * @param {number} viewer_aspect
- * @param {boolean} eyes_enabled
- * @param {boolean} head_enabled
- * @param {number} head_follow_fraction
- * @param {boolean} lock_head_to_camera
- * @param {number} world_units_per_meter
- * @returns {Float32Array}
- */
-export function solve_profile_viewer_space_gaze_scaled(profile_json, viewer_target, camera_position, camera_quaternion, gaze_origin, model_quaternion, viewer_vertical_fov_degrees, viewer_aspect, eyes_enabled, head_enabled, head_follow_fraction, lock_head_to_camera, world_units_per_meter) {
-    const ptr0 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF32ToWasm0(viewer_target, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArrayF32ToWasm0(camera_position, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArrayF32ToWasm0(camera_quaternion, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ptr4 = passArrayF32ToWasm0(gaze_origin, wasm.__wbindgen_malloc);
-    const len4 = WASM_VECTOR_LEN;
-    const ptr5 = passArrayF32ToWasm0(model_quaternion, wasm.__wbindgen_malloc);
-    const len5 = WASM_VECTOR_LEN;
-    const ret = wasm.solve_profile_viewer_space_gaze_scaled(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, viewer_vertical_fov_degrees, viewer_aspect, eyes_enabled, head_enabled, head_follow_fraction, lock_head_to_camera, world_units_per_meter);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v7 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v7;
-}
-
 /**
  * Solve a uniform scale and translation for placing a template skeleton inside a mesh.
  *
@@ -2823,10 +2648,19 @@ const CameraOrbitFinalization = (typeof FinalizationRegistry === 'undefined')
 const HairPhysicsSolverFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hairphysicssolver_free(ptr, 1));
+const NativePlaybackSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_nativeplaybacksession_free(ptr, 1));
 const RuntimeCoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_runtimecore_free(ptr, 1));
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function getArrayF32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);