@lovelace_lol/embody 0.0.7 → 0.0.9

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.
@@ -193,11 +384,16 @@ export class RuntimeCore {
         wasm.__wbg_runtimecore_free(ptr, 0);
     }
     /**
-     * @returns {number}
+     * Validate every channel before replacing Body state. Other FACS state remains.
+     * @param {string} json
      */
-    active_transition_count() {
-        const ret = wasm.runtimecore_active_transition_count(this.__wbg_ptr);
-        return ret >>> 0;
+    apply_semantic_pose_json(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_apply_semantic_pose_json(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * @returns {number}
@@ -206,12 +402,222 @@ 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
+     * @param {string} options_json
+     * @returns {string}
+     */
+    build_clip(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_build_clip(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);
+        }
+    }
+    /**
+     * 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
+     * @param {string} json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    build_semantic_clip(name, json, options_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(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_build_semantic_clip(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);
+        }
+    }
+    /**
+     * @param {string} clip_name
+     * @param {string} channels_json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    build_typed_clip(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_build_typed_clip(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);
+        }
+    }
+    /**
+     * Captures manual semantic state; does not infer actions from a mixer pose.
+     * @returns {string}
+     */
+    capture_semantic_pose_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.runtimecore_capture_semantic_pose_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} clip_name
+     * @returns {boolean}
+     */
+    cleanup_snippet(clip_name) {
+        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_cleanup_snippet(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     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,
@@ -253,9 +659,9 @@ export class RuntimeCore {
     /**
      * Configure from a resolved profile without applying an embedded preset.
      *
-     * This path is intentionally strict so a host cannot accidentally select
-     * a profile that has no usable runtime bindings. Preset fallback remains
-     * an explicit host decision.
+     * Empty profiles and mappings that do not match the current model are
+     * non-fatal. Static imports can render before authoring any bindings,
+     * without silently substituting an embedded preset.
      * @param {string} profile_json
      * @param {string} model_json
      */
@@ -269,6 +675,42 @@ export class RuntimeCore {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * 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
+     */
+    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,
+     * translation, or viseme jaw value is currently rotating or moving.
+     * Neutral bones are omitted (no rest reset), so hosts can re-apply this
+     * after mixer playback without freezing clip-driven bones (Loom3 parity).
+     * @returns {Float32Array}
+     */
+    evaluate_active_bone_frame() {
+        const ret = wasm.runtimecore_evaluate_active_bone_frame(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Same rows as `evaluate_morph_frame_delta`, but only channels with a
+     * non-zero live value or an explicit direct override (including zero).
+     * Hosts re-apply this after mixer playback so live
+     * AU/viseme state wins over clip tracks (Loom3 parity) without resetting
+     * channels the mixer owns.
+     * @returns {Float32Array}
+     */
+    evaluate_active_morph_frame() {
+        const ret = wasm.runtimecore_evaluate_active_morph_frame(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * Packed bone FrameDelta rows: `[bone_id, px, py, pz, qx, qy, qz, qw, flags] * N`
      * flags: bit0 = has_position, bit1 = has_rotation. Composite rotations are
@@ -284,6 +726,7 @@ export class RuntimeCore {
     }
     /**
      * Packed morph FrameDelta rows: `[mesh_id, morph_target_id, value, mode] * N`
+     * Live AU/viseme/direct morph state only — clip playback is host-owned.
      * @returns {Float32Array}
      */
     evaluate_morph_frame_delta() {
@@ -292,6 +735,84 @@ export class RuntimeCore {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Emit only currently/previously owned bone properties. Position and
+     * rotation ownership are separate; inactive properties release once.
+     * @returns {Float32Array}
+     */
+    evaluate_procedural_bone_frame() {
+        const ret = wasm.runtimecore_evaluate_procedural_bone_frame(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Emit active morphs plus one neutral release for previously owned
+     * targets. Direct overrides, including explicit zero, retain ownership.
+     * Untouched targets are omitted so constant mixer tracks keep their pose.
+     * @returns {Float32Array}
+     */
+    evaluate_procedural_morph_frame() {
+        const ret = wasm.runtimecore_evaluate_procedural_morph_frame(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Scene extras for live state. Clip-driven scale/visibility/object writes
+     * are owned by the host mixer, so this returns an empty frame.
+     * @returns {string}
+     */
+    evaluate_scene_frame() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_evaluate_scene_frame(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);
+        }
+    }
+    /**
+     * Full Body property writes, including neutral reference values. Hosts use
+     * this once when an explicit pose replaces direct legacy bone edits.
+     * @returns {Float32Array}
+     */
+    evaluate_semantic_body_bone_frame() {
+        const ret = wasm.runtimecore_evaluate_semantic_body_bone_frame(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    get_animation_clips() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_get_animation_clips(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);
+        }
+    }
     /**
      * @param {number} id
      * @returns {number}
@@ -300,6 +821,41 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_get_au(this.__wbg_ptr, id);
         return ret;
     }
+    /**
+     * Stored live AU balance in [-1, 1], or neutral zero when unset or cleared.
+     * @param {number} id
+     * @returns {number}
+     */
+    get_au_balance(id) {
+        const ret = wasm.runtimecore_get_au_balance(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * Current runtime tissue strength, independent of persisted profile defaults.
+     * @param {number} id
+     * @returns {number}
+     */
+    get_au_mix_weight(id) {
+        const ret = wasm.runtimecore_get_au_mix_weight(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * Resolved Body descriptors for the configured profile/model. Model
+     * inspection and descriptor resolution are cached until reconfiguration.
+     * @returns {string}
+     */
+    get_body_controls_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.runtimecore_get_body_controls_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 {number} neg_au
      * @param {number} pos_au
@@ -309,6 +865,122 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_get_continuum(this.__wbg_ptr, neg_au, pos_au);
         return ret;
     }
+    /**
+     * Normalized hair configuration belongs to the selected profile, never an
+     * adapter fallback. Explicit empty/null mappings remain empty.
+     * @returns {string}
+     */
+    get_hair_config_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_get_hair_config_json(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);
+        }
+    }
+    /**
+     * @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}
+     */
+    get_semantic_pose_catalog_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.runtimecore_get_semantic_pose_catalog_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);
+        }
+    }
+    /**
+     * Stored direct viseme value, or zero for an unset or out-of-range slot.
+     * Host mixer output is not part of this live control state.
+     * @param {number} index
+     * @returns {number}
+     */
+    get_viseme(index) {
+        const ret = wasm.runtimecore_get_viseme(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * Stored direct viseme jaw scale, or one for an unset or out-of-range slot.
+     * @param {number} index
+     * @returns {number}
+     */
+    get_viseme_jaw_scale(index) {
+        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
+     */
+    load_animation_clips(clips_json) {
+        const ptr0 = passStringToWasm0(clips_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_load_animation_clips(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Packed rows: `[au_id, side, mesh_id, morph_target_id, weight] * N`
      * side: 0=left, 1=right, 2=center
@@ -320,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) {
@@ -385,6 +1056,112 @@ export class RuntimeCore {
         RuntimeCoreFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {string} clip_json
+     * @param {string} source
+     */
+    register_animation_clip(clip_json, source) {
+        const ptr0 = passStringToWasm0(clip_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_register_animation_clip(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Release a direct morph override so AU/viseme/mixer ownership can resume.
+     * A deliberate `set_morph(..., 0, ...)` still owns and masks the target;
+     * preview cleanup must release instead of installing a permanent zero.
+     * Target selection matches `set_morph`; returns overrides actually removed.
+     * @param {string} morph_name
+     * @param {string} mesh_names_json
+     * @returns {number}
+     */
+    release_morph(morph_name, 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_release_morph(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret >>> 0;
+    }
+    /**
+     * Index counterpart to `release_morph`, with `set_morph_index` selection.
+     * @param {number} morph_index
+     * @param {string} mesh_names_json
+     * @returns {number}
+     */
+    release_morph_index(morph_index, mesh_names_json) {
+        const ptr0 = passStringToWasm0(mesh_names_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_release_morph_index(this.__wbg_ptr, morph_index, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Release owned morphs through the old renderer binding IDs before rebind.
+     * @returns {Float32Array}
+     */
+    release_procedural_morph_frame() {
+        const ret = wasm.runtimecore_release_procedural_morph_frame(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {string} clip_name
+     * @returns {boolean}
+     */
+    remove_animation_clip(clip_name) {
+        const ptr0 = passStringToWasm0(clip_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_remove_animation_clip(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Clear each unique configured Body action and bilateral balance together.
+     * Shared facial aliases are Body actions too. Preserve other actions,
+     * visemes, direct morph overrides, and authored/current morph mix weights.
+     */
+    reset_body_controls() {
+        wasm.runtimecore_reset_body_controls(this.__wbg_ptr);
+    }
+    /**
+     * Forget ownership when renderer bindings are discarded. Before replacing
+     * bindings, apply release_procedural_morph_frame through the old IDs.
+     * Normal clear/reset deliberately retain tracking for the next frame.
+     */
+    reset_procedural_frame_tracking() {
+        wasm.runtimecore_reset_procedural_frame_tracking(this.__wbg_ptr);
+    }
+    /**
+     * 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}
+     */
+    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 {number} id
      * @param {number} value
@@ -401,8 +1178,9 @@ export class RuntimeCore {
         wasm.runtimecore_set_au_mix_weight(this.__wbg_ptr, id, weight);
     }
     /**
-     * Continuum-aware AU set. Negative values route through the configured
-     * continuum pair (e.g. eyes left/right) exactly like the legacy runtime.
+     * Manual directional command: a nonzero value owns its configured pair.
+     * Negative values select the opposite direction. Zero clears only the
+     * named AU, so releasing an inactive slider does not stop its partner.
      * @param {number} id
      * @param {number} value
      * @param {number} balance
@@ -419,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
      */
@@ -427,6 +1229,32 @@ export class RuntimeCore {
         const len0 = WASM_VECTOR_LEN;
         wasm.runtimecore_set_mixed_aus(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * @param {string} morph_name
+     * @param {number} value
+     * @param {string} mesh_names_json
+     * @returns {number}
+     */
+    set_morph(morph_name, value, 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_set_morph(this.__wbg_ptr, ptr0, len0, value, ptr1, len1);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} morph_index
+     * @param {number} value
+     * @param {string} mesh_names_json
+     * @returns {number}
+     */
+    set_morph_index(morph_index, value, mesh_names_json) {
+        const ptr0 = passStringToWasm0(mesh_names_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_set_morph_index(this.__wbg_ptr, morph_index, value, ptr0, len0);
+        return ret >>> 0;
+    }
     /**
      * @param {number} index
      * @param {number} value
@@ -448,34 +1276,44 @@ export class RuntimeCore {
         wasm.runtimecore_set_viseme_slot_count(this.__wbg_ptr, count);
     }
     /**
-     * Start (or replace) an eased AU transition. Advanced by `update`.
-     * @param {number} id
-     * @param {number} to
-     * @param {number} duration_ms
-     * @param {number} balance
+     * Compile and validate without registering a clip or changing live controls.
+     * @param {string} json
+     * @param {string} options_json
      */
-    transition_au(id, to, duration_ms, balance) {
-        wasm.runtimecore_transition_au(this.__wbg_ptr, id, to, duration_ms, balance);
-    }
-    /**
-     * @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);
+    validate_semantic_animation_json(json, options_json) {
+        const ptr0 = passStringToWasm0(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.runtimecore_validate_semantic_animation_json(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Advance all running transitions by `dt` seconds and write the eased
-     * values into the core state. Returns the number of still-active
-     * transitions so hosts know whether a frame delta re-evaluation is due.
-     * @param {number} dt_seconds
-     * @returns {number}
+     * Validate and fill optional settings without changing runtime or renderer state.
+     * @param {string} json
+     * @returns {string}
      */
-    update(dt_seconds) {
-        const ret = wasm.runtimecore_update(this.__wbg_ptr, dt_seconds);
-        return ret >>> 0;
+    validate_semantic_pose_json(json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_validate_semantic_pose_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);
+        }
     }
     /**
      * @returns {number}
@@ -522,6 +1360,40 @@ export function analyze_mesh_proportions(vertices, vertical_axis) {
     return v2;
 }
 
+/**
+ * @param {string} model_json
+ * @param {string} clips_json
+ * @param {string} profile_json
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function analyze_model_descriptor(model_json, clips_json, profile_json, options_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(model_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(clips_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.analyze_model_descriptor(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var ptr5 = ret[0];
+        var len5 = ret[1];
+        if (ret[3]) {
+            ptr5 = 0; len5 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
+    } finally {
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+
 /**
  * @returns {number}
  */
@@ -711,6 +1583,22 @@ export function compose_template_skeleton_fit_transform(fit_scale, fit_translati
     return v3;
 }
 
+/**
+ * @param {string} template_json
+ * @returns {Float64Array}
+ */
+export function compute_humanoid_skeleton_template_rest_bounds(template_json) {
+    const ptr0 = passStringToWasm0(template_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compute_humanoid_skeleton_template_rest_bounds(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * @returns {number}
  */
@@ -719,6 +1607,53 @@ export function core_abi_version() {
     return ret >>> 0;
 }
 
+/**
+ * @param {string} template_json
+ * @returns {string}
+ */
+export function create_validation_skeleton_json(template_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(template_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.create_validation_skeleton_json(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);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function default_hair_color_appearance_json() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.default_hair_color_appearance_json();
+        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);
+    }
+}
+
 /**
  * @returns {Float32Array}
  */
@@ -729,6 +1664,90 @@ export function default_hair_physics_config_values() {
     return v1;
 }
 
+/**
+ * Execute a host-neutral Embody operation using JSON in and JSON out.
+ * This keeps CLJS and other browser hosts off the Rust data structures while
+ * ensuring all profile semantics execute inside Wasm.
+ * @param {string} request_json
+ * @returns {string}
+ */
+export function embody_request(request_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(request_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.embody_request(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 {string} model_json
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function extract_humanoid_skeleton_template_json(model_json, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(model_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.extract_humanoid_skeleton_template_json(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} model_json
+ * @param {string} clips_json
+ * @returns {string}
+ */
+export function extract_model_data_json(model_json, clips_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(model_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(clips_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.extract_model_data_json(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);
+    }
+}
+
 /**
  * Padding factor for a focus target of the given max dimension.
  * @param {number} size
@@ -742,6 +1761,31 @@ export function focus_padding_factor(size, close_up_padding, zoom_padding, full_
     return ret;
 }
 
+/**
+ * @param {string} id
+ * @returns {string}
+ */
+export function get_humanoid_skeleton_template_json(id) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.get_humanoid_skeleton_template_json(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);
+    }
+}
+
 /**
  * Return the embedded preset JSON for a preset id (intake source of truth).
  * @param {string} preset_id
@@ -768,6 +1812,28 @@ export function get_preset_json(preset_id) {
     }
 }
 
+/**
+ * @returns {string}
+ */
+export function hair_color_presets_json() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.hair_color_presets_json();
+        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);
+    }
+}
+
 /**
  * @returns {number}
  */
@@ -812,6 +1878,53 @@ export function has_preset(preset_id) {
     return ret !== 0;
 }
 
+/**
+ * @param {string} template_json
+ * @returns {string}
+ */
+export function humanoid_skeleton_template_bone_names(template_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(template_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.humanoid_skeleton_template_bone_names(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);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function list_humanoid_skeleton_templates_json() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.list_humanoid_skeleton_templates_json();
+        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);
+    }
+}
+
 /**
  * Canonical embedded preset ids available inside the Wasm core.
  * @returns {string[]}
@@ -931,6 +2044,34 @@ export function normalize_camera_angle_degrees(angle) {
     return ret;
 }
 
+/**
+ * @param {string} value_json
+ * @param {string} fallback_json
+ * @returns {string}
+ */
+export function normalize_hair_color_appearance_json(value_json, fallback_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(value_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(fallback_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.normalize_hair_color_appearance_json(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 {Uint32Array} mesh_ids
  * @param {Uint32Array} morph_target_ids
@@ -1386,6 +2527,71 @@ export function validate_generated_template_fit_metadata(template_id, source_cha
     return ret >>> 0;
 }
 
+/**
+ * Resolve and validate VRM humanoid roles through profile node keys against a
+ * renderer-neutral model descriptor. This is characterization metadata only;
+ * it does not create or apply pose frame writes.
+ * @param {string} profile_json
+ * @param {string} model_json
+ * @returns {string}
+ */
+export function validate_humanoid_characterization(profile_json, model_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(model_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.validate_humanoid_characterization(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);
+    }
+}
+
+/**
+ * Validate an authored profile against a renderer-neutral model descriptor.
+ * Three.js objects are reduced to this descriptor by the thin host adapter;
+ * all mapping analysis and correction generation stays in Rust.
+ * @param {string} profile_json
+ * @param {string} model_json
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function validate_profile_model(profile_json, model_json, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(model_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.validate_profile_model(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);
+    }
+}
+
 /**
  * World-space camera direction for a model-relative camera angle.
  * `model_quat` is the model's world quaternion `[x, y, z, w]`
@@ -1442,15 +2648,29 @@ 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);
 }
 
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -1478,6 +2698,14 @@ function getFloat32ArrayMemory0() {
     return cachedFloat32ArrayMemory0;
 }
 
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
@@ -1602,6 +2830,7 @@ function __wbg_finalize_init(instance, module) {
     wasmModule = module;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();