@lovelace_lol/embody 0.0.13 → 0.0.15

package/dist/wasm/embody_wasm.js

@@ -1,9 +1,345 @@
 /* @ts-self-types="./embody_wasm.d.ts" */
 
+/**
+ * Browser timers only wake this state machine. Rust owns deadlines, expiry,
+ * manual overrides, repeated preview starts, and one-shot end notifications.
+ */
+export class AnnotationLifecycle {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AnnotationLifecycleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_annotationlifecycle_free(ptr, 0);
+    }
+    /**
+     * @param {string} operation
+     * @param {string} options_json
+     * @param {number} now_ms
+     * @returns {string}
+     */
+    command(operation, options_json, now_ms) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(operation, 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.annotationlifecycle_command(this.__wbg_ptr, ptr0, len0, ptr1, len1, now_ms);
+            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 {number | undefined}
+     */
+    deadline() {
+        const ret = wasm.annotationlifecycle_deadline(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @returns {boolean}
+     */
+    is_active() {
+        const ret = wasm.annotationlifecycle_is_active(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} mode
+     * @param {number} default_duration_ms
+     */
+    constructor(mode, default_duration_ms) {
+        const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationlifecycle_new(ptr0, len0, default_duration_ms);
+        this.__wbg_ptr = ret;
+        AnnotationLifecycleFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) AnnotationLifecycle.prototype[Symbol.dispose] = AnnotationLifecycle.prototype.free;
+
+export class AnnotationRuntime {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AnnotationRuntimeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_annotationruntime_free(ptr, 0);
+    }
+    /**
+     * The only camera integrator: pose observation(6), fov/aspect/viewport(4).
+     * Returns pose(6), active request id, completed request id, needs frame.
+     * @param {number} now_ms
+     * @param {Float32Array} observation
+     * @returns {Float32Array}
+     */
+    camera_frame(now_ms, observation) {
+        const ptr0 = passArrayF32ToWasm0(observation, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_camera_frame(this.__wbg_ptr, now_ms, ptr0, len0);
+        var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+    /**
+     * @param {string} operation
+     * @param {string} payload_json
+     * @param {number} now_ms
+     * @returns {string}
+     */
+    command(operation, payload_json, now_ms) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.annotationruntime_command(this.__wbg_ptr, ptr0, len0, ptr1, len1, now_ms);
+            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 {number}
+     */
+    completed_camera_request() {
+        const ret = wasm.annotationruntime_completed_camera_request(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    dispose() {
+        wasm.annotationruntime_dispose(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} generation
+     */
+    finish_markers(generation) {
+        wasm.annotationruntime_finish_markers(this.__wbg_ptr, generation);
+    }
+    /**
+     * @returns {number}
+     */
+    generation() {
+        const ret = wasm.annotationruntime_generation(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} generation
+     * @returns {boolean}
+     */
+    is_current(generation) {
+        const ret = wasm.annotationruntime_is_current(this.__wbg_ptr, generation);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} id
+     * @param {number} width
+     * @param {number} height
+     */
+    label_metrics(id, width, height) {
+        wasm.annotationruntime_label_metrics(this.__wbg_ptr, id, width, height);
+    }
+    /**
+     * @param {number} now_ms
+     * @param {Float32Array} projection
+     * @param {Float32Array} view_projection
+     * @param {number} width
+     * @param {number} height
+     * @returns {Float32Array}
+     */
+    marker_frame(now_ms, projection, view_projection, width, height) {
+        const ptr0 = passArrayF32ToWasm0(projection, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(view_projection, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_marker_frame(this.__wbg_ptr, now_ms, ptr0, len0, ptr1, len1, width, height);
+        var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v3;
+    }
+    /**
+     * @returns {boolean}
+     */
+    needs_frame() {
+        const ret = wasm.annotationruntime_needs_frame(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} settings_json
+     */
+    constructor(settings_json) {
+        const ptr0 = passStringToWasm0(settings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        AnnotationRuntimeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} model_json
+     */
+    observe_model(model_json) {
+        const ptr0 = passStringToWasm0(model_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_observe_model(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Native hit observations are [marker id, nearest distance], with infinity for no hit.
+     * @param {Float32Array} hits
+     */
+    observe_occlusion(hits) {
+        const ptr0 = passArrayF32ToWasm0(hits, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.annotationruntime_observe_occlusion(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Packed observation records are [object id, column-major matrixWorld(16)].
+     * @param {Float32Array} transforms
+     */
+    observe_transforms(transforms) {
+        const ptr0 = passArrayF32ToWasm0(transforms, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.annotationruntime_observe_transforms(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * HTML occlusion rays: [id, origin(3), direction(3), maximum distance].
+     * Three reports the nearest native hit; Rust owns its visibility meaning.
+     * @returns {Float32Array}
+     */
+    occlusion_queries() {
+        const ret = wasm.annotationruntime_occlusion_queries(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Plans contain native ray queries, never native handles. Every result is
+     * tied to this generation; a stale query cannot resurrect cleared markers.
+     * @param {string} morph_anchors_json
+     * @returns {string}
+     */
+    plan_markers(morph_anchors_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(morph_anchors_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.annotationruntime_plan_markers(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}
+     */
+    revision() {
+        const ret = wasm.annotationruntime_revision(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} model_json
+     */
+    set_model(model_json) {
+        const ptr0 = passStringToWasm0(model_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.annotationruntime_set_model(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    snapshot() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.annotationruntime_snapshot(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} generation
+     * @param {number} id
+     * @param {number} phase
+     * @param {Float32Array} hits
+     * @returns {string}
+     */
+    surface_result(generation, id, phase, hits) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passArrayF32ToWasm0(hits, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.annotationruntime_surface_result(this.__wbg_ptr, generation, id, phase, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    tracked_objects() {
+        const ret = wasm.annotationruntime_tracked_objects(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) AnnotationRuntime.prototype[Symbol.dispose] = AnnotationRuntime.prototype.free;
+
 /**
  * Spherical camera flight between two camera poses.
  *
- * Mirrors the DPthree camera transition: orbital interpolation with a
+ * Mirrors the ThreeAnnotations camera transition: orbital interpolation with a
  * pullback arc so large rotations do not pass through the model.
  * `sample(elapsed_ms)` returns
  * `[posX, posY, posZ, targetX, targetY, targetZ, done]`.
@@ -1259,6 +1595,27 @@ export function analyze_model_descriptor(model_json, clips_json, profile_json, o
     }
 }
 
+/**
+ * Select vertices influenced by any requested skeleton index. The adapter
+ * evaluates these indices through the native skinned vertex API.
+ * @param {Float32Array} indices
+ * @param {Float32Array} weights
+ * @param {Uint32Array} bones
+ * @returns {Uint32Array}
+ */
+export function annotation_bone_vertices(indices, weights, bones) {
+    const ptr0 = passArrayF32ToWasm0(indices, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(weights, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(bones, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.annotation_bone_vertices(ptr0, len0, ptr1, len1, ptr2, len2);
+    var v4 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v4;
+}
+
 /**
  * @returns {number}
  */
@@ -1267,6 +1624,91 @@ export function annotation_camera_framing_stride() {
     return ret >>> 0;
 }
 
+/**
+ * @returns {number}
+ */
+export function annotation_marker_frame_stride() {
+    const ret = wasm.annotation_marker_frame_stride();
+    return ret >>> 0;
+}
+
+/**
+ * @param {Float32Array} base
+ * @param {Float32Array} morphs
+ * @param {boolean} relative
+ * @returns {Float32Array}
+ */
+export function annotation_morph_candidates(base, morphs, relative) {
+    const ptr0 = passArrayF32ToWasm0(base, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(morphs, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.annotation_morph_candidates(ptr0, len0, ptr1, len1, relative);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * @param {string} region_json
+ * @param {Float32Array} candidates
+ * @returns {Float32Array}
+ */
+export function annotation_morph_center(region_json, candidates) {
+    const ptr0 = passStringToWasm0(region_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF32ToWasm0(candidates, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.annotation_morph_center(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * @param {Float32Array} points
+ * @returns {Float32Array}
+ */
+export function annotation_point_bounds(points) {
+    const ptr0 = passArrayF32ToWasm0(points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.annotation_point_bounds(ptr0, len0);
+    var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+
+/**
+ * @param {string} operation
+ * @param {string} payload_json
+ * @returns {string}
+ */
+export function annotation_query(operation, payload_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.annotation_query(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);
+    }
+}
+
 /**
  * Build head-pitch gravity hair morph curves.
  * @param {string} config_json
@@ -2164,7 +2606,7 @@ export function sample_marker_bezier_curve(start, end, segments) {
  *
  * `starts` and `ends` are packed `[x, y, z, ...]` arrays. The output includes
  * one endpoint for every complete start/end pair. Proximity and rotation
- * constants match DPthree's marker layout, scaled to the current model height.
+ * constants match ThreeAnnotations's marker layout, scaled to the current model height.
  * @param {Float32Array} starts
  * @param {Float32Array} ends
  * @param {Float32Array} model_center
@@ -2504,6 +2946,12 @@ function __wbg_get_imports() {
     };
 }
 
+const AnnotationLifecycleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_annotationlifecycle_free(ptr, 1));
+const AnnotationRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_annotationruntime_free(ptr, 1));
 const CameraFlightFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cameraflight_free(ptr, 1));
@@ -2547,6 +2995,11 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {