@lovelace_lol/embody 0.0.6 → 0.0.8

package/dist/wasm/embody_wasm.js

@@ -199,6 +199,18 @@ export class RuntimeCore {
         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
+     */
+    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,6 +218,123 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_au_morph_binding_stride();
         return ret >>> 0;
     }
+    /**
+     * @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 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);
     }
@@ -253,9 +382,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 +398,83 @@ export class RuntimeCore {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * 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}
+     */
+    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);
+        }
+    }
+    /**
+     * 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 +490,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 +499,108 @@ 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 {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}
@@ -300,6 +609,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 +653,73 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_get_continuum(this.__wbg_ptr, neg_au, pos_au);
         return ret;
     }
+    /**
+     * @returns {string}
+     */
+    get_playing_animations() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_get_playing_animations(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);
+        }
+    }
+    /**
+     * 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 {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
@@ -385,6 +796,289 @@ export class RuntimeCore {
         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);
+        }
+    }
+    /**
+     * @param {string} clip_name
+     * @param {string} channels_json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    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);
+        }
+    }
+    /**
+     * @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);
+    }
+    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
+     */
+    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]);
+        }
+    }
+    /**
+     * @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
@@ -401,8 +1095,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
@@ -428,17 +1123,43 @@ export class RuntimeCore {
         wasm.runtimecore_set_mixed_aus(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {number} index
+     * @param {string} morph_name
      * @param {number} value
+     * @param {string} mesh_names_json
+     * @returns {number}
      */
-    set_viseme(index, value) {
-        wasm.runtimecore_set_viseme(this.__wbg_ptr, index, value);
+    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} index
-     * @param {number} jaw_scale
+     * @param {number} morph_index
+     * @param {number} value
+     * @param {string} mesh_names_json
+     * @returns {number}
      */
-    set_viseme_jaw_scale(index, jaw_scale) {
+    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
+     */
+    set_viseme(index, value) {
+        wasm.runtimecore_set_viseme(this.__wbg_ptr, index, value);
+    }
+    /**
+     * @param {number} index
+     * @param {number} jaw_scale
+     */
+    set_viseme_jaw_scale(index, jaw_scale) {
         wasm.runtimecore_set_viseme_jaw_scale(this.__wbg_ptr, index, jaw_scale);
     }
     /**
@@ -447,36 +1168,133 @@ 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);
+    }
     /**
-     * Start (or replace) an eased AU transition. Advanced by `update`.
+     * Set an AU immediately. Duration is ignored — host mixers own timed fades.
      * @param {number} id
      * @param {number} to
-     * @param {number} duration_ms
+     * @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);
+    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} _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);
+    transition_viseme(index, to, _duration_ms, jaw_scale) {
+        wasm.runtimecore_transition_viseme(this.__wbg_ptr, index, to, _duration_ms, jaw_scale);
     }
     /**
-     * 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
+     * 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);
+    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
+     * @param {string} options_json
+     */
+    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]);
+        }
+    }
+    /**
+     * Validate and fill optional settings without changing runtime or renderer state.
+     * @param {string} json
+     * @returns {string}
+     */
+    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 +1340,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}
  */
@@ -621,17 +1473,285 @@ export function camera_flight_sample_stride() {
 }
 
 /**
- * Compile a clip track input (JSON) into host-neutral ClipIR JSON.
- * @param {string} input_json
+ * Compile a clip track input (JSON) into host-neutral ClipIR JSON.
+ * @param {string} input_json
+ * @returns {string}
+ */
+export function compile_clip(input_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_clip(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);
+    }
+}
+
+/**
+ * Compile named intensity curves (JSON) into host-neutral ClipIR JSON.
+ * @param {string} input_json
+ * @returns {string}
+ */
+export function compile_clip_curves(input_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.compile_clip_curves(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);
+    }
+}
+
+/**
+ * Compose user-facing manual adjustments onto a solved skeleton fit.
+ *
+ * `fit` must start with [scale, translate_x, translate_y, translate_z]. The
+ * output preserves those four fields after multiplying scale and adding offsets.
+ * @param {Float32Array} fit
+ * @param {number} scale_multiplier
+ * @param {number} offset_x
+ * @param {number} offset_y
+ * @param {number} offset_z
+ * @returns {Float32Array}
+ */
+export function compose_template_fit_adjustment(fit, scale_multiplier, offset_x, offset_y, offset_z) {
+    const ptr0 = passArrayF32ToWasm0(fit, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compose_template_fit_adjustment(ptr0, len0, scale_multiplier, offset_x, offset_y, offset_z);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * @param {number} fit_scale
+ * @param {Float32Array} fit_translation
+ * @param {number} manual_scale
+ * @param {Float32Array} manual_translation
+ * @returns {Float32Array}
+ */
+export function compose_template_skeleton_fit_transform(fit_scale, fit_translation, manual_scale, manual_translation) {
+    const ptr0 = passArrayF32ToWasm0(fit_translation, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(manual_translation, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compose_template_skeleton_fit_transform(fit_scale, ptr0, len0, manual_scale, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    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}
+ */
+export function core_abi_version() {
+    const ret = wasm.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}
+ */
+export function default_hair_physics_config_values() {
+    const ret = wasm.default_hair_physics_config_values();
+    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    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
+ * @param {number} close_up_padding
+ * @param {number} zoom_padding
+ * @param {number} full_body_padding
+ * @returns {number}
+ */
+export function focus_padding_factor(size, close_up_padding, zoom_padding, full_body_padding) {
+    const ret = wasm.focus_padding_factor(size, close_up_padding, zoom_padding, full_body_padding);
+    return ret;
+}
+
+/**
+ * @param {string} id
  * @returns {string}
  */
-export function compile_clip(input_json) {
+export function get_humanoid_skeleton_template_json(id) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compile_clip(ptr0, len0);
+        const ret = wasm.get_humanoid_skeleton_template_json(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -647,17 +1767,17 @@ export function compile_clip(input_json) {
 }
 
 /**
- * Compile named intensity curves (JSON) into host-neutral ClipIR JSON.
- * @param {string} input_json
+ * Return the embedded preset JSON for a preset id (intake source of truth).
+ * @param {string} preset_id
  * @returns {string}
  */
-export function compile_clip_curves(input_json) {
+export function get_preset_json(preset_id) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passStringToWasm0(input_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(preset_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compile_clip_curves(ptr0, len0);
+        const ret = wasm.get_preset_json(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -673,98 +1793,24 @@ export function compile_clip_curves(input_json) {
 }
 
 /**
- * Compose user-facing manual adjustments onto a solved skeleton fit.
- *
- * `fit` must start with [scale, translate_x, translate_y, translate_z]. The
- * output preserves those four fields after multiplying scale and adding offsets.
- * @param {Float32Array} fit
- * @param {number} scale_multiplier
- * @param {number} offset_x
- * @param {number} offset_y
- * @param {number} offset_z
- * @returns {Float32Array}
- */
-export function compose_template_fit_adjustment(fit, scale_multiplier, offset_x, offset_y, offset_z) {
-    const ptr0 = passArrayF32ToWasm0(fit, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.compose_template_fit_adjustment(ptr0, len0, scale_multiplier, offset_x, offset_y, offset_z);
-    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v2;
-}
-
-/**
- * @param {number} fit_scale
- * @param {Float32Array} fit_translation
- * @param {number} manual_scale
- * @param {Float32Array} manual_translation
- * @returns {Float32Array}
- */
-export function compose_template_skeleton_fit_transform(fit_scale, fit_translation, manual_scale, manual_translation) {
-    const ptr0 = passArrayF32ToWasm0(fit_translation, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF32ToWasm0(manual_translation, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.compose_template_skeleton_fit_transform(fit_scale, ptr0, len0, manual_scale, ptr1, len1);
-    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v3;
-}
-
-/**
- * @returns {number}
- */
-export function core_abi_version() {
-    const ret = wasm.core_abi_version();
-    return ret >>> 0;
-}
-
-/**
- * @returns {Float32Array}
- */
-export function default_hair_physics_config_values() {
-    const ret = wasm.default_hair_physics_config_values();
-    var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v1;
-}
-
-/**
- * Padding factor for a focus target of the given max dimension.
- * @param {number} size
- * @param {number} close_up_padding
- * @param {number} zoom_padding
- * @param {number} full_body_padding
- * @returns {number}
- */
-export function focus_padding_factor(size, close_up_padding, zoom_padding, full_body_padding) {
-    const ret = wasm.focus_padding_factor(size, close_up_padding, zoom_padding, full_body_padding);
-    return ret;
-}
-
-/**
- * Return the embedded preset JSON for a preset id (intake source of truth).
- * @param {string} preset_id
  * @returns {string}
  */
-export function get_preset_json(preset_id) {
-    let deferred3_0;
-    let deferred3_1;
+export function hair_color_presets_json() {
+    let deferred2_0;
+    let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(preset_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.get_preset_json(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ret = wasm.hair_color_presets_json();
+        var ptr1 = ret[0];
+        var len1 = ret[1];
         if (ret[3]) {
-            ptr2 = 0; len2 = 0;
+            ptr1 = 0; len1 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
 
@@ -812,6 +1858,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 +2024,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
@@ -1152,6 +2273,14 @@ 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.
@@ -1308,6 +2437,193 @@ 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.
  *
@@ -1386,6 +2702,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]`
@@ -1451,6 +2832,11 @@ function getArrayF32FromWasm0(ptr, len) {
     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 +2864,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 +2996,7 @@ function __wbg_finalize_init(instance, module) {
     wasmModule = module;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();