@lovelace_lol/embody 0.0.14 → 0.0.16

package/dist/wasm/embody_wasm.js

@@ -215,6 +215,39 @@ export class AnnotationRuntime {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Packed world-space XYZ observations in the prepared vertex order. Stale,
+     * incomplete or nonfinite observations leave the last valid anchor intact.
+     * @param {number} generation
+     * @param {number} plan_id
+     * @param {Float32Array} positions
+     * @returns {boolean}
+     */
+    observe_morph_anchor(generation, plan_id, positions) {
+        const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_observe_morph_anchor(this.__wbg_ptr, generation, plan_id, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Native geometry identities/versions advance this per-object revision.
+     * Returns true when new geometry must be supplied. Retires old plan IDs
+     * without changing the region generation, marker IDs or reveal state.
+     * @param {number} generation
+     * @param {number} object_id
+     * @param {number} revision
+     * @param {string} morph_names_json
+     * @returns {boolean}
+     */
+    observe_morph_geometry(generation, object_id, revision, morph_names_json) {
+        const ptr0 = passStringToWasm0(morph_names_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_observe_morph_geometry(this.__wbg_ptr, generation, object_id, revision, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
     /**
      * Native hit observations are [marker id, nearest distance], with infinity for no hit.
      * @param {Float32Array} hits
@@ -270,6 +303,30 @@ export class AnnotationRuntime {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Prepare an attachment for this generation from mesh-space geometry.
+     * Returns [plan id, vertex indices...] or an empty array for a fallback anchor.
+     * Report geometry changes with observe_morph_geometry before preparing replacements.
+     * @param {number} generation
+     * @param {number} object_id
+     * @param {string} region_name
+     * @param {Float32Array} base
+     * @param {Float32Array} morphs
+     * @param {boolean} relative
+     * @returns {Uint32Array}
+     */
+    prepare_morph_anchor(generation, object_id, region_name, base, morphs, relative) {
+        const ptr0 = passStringToWasm0(region_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(base, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF32ToWasm0(morphs, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_prepare_morph_anchor(this.__wbg_ptr, generation, object_id, ptr0, len0, ptr1, len1, ptr2, len2, relative);
+        var v4 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v4;
+    }
     /**
      * @returns {number}
      */
@@ -719,6 +776,41 @@ export class RuntimeCore {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_runtimecore_free(ptr, 0);
     }
+    /**
+     * Compatibility impulses enter the same continuous state; they do not
+     * start an independent clip, reset its phase or replace head history.
+     * @param {number} horizontal
+     * @param {number} vertical
+     */
+    add_hair_response_impulse(horizontal, vertical) {
+        const ret = wasm.runtimecore_add_hair_response_impulse(this.__wbg_ptr, horizontal, vertical);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Host supplies elapsed seconds from its existing render clock, independent of clip speed.
+     * @param {number} delta_seconds
+     * @returns {string}
+     */
+    advance_mesh_highlight(delta_seconds) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_advance_mesh_highlight(this.__wbg_ptr, delta_seconds);
+            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}
      */
@@ -795,61 +887,68 @@ export class RuntimeCore {
         }
     }
     /**
-     * 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.
+     * Advance one character-owned simulation from the renderer's delta and
+     * actual blended local head quaternion. Constant additive morph samples
+     * are consumed by one persistent native action on its next mixer frame.
+     * This does not register a clip or change live AU/viseme/morph controls.
      * @param {string} name
-     * @param {number} duration_seconds
+     * @param {string} head_quaternion_json
+     * @param {number} dt_seconds
+     * @param {string} options_json
      * @returns {string}
      */
-    build_live_clip(name, duration_seconds) {
-        let deferred3_0;
-        let deferred3_1;
+    build_hair_response_clip(name, head_quaternion_json, dt_seconds, 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 ret = wasm.runtimecore_build_live_clip(this.__wbg_ptr, ptr0, len0, duration_seconds);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
+            const ptr1 = passStringToWasm0(head_quaternion_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_hair_response_clip(this.__wbg_ptr, ptr0, len0, ptr1, len1, dt_seconds, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
             if (ret[3]) {
-                ptr2 = 0; len2 = 0;
+                ptr4 = 0; len4 = 0;
                 throw takeFromExternrefTable0(ret[2]);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
         } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
         }
     }
     /**
-     * Compile relinquished live targets back to their reference values. Run
-     * this clip with finalPose=release so native ownership ends at completion.
+     * Compile the current live semantic controls into ordinary native tracks.
+     * `inherit_start` marks timed tracks as continuing from the current pose;
+     * the Three adapter resolves it from each live target's own outgoing
+     * action (not the mixed pose) at play time. Rust never ticks or
+     * interpolates these samples. Empty output relinquishes all live tracks.
      * @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;
+    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 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];
+            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]) {
-                ptr3 = 0; len3 = 0;
+                ptr2 = 0; len2 = 0;
                 throw takeFromExternrefTable0(ret[2]);
             }
-            deferred4_0 = ptr3;
-            deferred4_1 = len3;
-            return getStringFromWasm0(ptr3, len3);
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
         } finally {
-            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
     /**
@@ -1001,6 +1100,28 @@ export class RuntimeCore {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Complete versioned snapshot; omitted IDs must have previous preview resources removed.
+     * @returns {string}
+     */
+    evaluate_mesh_highlight_frame() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_evaluate_mesh_highlight_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);
+        }
+    }
     /**
      * Packed morph FrameDelta rows: `[mesh_id, morph_target_id, value, mode] * N`
      * Live AU/viseme/direct morph state only — clip playback is host-owned.
@@ -1153,6 +1274,29 @@ export class RuntimeCore {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * Resolved head role and captured local reference; null leaves ambient
+     * hair available without inventing a preset or renderer-side rig mapping.
+     * @returns {string}
+     */
+    get_hair_head_binding_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.runtimecore_get_hair_head_binding_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}
@@ -1204,6 +1348,13 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_has_left_right_bones(this.__wbg_ptr, au_id);
         return ret !== 0;
     }
+    /**
+     * @returns {boolean}
+     */
+    is_hair_response_paused() {
+        const ret = wasm.runtimecore_is_hair_response_paused(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {string}
      */
@@ -1296,6 +1447,40 @@ export class RuntimeCore {
         const len0 = WASM_VECTOR_LEN;
         wasm.runtimecore_load_viseme_morph_bindings(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Distance from a slot's current contribution to `destination_json`
+     * (`{auId: value}`), measured along profile continuum pairs. Travel is
+     * reversed only against an `unfinished` slot. A missing slot is at zero.
+     * Returns `{distance, reversal, current}`.
+     * @param {string} name
+     * @param {number} time
+     * @param {number} weight
+     * @param {string} destination_json
+     * @param {boolean} unfinished
+     * @returns {string}
+     */
+    measure_au_goal(name, time, weight, destination_json, unfinished) {
+        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(destination_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_measure_au_goal(this.__wbg_ptr, ptr0, len0, time, weight, ptr1, len1, unfinished);
+            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 {number} viseme_slot_count
      */
@@ -1305,6 +1490,80 @@ export class RuntimeCore {
         RuntimeCoreFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * One slot's own AU contribution, `{auId: value}`, at the host's native
+     * action time and effective weight; `null` when the slot is not readable.
+     * @param {string} name
+     * @param {number} time
+     * @param {number} weight
+     * @returns {string}
+     */
+    read_semantic_slot(name, time, weight) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_read_semantic_slot(this.__wbg_ptr, ptr0, len0, time, weight);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Live AU state plus every listed slot's contribution. `slots_json` is
+     * `[{name, time, weight}]` for the host's active actions. Returns
+     * `{live, animated, total}`; unreadable names are the host's to report.
+     * @param {string} slots_json
+     * @returns {string}
+     */
+    read_semantic_state(slots_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(slots_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.runtimecore_read_semantic_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);
+        }
+    }
+    /**
+     * Record the semantic AU keys of an admitted AU-curve clip slot. The
+     * same-name slot recorded earlier is the predecessor: `predecessor_time`
+     * is its native action time (NaN when absent) and `weight_ratio` its
+     * effective weight divided by the incoming weight, as for physical
+     * inheritance. Only numeric AU curves are kept.
+     * @param {string} name
+     * @param {string} curves_json
+     * @param {number} intensity_scale
+     * @param {string} easing
+     * @param {number} predecessor_time
+     * @param {number} weight_ratio
+     */
+    record_semantic_slot(name, curves_json, intensity_scale, easing, predecessor_time, weight_ratio) {
+        const ptr0 = passStringToWasm0(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(easing, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_record_semantic_slot(this.__wbg_ptr, ptr0, len0, ptr1, len1, intensity_scale, ptr2, len2, predecessor_time, weight_ratio);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {string} clip_json
      * @param {string} source
@@ -1358,6 +1617,18 @@ export class RuntimeCore {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Forget a slot once its native action is released or replaced by a
+     * non-curve source. Returns whether a slot existed.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    release_semantic_slot(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.runtimecore_release_semantic_slot(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * @param {string} clip_name
      * @returns {boolean}
@@ -1368,6 +1639,20 @@ export class RuntimeCore {
         const ret = wasm.runtimecore_remove_animation_clip(this.__wbg_ptr, ptr0, len0);
         return ret !== 0;
     }
+    /**
+     * Transient preview request. Names resolve against the configured model in Rust.
+     * @param {string | null} [name]
+     * @param {number | null} [color]
+     * @param {number | null} [intensity]
+     */
+    request_mesh_highlight(name, color, intensity) {
+        var ptr0 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.runtimecore_request_mesh_highlight(this.__wbg_ptr, ptr0, len0, isLikeNone(color) ? Number.MAX_SAFE_INTEGER : (color) >>> 0, isLikeNone(intensity) ? Number.MAX_SAFE_INTEGER : Math.fround(intensity));
+    }
+    reset_hair_response() {
+        wasm.runtimecore_reset_hair_response(this.__wbg_ptr);
+    }
     /**
      * Forget ownership when renderer bindings are discarded. Before replacing
      * bindings, apply release_procedural_morph_frame through the old IDs.
@@ -1403,6 +1688,24 @@ export class RuntimeCore {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Apply an in-place strength/easing edit to a running slot.
+     * @param {string} name
+     * @param {number} intensity_scale
+     * @param {string} easing
+     * @returns {boolean}
+     */
+    restyle_semantic_slot(name, intensity_scale, easing) {
+        const ptr0 = passStringToWasm0(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_restyle_semantic_slot(this.__wbg_ptr, ptr0, len0, intensity_scale, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
     /**
      * @param {number} id
      * @param {number} value
@@ -1462,6 +1765,14 @@ export class RuntimeCore {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Suspension intent survives empty mappings, enable changes and dynamics
+     * resets. Profile replacement starts a new character configuration.
+     * @param {boolean} paused
+     */
+    set_hair_response_paused(paused) {
+        wasm.runtimecore_set_hair_response_paused(this.__wbg_ptr, paused);
+    }
     /**
      * @param {Uint32Array} ids
      */
@@ -1632,6 +1943,31 @@ export function annotation_marker_frame_stride() {
     return ret >>> 0;
 }
 
+/**
+ * Final mesh-space attachment vertices as [index, influence] pairs. The same
+ * selection is used by AnnotationRuntime; native adapters only evaluate poses.
+ * @param {string} region_json
+ * @param {Float32Array} base
+ * @param {Float32Array} morphs
+ * @param {boolean} relative
+ * @returns {Float32Array}
+ */
+export function annotation_morph_anchor_candidates(region_json, base, morphs, relative) {
+    const ptr0 = passStringToWasm0(region_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(base, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF32ToWasm0(morphs, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.annotation_morph_anchor_candidates(ptr0, len0, ptr1, len1, ptr2, len2, relative);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v4;
+}
+
 /**
  * @param {Float32Array} base
  * @param {Float32Array} morphs
@@ -1709,6 +2045,21 @@ export function annotation_query(operation, payload_json) {
     }
 }
 
+/**
+ * Reduce packed [world x, world y, world z, influence] observations without
+ * selecting vertices again. Invalid/incomplete observations return no point.
+ * @param {Float32Array} samples
+ * @returns {Float32Array}
+ */
+export function annotation_weighted_anchor(samples) {
+    const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.annotation_weighted_anchor(ptr0, len0);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
 /**
  * Build head-pitch gravity hair morph curves.
  * @param {string} config_json
@@ -1939,6 +2290,88 @@ export function create_validation_skeleton_json(template_json) {
     }
 }
 
+/**
+ * @param {string} animation_json
+ * @param {string} profile_json
+ * @returns {string}
+ */
+export function decode_legacy_animation(animation_json, profile_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(animation_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.decode_legacy_animation(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} pose_json
+ * @param {string} profile_json
+ * @returns {string}
+ */
+export function decode_legacy_pose(pose_json, profile_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(pose_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(profile_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.decode_legacy_pose(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);
+    }
+}
+
+/**
+ * Decode the supported body-only VRMA subset; rejects unsupported channels.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function decode_vrma_animation(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.decode_vrma_animation(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}
  */
@@ -1999,6 +2432,23 @@ export function embody_request(request_json) {
     }
 }
 
+/**
+ * Write a standalone glTF 2 GLB with VRMC_vrm_animation 1.0, suitable for .vrma.
+ * @param {string} animation_json
+ * @returns {Uint8Array}
+ */
+export function encode_vrma_animation(animation_json) {
+    const ptr0 = passStringToWasm0(animation_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encode_vrma_animation(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
 /**
  * @param {string} model_json
  * @param {string} options_json
@@ -2379,6 +2829,32 @@ export function normalize_hair_color_appearance_json(value_json, fallback_json)
     }
 }
 
+/**
+ * Convert an explicitly referenced Mixamo rig to normalized VRM humanoid keys.
+ * @param {string} input_json
+ * @returns {string}
+ */
+export function normalize_mixamo_animation(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.normalize_mixamo_animation(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} mesh_ids
  * @param {Uint32Array} morph_target_ids
@@ -2562,6 +3038,35 @@ export function resolve_viewport_safe_bounds(label_scale_x, label_scale_y, proje
     return v1;
 }
 
+/**
+ * Convert portable keys to target local rotations/translations without sampling.
+ * @param {string} animation_json
+ * @param {string} target_rig_json
+ * @returns {string}
+ */
+export function retarget_vrma_animation(animation_json, target_rig_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(animation_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(target_rig_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.retarget_vrma_animation(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);
+    }
+}
+
 /**
  * Sinusoidal arc leader line points between two world positions.
  * Returns `(segments + 1) * 3` floats.
@@ -3000,6 +3505,11 @@ function getArrayU32FromWasm0(ptr, len) {
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {