@octoseq/visualiser 0.1.0-main.4ecb074 → 0.1.0-main.5fdb072

package/pkg/visualiser.js

@@ -1,8 +1,11 @@
 let wasm;
 
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
     return idx;
 }
 
@@ -75,6 +78,12 @@ function debugString(val) {
     return className;
 }
 
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
 function getArrayF32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
@@ -127,15 +136,21 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function getObject(idx) { return heap[idx]; }
+
 function handleError(f, args) {
     try {
         return f.apply(this, args);
     } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
+        wasm.__wbindgen_export3(addHeapObject(e));
     }
 }
 
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
@@ -212,6 +227,12 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
@@ -241,16 +262,16 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function wasm_bindgen__convert__closures_____invoke__h9d1c5a23ecfcd5c8(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h9d1c5a23ecfcd5c8(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_10256(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_10256(arg0, arg1, addHeapObject(arg2));
 }
 
-function wasm_bindgen__convert__closures_____invoke__h53437a38721e89f7(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h53437a38721e89f7(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_11338(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_11338(arg0, arg1, addHeapObject(arg2));
 }
 
-function wasm_bindgen__convert__closures_____invoke__h320f3d825d3712ba(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h320f3d825d3712ba(arg0, arg1, arg2, arg3);
+function __wasm_bindgen_func_elem_11945(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_11945(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_GpuCompilationMessageType = ["error", "warning", "info"];
@@ -293,6 +314,17 @@ export class WasmVisualiser {
         const ret = wasm.wasmvisualiser_has_script(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Check if a signal variable exists in the current script.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has_signal(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_has_signal(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * Load a Rhai script for controlling the visualiser.
      * Returns true if the script was loaded successfully.
@@ -300,7 +332,7 @@ export class WasmVisualiser {
      * @returns {boolean}
      */
     load_script(script) {
-        const ptr0 = passStringToWasm0(script, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(script, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.wasmvisualiser_load_script(this.__wbg_ptr, ptr0, len0);
         return ret !== 0;
@@ -313,12 +345,42 @@ export class WasmVisualiser {
      * @param {number} sample_rate
      */
     push_signal(name, samples, sample_rate) {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF32ToWasm0(samples, wasm.__wbindgen_malloc);
+        const ptr1 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
         const len1 = WASM_VECTOR_LEN;
         wasm.wasmvisualiser_push_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, sample_rate);
     }
+    /**
+     * Run script in analysis mode to collect debug.emit() signals.
+     *
+     * This runs the script headlessly across the full track duration,
+     * collecting all debug.emit() calls without rendering.
+     *
+     * Returns a JSON-serialized AnalysisResultJson.
+     * @param {string} script
+     * @param {number} duration
+     * @param {number} time_step
+     * @returns {string}
+     */
+    run_analysis(script, duration, time_step) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(script, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmvisualiser_run_analysis(retptr, this.__wbg_ptr, ptr0, len0, duration, time_step);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred2_0 = r0;
+            deferred2_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Clear all named signals.
      */
@@ -331,47 +393,781 @@ export class WasmVisualiser {
     set_sigmoid_k(k) {
         wasm.wasmvisualiser_set_sigmoid_k(this.__wbg_ptr, k);
     }
+    /**
+     * Isolate a single entity for rendering (useful for debugging).
+     * Only this entity will be rendered.
+     * @param {bigint} entity_id
+     */
+    isolate_entity(entity_id) {
+        wasm.wasmvisualiser_isolate_entity(this.__wbg_ptr, entity_id);
+    }
     /**
      * @param {Float32Array} samples
      * @param {number} sample_rate
      */
     push_zoom_data(samples, sample_rate) {
-        const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_malloc);
+        const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.wasmvisualiser_push_zoom_data(this.__wbg_ptr, ptr0, len0, sample_rate);
     }
+    /**
+     * Clear entity isolation, resume normal rendering.
+     */
+    clear_isolation() {
+        wasm.wasmvisualiser_clear_isolation(this.__wbg_ptr);
+    }
     /**
      * Get current state values for debugging.
      * Returns [time, scene_entity_count, mesh_count, line_count]
      * @returns {Float32Array}
      */
     get_current_vals() {
-        const ret = wasm.wasmvisualiser_get_current_vals(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_current_vals(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * Get the last script error message, if any.
      * @returns {string | undefined}
      */
     get_script_error() {
-        const ret = wasm.wasmvisualiser_get_script_error(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_script_error(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the list of available signal names.
+     * Returns a JSON array of signal names.
+     * @returns {string}
+     */
+    get_signal_names() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_signal_names(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get a list of all registered mesh asset IDs.
+     * Returns a JSON array of asset IDs.
+     * @returns {string}
+     */
+    list_mesh_assets() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_list_mesh_assets(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
-        return v1;
+    }
+    /**
+     * Push pre-extracted events for a band.
+     *
+     * Events are extracted by the TypeScript layer using the existing peak picker,
+     * then pushed here for script access via `inputs.bands[id].events`.
+     *
+     * The JSON format should be an array of event objects with:
+     * - time: f32
+     * - weight: f32
+     * - beat_position: Option<f32>
+     * - beat_phase: Option<f32>
+     * - cluster_id: Option<u32>
+     *
+     * Returns true if successful, false if parsing failed.
+     * @param {string} band_id
+     * @param {string} events_json
+     * @returns {boolean}
+     */
+    push_band_events(band_id, events_json) {
+        const ptr0 = passStringToWasm0(band_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(events_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_push_band_events(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * Push a band-scoped signal for use in scripts.
+     * The signal will be available as `inputs.bands[band_id].{feature}` in Rhai scripts.
+     * Stores under both band_id and band_label for dual-access support.
+     *
+     * - `band_id`: The unique ID of the frequency band.
+     * - `band_label`: The user-visible label of the band.
+     * - `feature`: Signal type ("energy", "onset", "flux").
+     * - `samples`: Signal data.
+     * - `sample_rate`: Sample rate of the signal.
+     * @param {string} band_id
+     * @param {string} band_label
+     * @param {string} feature
+     * @param {Float32Array} samples
+     * @param {number} sample_rate
+     */
+    push_band_signal(band_id, band_label, feature, samples, sample_rate) {
+        const ptr0 = passStringToWasm0(band_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(band_label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(feature, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.wasmvisualiser_push_band_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, sample_rate);
+    }
+    /**
+     * Push a stem-scoped signal for use in scripts.
+     * The signal will be available as `inputs.stems[stem_id].{feature}` in Rhai scripts.
+     * Stores under both stem_id and stem_label for dual-access support.
+     *
+     * - `stem_id`: The unique ID of the stem.
+     * - `stem_label`: The user-visible label of the stem.
+     * - `feature`: Signal type ("energy", "onset", "flux").
+     * - `samples`: Signal data.
+     * - `sample_rate`: Sample rate of the signal.
+     * @param {string} stem_id
+     * @param {string} stem_label
+     * @param {string} feature
+     * @param {Float32Array} samples
+     * @param {number} sample_rate
+     */
+    push_stem_signal(stem_id, stem_label, feature, samples, sample_rate) {
+        const ptr0 = passStringToWasm0(stem_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(stem_label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(feature, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.wasmvisualiser_push_stem_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, sample_rate);
+    }
+    /**
+     * Set the musical time structure for beat-aware signal processing.
+     * The JSON format matches the TypeScript MusicalTimeStructure type.
+     * Returns true if successful, false if parsing failed.
+     * @param {string} json
+     * @returns {boolean}
+     */
+    set_musical_time(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_set_musical_time(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Clear all band event streams.
+     */
+    clear_band_events() {
+        wasm.wasmvisualiser_clear_band_events(this.__wbg_ptr);
+    }
+    /**
+     * Push a named event stream (e.g., "beatCandidates") for script access.
+     *
+     * The event stream will be available as `inputs.<name>` in Rhai scripts.
+     * This is used for MIR-derived events like beat candidates, onset peaks, etc.
+     *
+     * The JSON format should be an array of event objects with:
+     * - time: f32
+     * - weight: f32
+     * - beat_position: Option<f32>
+     * - beat_phase: Option<f32>
+     * - cluster_id: Option<u32>
+     *
+     * Returns true if successful, false if parsing failed.
+     * @param {string} name
+     * @param {string} events_json
+     * @returns {boolean}
+     */
+    push_event_stream(name, events_json) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(events_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_push_event_stream(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * Set debug visualization options.
+     * @param {boolean} wireframe
+     * @param {boolean} bounding_boxes
+     */
+    set_debug_options(wireframe, bounding_boxes) {
+        wasm.wasmvisualiser_set_debug_options(this.__wbg_ptr, wireframe, bounding_boxes);
+    }
+    /**
+     * Clear all band signals.
+     */
+    clear_band_signals() {
+        wasm.wasmvisualiser_clear_band_signals(this.__wbg_ptr);
+    }
+    /**
+     * Clear the musical time structure.
+     * Beat-aware operations will fall back to 120 BPM default.
+     */
+    clear_musical_time() {
+        wasm.wasmvisualiser_clear_musical_time(this.__wbg_ptr);
+    }
+    /**
+     * Clear all stem signals.
+     */
+    clear_stem_signals() {
+        wasm.wasmvisualiser_clear_stem_signals(this.__wbg_ptr);
+    }
+    /**
+     * Get frequency bounds for all active bands at a given time.
+     * Returns a JSON array of { bandId, label, lowHz, highHz, enabled } objects.
+     * @param {number} time
+     * @returns {string}
+     */
+    get_band_bounds_at(time) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_band_bounds_at(retptr, this.__wbg_ptr, time);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get all Signal variables from the current script.
+     * Returns a JSON array of ScriptSignalInfo objects.
+     * @returns {string}
+     */
+    get_script_signals() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_script_signals(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Push a custom signal for use in scripts.
+     * The signal will be available as `inputs.customSignals["signal_id"]` in Rhai scripts.
+     *
+     * - `signal_id`: The unique ID of the custom signal.
+     * - `label`: The user-visible label of the signal.
+     * - `samples`: Signal data.
+     * - `sample_rate`: Sample rate of the signal.
+     * @param {string} signal_id
+     * @param {string} label
+     * @param {Float32Array} samples
+     * @param {number} sample_rate
+     */
+    push_custom_signal(signal_id, label, samples, sample_rate) {
+        const ptr0 = passStringToWasm0(signal_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.wasmvisualiser_push_custom_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, sample_rate);
     }
     /**
      * @param {Float32Array} samples
      * @param {number} sample_rate
      */
     push_rotation_data(samples, sample_rate) {
-        const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_malloc);
+        const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        wasm.wasmvisualiser_push_data(this.__wbg_ptr, ptr0, len0, sample_rate);
+        wasm.wasmvisualiser_push_rotation_data(this.__wbg_ptr, ptr0, len0, sample_rate);
+    }
+    /**
+     * Render with a frame budget timeout.
+     *
+     * If the frame takes longer than `budget_ms` to process, it will be dropped
+     * and a warning logged. This prevents expensive scripts from freezing the browser.
+     *
+     * Returns true if the frame completed, false if it was dropped due to budget.
+     * @param {number} dt
+     * @param {number} budget_ms
+     * @returns {boolean}
+     */
+    render_with_budget(dt, budget_ms) {
+        const ret = wasm.wasmvisualiser_render_with_budget(this.__wbg_ptr, dt, budget_ms);
+        return ret !== 0;
+    }
+    /**
+     * Clear all named event streams.
+     */
+    clear_event_streams() {
+        wasm.wasmvisualiser_clear_event_streams(this.__wbg_ptr);
+    }
+    /**
+     * Check if frequency bands are currently set.
+     * @returns {boolean}
+     */
+    has_frequency_bands() {
+        const ret = wasm.wasmvisualiser_has_frequency_bands(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Register a mesh asset from OBJ content.
+     * The asset will be available as `mesh.load(asset_id)` in scripts.
+     * Returns true if successful, false if parsing failed.
+     * @param {string} asset_id
+     * @param {string} obj_content
+     * @returns {boolean}
+     */
+    register_mesh_asset(asset_id, obj_content) {
+        const ptr0 = passStringToWasm0(asset_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(obj_content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_register_mesh_asset(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * Set available stems for script namespace generation.
+     * This registers stem IDs and labels so the script engine can generate
+     * `inputs.stems["stem_id"]` and `inputs.stems["label"]` accessors.
+     *
+     * The JSON format should be an array of [id, label] pairs:
+     * `[["stem-abc123", "Drums"], ["stem-def456", "Bass"]]`
+     *
+     * Returns true if successful, false if parsing failed.
+     * @param {string} json
+     * @returns {boolean}
+     */
+    set_available_stems(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_set_available_stems(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Set the frequency band structure for band-aware processing.
+     * The JSON format matches the TypeScript FrequencyBandStructure type.
+     * Returns true if successful, false if parsing failed.
+     * @param {string} json
+     * @returns {boolean}
+     */
+    set_frequency_bands(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_set_frequency_bands(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Analyze a signal chain with localized sampling.
+     *
+     * Returns JSON with either:
+     * - SignalChainAnalysis on success
+     * - { "error": "message" } on failure
+     *
+     * Parameters:
+     * - signal_name: Name of the signal variable in the script
+     * - center_time: Time to center analysis around (seconds)
+     * - window_beats: Number of beats before/after center to sample
+     * - sample_count: Number of samples to take
+     * @param {string} signal_name
+     * @param {number} center_time
+     * @param {number} window_beats
+     * @param {number} sample_count
+     * @returns {string}
+     */
+    analyze_signal_chain(signal_name, center_time, window_beats, sample_count) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(signal_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmvisualiser_analyze_signal_chain(retptr, this.__wbg_ptr, ptr0, len0, center_time, window_beats, sample_count);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred2_0 = r0;
+            deferred2_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Clear all custom signals.
+     */
+    clear_custom_signals() {
+        wasm.wasmvisualiser_clear_custom_signals(this.__wbg_ptr);
+    }
+    /**
+     * Get the number of events for a specific band.
+     * Returns 0 if no events are stored for this band.
+     * @param {string} band_id
+     * @returns {number}
+     */
+    get_band_event_count(band_id) {
+        const ptr0 = passStringToWasm0(band_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_get_band_event_count(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get list of band keys (IDs and labels) that have signals.
+     * Returns a JSON array of strings.
+     * @returns {string}
+     */
+    get_band_signal_keys() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_band_signal_keys(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get list of stem keys (IDs and labels) that have signals.
+     * Returns a JSON array of strings.
+     * @returns {string}
+     */
+    get_stem_signal_keys() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_stem_signal_keys(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Check if performance profiling is currently enabled.
+     * @returns {boolean}
+     */
+    is_profiling_enabled() {
+        const ret = wasm.wasmvisualiser_is_profiling_enabled(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Push a composed signal for use in scripts.
+     * The signal will be available as `inputs.composedSignals["name"]` in Rhai scripts.
+     *
+     * - `name`: The composed signal name (composed signals are keyed by name only).
+     * - `samples`: Signal data.
+     * - `sample_rate`: Sample rate of the signal.
+     * @param {string} name
+     * @param {Float32Array} samples
+     * @param {number} sample_rate
+     */
+    push_composed_signal(name, samples, sample_rate) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmvisualiser_push_composed_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, sample_rate);
+    }
+    /**
+     * Clear the frequency band structure.
+     */
+    clear_frequency_bands() {
+        wasm.wasmvisualiser_clear_frequency_bands(this.__wbg_ptr);
+    }
+    /**
+     * Get camera state as JSON for inspector.
+     * Returns current position, rotation, target, fov, near, far, mode, and signal flags.
+     * @returns {string}
+     */
+    get_camera_state_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_camera_state_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Enable or disable performance profiling.
+     * When enabled, console timing and collection size logging will be active.
+     * @param {boolean} enabled
+     */
+    set_profiling_enabled(enabled) {
+        wasm.wasmvisualiser_set_profiling_enabled(this.__wbg_ptr, enabled);
+    }
+    /**
+     * Unregister a mesh asset.
+     * Returns true if the asset was unregistered, false if it didn't exist.
+     * @param {string} asset_id
+     * @returns {boolean}
+     */
+    unregister_mesh_asset(asset_id) {
+        const ptr0 = passStringToWasm0(asset_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_unregister_mesh_asset(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Clear all composed signals.
+     */
+    clear_composed_signals() {
+        wasm.wasmvisualiser_clear_composed_signals(this.__wbg_ptr);
+    }
+    /**
+     * Get list of custom signal keys (IDs and labels).
+     * Returns a JSON array of strings.
+     * @returns {string}
+     */
+    get_custom_signal_keys() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_custom_signal_keys(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the number of events in a named event stream.
+     * Returns 0 if no events are stored for this name.
+     * @param {string} name
+     * @returns {number}
+     */
+    get_event_stream_count(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_get_event_stream_count(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * Get the number of frequency bands.
+     * @returns {number}
+     */
+    get_frequency_band_count() {
+        const ret = wasm.wasmvisualiser_get_frequency_band_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Run script in analysis mode with event extraction support.
+     *
+     * This runs the script headlessly across the full track duration,
+     * collecting all debug.emit() calls AND extracting events from
+     * any signal.pick.events() calls.
+     *
+     * Returns a JSON-serialized ExtendedAnalysisResultJson.
+     * @param {string} script
+     * @param {number} duration
+     * @param {number} time_step
+     * @returns {string}
+     */
+    run_analysis_with_events(script, duration, time_step) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(script, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wasmvisualiser_run_analysis_with_events(retptr, this.__wbg_ptr, ptr0, len0, duration, time_step);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred2_0 = r0;
+            deferred2_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Get entity positions as JSON for debugging.
+     * Returns a JSON array of objects with id, type, and position fields.
+     * @returns {string}
+     */
+    get_entity_positions_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_get_entity_positions_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Push an authored event stream for script access.
+     *
+     * The event stream will be available as `inputs.authored["name"]` in Rhai scripts.
+     * This is used for user-authored events (promoted or manually created).
+     *
+     * The JSON format should be an array of event objects with:
+     * - time: f32
+     * - weight: f32
+     * - beat_position: Option<f32>
+     * - beat_phase: Option<f32>
+     * - cluster_id: Option<u32>
+     *
+     * Returns true if successful, false if parsing failed.
+     * @param {string} name
+     * @param {string} events_json
+     * @returns {boolean}
+     */
+    push_authored_event_stream(name, events_json) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(events_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_push_authored_event_stream(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * Clear all authored event streams.
+     */
+    clear_authored_event_streams() {
+        wasm.wasmvisualiser_clear_authored_event_streams(this.__wbg_ptr);
+    }
+    /**
+     * Set available custom signals for script namespace generation.
+     * This registers custom signal IDs and labels so the script engine can generate
+     * `inputs.customSignals["signal_id"]` accessors.
+     *
+     * The JSON format should be an array of [id, label] pairs:
+     * `[["signal-abc123", "My Signal"], ["signal-def456", "Another Signal"]]`
+     *
+     * Returns true if successful, false if parsing failed.
+     * @param {string} json
+     * @returns {boolean}
+     */
+    set_available_custom_signals(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_set_available_custom_signals(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Drain and return any pending structured script diagnostics as JSON.
+     *
+     * Intended for UI consumption. Calling this clears the pending diagnostics
+     * queue so repeated polling does not duplicate messages.
+     * @returns {string}
+     */
+    take_script_diagnostics_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmvisualiser_take_script_diagnostics_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Set available composed signals for script namespace generation.
+     * This registers composed signal IDs and labels so the script engine can generate
+     * `inputs.composedSignals["name"]` accessors.
+     *
+     * The JSON format should be an array of [id, label] pairs:
+     * `[["intensity", "intensity"], ["buildup", "buildup"]]`
+     *
+     * Returns true if successful, false if parsing failed.
+     * @param {string} json
+     * @returns {boolean}
+     */
+    set_available_composed_signals(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_set_available_composed_signals(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Get the number of events in an authored event stream.
+     * Returns 0 if no events are stored for this name.
+     * @param {string} name
+     * @returns {number}
+     */
+    get_authored_event_stream_count(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmvisualiser_get_authored_event_stream_count(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
     }
     constructor() {
         const ret = wasm.wasmvisualiser_new();
@@ -403,7 +1199,7 @@ export class WasmVisualiser {
      * @param {number} sample_rate
      */
     push_data(samples, sample_rate) {
-        const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_malloc);
+        const ptr0 = passArrayF32ToWasm0(samples, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         wasm.wasmvisualiser_push_data(this.__wbg_ptr, ptr0, len0, sample_rate);
     }
@@ -415,8 +1211,33 @@ if (Symbol.dispose) WasmVisualiser.prototype[Symbol.dispose] = WasmVisualiser.pr
  * @returns {Promise<WasmVisualiser>}
  */
 export function create_visualiser(canvas) {
-    const ret = wasm.create_visualiser(canvas);
-    return ret;
+    const ret = wasm.create_visualiser(addHeapObject(canvas));
+    return takeObject(ret);
+}
+
+/**
+ * Get the host-defined Script API metadata as a JSON string.
+ *
+ * This is a stable, versioned description of the scripting API surface and is
+ * intended to drive editor UX (autocomplete/hover/docs) and future language
+ * bindings.
+ * @returns {string}
+ */
+export function get_script_api_metadata_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.get_script_api_metadata_json(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+    }
 }
 
 export function init_panic_hook() {
@@ -459,41 +1280,41 @@ function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
     imports.wbg.__wbg_Window_cf5b693340a7c469 = function(arg0) {
-        const ret = arg0.Window;
-        return ret;
+        const ret = getObject(arg0).Window;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_WorkerGlobalScope_354364d1b0bd06e5 = function(arg0) {
-        const ret = arg0.WorkerGlobalScope;
-        return ret;
+        const ret = getObject(arg0).WorkerGlobalScope;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
-        const ret = debugString(arg1);
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = debugString(getObject(arg1));
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
     imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
-        const ret = typeof(arg0) === 'function';
+        const ret = typeof(getObject(arg0)) === 'function';
         return ret;
     };
     imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
-        const ret = arg0 === null;
+        const ret = getObject(arg0) === null;
         return ret;
     };
     imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
-        const val = arg0;
+        const val = getObject(arg0);
         const ret = typeof(val) === 'object' && val !== null;
         return ret;
     };
     imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
-        const ret = arg0 === undefined;
+        const ret = getObject(arg0) === undefined;
         return ret;
     };
     imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
-        const obj = arg1;
+        const obj = getObject(arg1);
         const ret = typeof(obj) === 'string' ? obj : undefined;
-        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         var len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -502,155 +1323,155 @@ function __wbg_get_imports() {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
-        arg0._wbg_cb_unref();
+        getObject(arg0)._wbg_cb_unref();
     };
     imports.wbg.__wbg_beginComputePass_90d5303e604970cb = function(arg0, arg1) {
-        const ret = arg0.beginComputePass(arg1);
-        return ret;
+        const ret = getObject(arg0).beginComputePass(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_beginRenderPass_9739520c601001c3 = function(arg0, arg1) {
-        const ret = arg0.beginRenderPass(arg1);
-        return ret;
+        const ret = getObject(arg0).beginRenderPass(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_buffer_6cb2fecb1f253d71 = function(arg0) {
-        const ret = arg0.buffer;
-        return ret;
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = arg0.call(arg1, arg2);
-        return ret;
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
-        const ret = arg0.call(arg1);
-        return ret;
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_clearBuffer_6164fc25d22b25cc = function(arg0, arg1, arg2, arg3) {
-        arg0.clearBuffer(arg1, arg2, arg3);
+        getObject(arg0).clearBuffer(getObject(arg1), arg2, arg3);
     };
     imports.wbg.__wbg_clearBuffer_cfcaaf1fb2baa885 = function(arg0, arg1, arg2) {
-        arg0.clearBuffer(arg1, arg2);
+        getObject(arg0).clearBuffer(getObject(arg1), arg2);
     };
     imports.wbg.__wbg_configure_2414aed971d368cd = function(arg0, arg1) {
-        arg0.configure(arg1);
+        getObject(arg0).configure(getObject(arg1));
     };
     imports.wbg.__wbg_copyBufferToBuffer_1ba67191114656a1 = function(arg0, arg1, arg2, arg3, arg4, arg5) {
-        arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4, arg5);
+        getObject(arg0).copyBufferToBuffer(getObject(arg1), arg2, getObject(arg3), arg4, arg5);
     };
     imports.wbg.__wbg_copyBufferToTexture_878d31d479e48f28 = function(arg0, arg1, arg2, arg3) {
-        arg0.copyBufferToTexture(arg1, arg2, arg3);
+        getObject(arg0).copyBufferToTexture(getObject(arg1), getObject(arg2), getObject(arg3));
     };
     imports.wbg.__wbg_copyExternalImageToTexture_7878d196c0b60d39 = function(arg0, arg1, arg2, arg3) {
-        arg0.copyExternalImageToTexture(arg1, arg2, arg3);
+        getObject(arg0).copyExternalImageToTexture(getObject(arg1), getObject(arg2), getObject(arg3));
     };
     imports.wbg.__wbg_copyTextureToBuffer_6a8fe0e90f0a663d = function(arg0, arg1, arg2, arg3) {
-        arg0.copyTextureToBuffer(arg1, arg2, arg3);
+        getObject(arg0).copyTextureToBuffer(getObject(arg1), getObject(arg2), getObject(arg3));
     };
     imports.wbg.__wbg_copyTextureToTexture_0a06a393d6726b4a = function(arg0, arg1, arg2, arg3) {
-        arg0.copyTextureToTexture(arg1, arg2, arg3);
+        getObject(arg0).copyTextureToTexture(getObject(arg1), getObject(arg2), getObject(arg3));
     };
     imports.wbg.__wbg_createBindGroupLayout_1d93b6d41c87ba9d = function(arg0, arg1) {
-        const ret = arg0.createBindGroupLayout(arg1);
-        return ret;
+        const ret = getObject(arg0).createBindGroupLayout(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createBindGroup_61cd07ec9d423432 = function(arg0, arg1) {
-        const ret = arg0.createBindGroup(arg1);
-        return ret;
+        const ret = getObject(arg0).createBindGroup(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createBuffer_963aa00d5fe859e4 = function(arg0, arg1) {
-        const ret = arg0.createBuffer(arg1);
-        return ret;
+        const ret = getObject(arg0).createBuffer(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createCommandEncoder_f0e1613e9a2dc1eb = function(arg0, arg1) {
-        const ret = arg0.createCommandEncoder(arg1);
-        return ret;
+        const ret = getObject(arg0).createCommandEncoder(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createComputePipeline_b9616b9fe2f4eb2f = function(arg0, arg1) {
-        const ret = arg0.createComputePipeline(arg1);
-        return ret;
+        const ret = getObject(arg0).createComputePipeline(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createPipelineLayout_56c6cf983f892d2b = function(arg0, arg1) {
-        const ret = arg0.createPipelineLayout(arg1);
-        return ret;
+        const ret = getObject(arg0).createPipelineLayout(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createQuerySet_c14be802adf7c207 = function(arg0, arg1) {
-        const ret = arg0.createQuerySet(arg1);
-        return ret;
+        const ret = getObject(arg0).createQuerySet(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createRenderBundleEncoder_8e4bdffea72f8c1f = function(arg0, arg1) {
-        const ret = arg0.createRenderBundleEncoder(arg1);
-        return ret;
+        const ret = getObject(arg0).createRenderBundleEncoder(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createRenderPipeline_079a88a0601fcce1 = function(arg0, arg1) {
-        const ret = arg0.createRenderPipeline(arg1);
-        return ret;
+        const ret = getObject(arg0).createRenderPipeline(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createSampler_ef5578990df3baf7 = function(arg0, arg1) {
-        const ret = arg0.createSampler(arg1);
-        return ret;
+        const ret = getObject(arg0).createSampler(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createShaderModule_17f451ea25cae47c = function(arg0, arg1) {
-        const ret = arg0.createShaderModule(arg1);
-        return ret;
+        const ret = getObject(arg0).createShaderModule(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createTexture_01cc1cd2fea732d9 = function(arg0, arg1) {
-        const ret = arg0.createTexture(arg1);
-        return ret;
+        const ret = getObject(arg0).createTexture(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_createView_04701884291e1ccc = function(arg0, arg1) {
-        const ret = arg0.createView(arg1);
-        return ret;
+        const ret = getObject(arg0).createView(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_debug_9d0c87ddda3dc485 = function(arg0) {
-        console.debug(arg0);
+        console.debug(getObject(arg0));
     };
     imports.wbg.__wbg_destroy_35f94012e5bb9c17 = function(arg0) {
-        arg0.destroy();
+        getObject(arg0).destroy();
     };
     imports.wbg.__wbg_destroy_767d9dde1008e293 = function(arg0) {
-        arg0.destroy();
+        getObject(arg0).destroy();
     };
     imports.wbg.__wbg_destroy_c6af4226dda95dbd = function(arg0) {
-        arg0.destroy();
+        getObject(arg0).destroy();
     };
     imports.wbg.__wbg_dispatchWorkgroupsIndirect_8b25efab93a7a433 = function(arg0, arg1, arg2) {
-        arg0.dispatchWorkgroupsIndirect(arg1, arg2);
+        getObject(arg0).dispatchWorkgroupsIndirect(getObject(arg1), arg2);
     };
     imports.wbg.__wbg_dispatchWorkgroups_c102fa81b955935d = function(arg0, arg1, arg2, arg3) {
-        arg0.dispatchWorkgroups(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0);
+        getObject(arg0).dispatchWorkgroups(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0);
     };
     imports.wbg.__wbg_document_5b745e82ba551ca5 = function(arg0) {
-        const ret = arg0.document;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        const ret = getObject(arg0).document;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
     imports.wbg.__wbg_drawIndexedIndirect_34484fc6227c7bc8 = function(arg0, arg1, arg2) {
-        arg0.drawIndexedIndirect(arg1, arg2);
+        getObject(arg0).drawIndexedIndirect(getObject(arg1), arg2);
     };
     imports.wbg.__wbg_drawIndexedIndirect_5a7c30bb5f1d5b67 = function(arg0, arg1, arg2) {
-        arg0.drawIndexedIndirect(arg1, arg2);
+        getObject(arg0).drawIndexedIndirect(getObject(arg1), arg2);
     };
     imports.wbg.__wbg_drawIndexed_115af1449b52a948 = function(arg0, arg1, arg2, arg3, arg4, arg5) {
-        arg0.drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
+        getObject(arg0).drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
     };
     imports.wbg.__wbg_drawIndexed_a587cce4c317791f = function(arg0, arg1, arg2, arg3, arg4, arg5) {
-        arg0.drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
+        getObject(arg0).drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
     };
     imports.wbg.__wbg_drawIndirect_036d71498a21f1a3 = function(arg0, arg1, arg2) {
-        arg0.drawIndirect(arg1, arg2);
+        getObject(arg0).drawIndirect(getObject(arg1), arg2);
     };
     imports.wbg.__wbg_drawIndirect_a1d7c5e893aa5756 = function(arg0, arg1, arg2) {
-        arg0.drawIndirect(arg1, arg2);
+        getObject(arg0).drawIndirect(getObject(arg1), arg2);
     };
     imports.wbg.__wbg_draw_5351b12033166aca = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+        getObject(arg0).draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
     };
     imports.wbg.__wbg_draw_e2a7c5d66fb2d244 = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+        getObject(arg0).draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
     };
     imports.wbg.__wbg_end_0ac71677a5c1717a = function(arg0) {
-        arg0.end();
+        getObject(arg0).end();
     };
     imports.wbg.__wbg_end_6f776519f1faa582 = function(arg0) {
-        arg0.end();
+        getObject(arg0).end();
     };
     imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         let deferred0_0;
@@ -660,109 +1481,109 @@ function __wbg_get_imports() {
             deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
-            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
         }
     };
     imports.wbg.__wbg_error_7bc7d576a6aaf855 = function(arg0) {
-        console.error(arg0);
+        console.error(getObject(arg0));
     };
     imports.wbg.__wbg_error_e98e6aadd08e0b94 = function(arg0) {
-        const ret = arg0.error;
-        return ret;
+        const ret = getObject(arg0).error;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_executeBundles_8e6c0614da2805d4 = function(arg0, arg1) {
-        arg0.executeBundles(arg1);
+        getObject(arg0).executeBundles(getObject(arg1));
     };
     imports.wbg.__wbg_features_1b464383ea8a7691 = function(arg0) {
-        const ret = arg0.features;
-        return ret;
+        const ret = getObject(arg0).features;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_features_e5fbbc2760867852 = function(arg0) {
-        const ret = arg0.features;
-        return ret;
+        const ret = getObject(arg0).features;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_finish_20711371c58df61c = function(arg0) {
-        const ret = arg0.finish();
-        return ret;
+        const ret = getObject(arg0).finish();
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_finish_34b2c54329c8719f = function(arg0, arg1) {
-        const ret = arg0.finish(arg1);
-        return ret;
+        const ret = getObject(arg0).finish(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_finish_a9ab917e756ea00c = function(arg0, arg1) {
-        const ret = arg0.finish(arg1);
-        return ret;
+        const ret = getObject(arg0).finish(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_finish_e0a6c97c0622f843 = function(arg0) {
-        const ret = arg0.finish();
-        return ret;
+        const ret = getObject(arg0).finish();
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_getBindGroupLayout_4a94df6108ac6667 = function(arg0, arg1) {
-        const ret = arg0.getBindGroupLayout(arg1 >>> 0);
-        return ret;
+        const ret = getObject(arg0).getBindGroupLayout(arg1 >>> 0);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_getBindGroupLayout_80e803d942962f6a = function(arg0, arg1) {
-        const ret = arg0.getBindGroupLayout(arg1 >>> 0);
-        return ret;
+        const ret = getObject(arg0).getBindGroupLayout(arg1 >>> 0);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_getCompilationInfo_2af3ecdfeda551a3 = function(arg0) {
-        const ret = arg0.getCompilationInfo();
-        return ret;
+        const ret = getObject(arg0).getCompilationInfo();
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_getContext_01f42b234e833f0a = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_getContext_2f210d0a58d43d95 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_getCurrentTexture_5a79cda2ff36e1ee = function(arg0) {
-        const ret = arg0.getCurrentTexture();
-        return ret;
+        const ret = getObject(arg0).getCurrentTexture();
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_getMappedRange_932dd043ae22ee0a = function(arg0, arg1, arg2) {
-        const ret = arg0.getMappedRange(arg1, arg2);
-        return ret;
+        const ret = getObject(arg0).getMappedRange(arg1, arg2);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_getPreferredCanvasFormat_de73c02773a5209e = function(arg0) {
-        const ret = arg0.getPreferredCanvasFormat();
+        const ret = getObject(arg0).getPreferredCanvasFormat();
         return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
     };
     imports.wbg.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
         globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
     }, arguments) };
     imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
-        const ret = arg0[arg1 >>> 0];
-        return ret;
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.get(arg0, arg1);
-        return ret;
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_get_c53d381635aa3929 = function(arg0, arg1) {
-        const ret = arg0[arg1 >>> 0];
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
     imports.wbg.__wbg_gpu_87871e8f7ace8fee = function(arg0) {
-        const ret = arg0.gpu;
-        return ret;
+        const ret = getObject(arg0).gpu;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_has_624cbf0451d880e8 = function(arg0, arg1, arg2) {
-        const ret = arg0.has(getStringFromWasm0(arg1, arg2));
+        const ret = getObject(arg0).has(getStringFromWasm0(arg1, arg2));
         return ret;
     };
     imports.wbg.__wbg_height_a07787f693c253d2 = function(arg0) {
-        const ret = arg0.height;
+        const ret = getObject(arg0).height;
         return ret;
     };
     imports.wbg.__wbg_info_ce6bcc489c22f6f0 = function(arg0) {
-        console.info(arg0);
+        console.info(getObject(arg0));
     };
     imports.wbg.__wbg_instanceof_GpuAdapter_0731153d2b08720b = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof GPUAdapter;
+            result = getObject(arg0) instanceof GPUAdapter;
         } catch (_) {
             result = false;
         }
@@ -772,7 +1593,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_instanceof_GpuCanvasContext_d14121c7bd72fcef = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof GPUCanvasContext;
+            result = getObject(arg0) instanceof GPUCanvasContext;
         } catch (_) {
             result = false;
         }
@@ -782,7 +1603,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_instanceof_GpuDeviceLostInfo_a3677ebb8241d800 = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof GPUDeviceLostInfo;
+            result = getObject(arg0) instanceof GPUDeviceLostInfo;
         } catch (_) {
             result = false;
         }
@@ -792,7 +1613,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_instanceof_GpuOutOfMemoryError_391d9a08edbfa04b = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof GPUOutOfMemoryError;
+            result = getObject(arg0) instanceof GPUOutOfMemoryError;
         } catch (_) {
             result = false;
         }
@@ -802,7 +1623,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_instanceof_GpuValidationError_f4d803c383da3c92 = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof GPUValidationError;
+            result = getObject(arg0) instanceof GPUValidationError;
         } catch (_) {
             result = false;
         }
@@ -812,7 +1633,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_instanceof_Object_577e21051f7bcb79 = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof Object;
+            result = getObject(arg0) instanceof Object;
         } catch (_) {
             result = false;
         }
@@ -822,7 +1643,7 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_instanceof_Window_b5cf7783caa68180 = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof Window;
+            result = getObject(arg0) instanceof Window;
         } catch (_) {
             result = false;
         }
@@ -830,207 +1651,207 @@ function __wbg_get_imports() {
         return ret;
     };
     imports.wbg.__wbg_label_2082ab37d2ad170d = function(arg0, arg1) {
-        const ret = arg1.label;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = getObject(arg1).label;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
     imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
-        const ret = arg0.length;
+        const ret = getObject(arg0).length;
         return ret;
     };
     imports.wbg.__wbg_length_9df32f7add647235 = function(arg0) {
-        const ret = arg0.length;
+        const ret = getObject(arg0).length;
         return ret;
     };
     imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
-        const ret = arg0.length;
+        const ret = getObject(arg0).length;
         return ret;
     };
     imports.wbg.__wbg_limits_2dd632c891786ddf = function(arg0) {
-        const ret = arg0.limits;
-        return ret;
+        const ret = getObject(arg0).limits;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_limits_f6411f884b0b2d62 = function(arg0) {
-        const ret = arg0.limits;
-        return ret;
+        const ret = getObject(arg0).limits;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_lineNum_0246de1e072ffe19 = function(arg0) {
-        const ret = arg0.lineNum;
+        const ret = getObject(arg0).lineNum;
         return ret;
     };
     imports.wbg.__wbg_log_1d990106d99dacb7 = function(arg0) {
-        console.log(arg0);
+        console.log(getObject(arg0));
     };
     imports.wbg.__wbg_lost_6e4d29847ce2a34a = function(arg0) {
-        const ret = arg0.lost;
-        return ret;
+        const ret = getObject(arg0).lost;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_mapAsync_37f5e03edf2e1352 = function(arg0, arg1, arg2, arg3) {
-        const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
-        return ret;
+        const ret = getObject(arg0).mapAsync(arg1 >>> 0, arg2, arg3);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_maxBindGroups_768ca5e8623bf450 = function(arg0) {
-        const ret = arg0.maxBindGroups;
+        const ret = getObject(arg0).maxBindGroups;
         return ret;
     };
     imports.wbg.__wbg_maxBindingsPerBindGroup_057972d600d69719 = function(arg0) {
-        const ret = arg0.maxBindingsPerBindGroup;
+        const ret = getObject(arg0).maxBindingsPerBindGroup;
         return ret;
     };
     imports.wbg.__wbg_maxBufferSize_e237b44f19a5a62b = function(arg0) {
-        const ret = arg0.maxBufferSize;
+        const ret = getObject(arg0).maxBufferSize;
         return ret;
     };
     imports.wbg.__wbg_maxColorAttachmentBytesPerSample_d6c7b4051d22c6d6 = function(arg0) {
-        const ret = arg0.maxColorAttachmentBytesPerSample;
+        const ret = getObject(arg0).maxColorAttachmentBytesPerSample;
         return ret;
     };
     imports.wbg.__wbg_maxColorAttachments_7a18ba24c05edcfd = function(arg0) {
-        const ret = arg0.maxColorAttachments;
+        const ret = getObject(arg0).maxColorAttachments;
         return ret;
     };
     imports.wbg.__wbg_maxComputeInvocationsPerWorkgroup_b99c2f3611633992 = function(arg0) {
-        const ret = arg0.maxComputeInvocationsPerWorkgroup;
+        const ret = getObject(arg0).maxComputeInvocationsPerWorkgroup;
         return ret;
     };
     imports.wbg.__wbg_maxComputeWorkgroupSizeX_adb26da9ed7f77f7 = function(arg0) {
-        const ret = arg0.maxComputeWorkgroupSizeX;
+        const ret = getObject(arg0).maxComputeWorkgroupSizeX;
         return ret;
     };
     imports.wbg.__wbg_maxComputeWorkgroupSizeY_cc217559c98be33b = function(arg0) {
-        const ret = arg0.maxComputeWorkgroupSizeY;
+        const ret = getObject(arg0).maxComputeWorkgroupSizeY;
         return ret;
     };
     imports.wbg.__wbg_maxComputeWorkgroupSizeZ_66606a80e2cf2309 = function(arg0) {
-        const ret = arg0.maxComputeWorkgroupSizeZ;
+        const ret = getObject(arg0).maxComputeWorkgroupSizeZ;
         return ret;
     };
     imports.wbg.__wbg_maxComputeWorkgroupStorageSize_cb6235497b8c4997 = function(arg0) {
-        const ret = arg0.maxComputeWorkgroupStorageSize;
+        const ret = getObject(arg0).maxComputeWorkgroupStorageSize;
         return ret;
     };
     imports.wbg.__wbg_maxComputeWorkgroupsPerDimension_6bf550b5f21d57cf = function(arg0) {
-        const ret = arg0.maxComputeWorkgroupsPerDimension;
+        const ret = getObject(arg0).maxComputeWorkgroupsPerDimension;
         return ret;
     };
     imports.wbg.__wbg_maxDynamicStorageBuffersPerPipelineLayout_c6ac20334e328b47 = function(arg0) {
-        const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
+        const ret = getObject(arg0).maxDynamicStorageBuffersPerPipelineLayout;
         return ret;
     };
     imports.wbg.__wbg_maxDynamicUniformBuffersPerPipelineLayout_aa8f14a74b440f01 = function(arg0) {
-        const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
+        const ret = getObject(arg0).maxDynamicUniformBuffersPerPipelineLayout;
         return ret;
     };
     imports.wbg.__wbg_maxSampledTexturesPerShaderStage_db7c4922cc60144a = function(arg0) {
-        const ret = arg0.maxSampledTexturesPerShaderStage;
+        const ret = getObject(arg0).maxSampledTexturesPerShaderStage;
         return ret;
     };
     imports.wbg.__wbg_maxSamplersPerShaderStage_538705fe2263e710 = function(arg0) {
-        const ret = arg0.maxSamplersPerShaderStage;
+        const ret = getObject(arg0).maxSamplersPerShaderStage;
         return ret;
     };
     imports.wbg.__wbg_maxStorageBufferBindingSize_32178c0f5f7f85cb = function(arg0) {
-        const ret = arg0.maxStorageBufferBindingSize;
+        const ret = getObject(arg0).maxStorageBufferBindingSize;
         return ret;
     };
     imports.wbg.__wbg_maxStorageBuffersPerShaderStage_9f67e9eae0089f77 = function(arg0) {
-        const ret = arg0.maxStorageBuffersPerShaderStage;
+        const ret = getObject(arg0).maxStorageBuffersPerShaderStage;
         return ret;
     };
     imports.wbg.__wbg_maxStorageTexturesPerShaderStage_57239664936031cf = function(arg0) {
-        const ret = arg0.maxStorageTexturesPerShaderStage;
+        const ret = getObject(arg0).maxStorageTexturesPerShaderStage;
         return ret;
     };
     imports.wbg.__wbg_maxTextureArrayLayers_db5d4e486c78ae04 = function(arg0) {
-        const ret = arg0.maxTextureArrayLayers;
+        const ret = getObject(arg0).maxTextureArrayLayers;
         return ret;
     };
     imports.wbg.__wbg_maxTextureDimension1D_3475085ffacabbdc = function(arg0) {
-        const ret = arg0.maxTextureDimension1D;
+        const ret = getObject(arg0).maxTextureDimension1D;
         return ret;
     };
     imports.wbg.__wbg_maxTextureDimension2D_7c8d5ecf09eb8519 = function(arg0) {
-        const ret = arg0.maxTextureDimension2D;
+        const ret = getObject(arg0).maxTextureDimension2D;
         return ret;
     };
     imports.wbg.__wbg_maxTextureDimension3D_8bd976677a0f91d4 = function(arg0) {
-        const ret = arg0.maxTextureDimension3D;
+        const ret = getObject(arg0).maxTextureDimension3D;
         return ret;
     };
     imports.wbg.__wbg_maxUniformBufferBindingSize_95b1a54e7e4a0f0f = function(arg0) {
-        const ret = arg0.maxUniformBufferBindingSize;
+        const ret = getObject(arg0).maxUniformBufferBindingSize;
         return ret;
     };
     imports.wbg.__wbg_maxUniformBuffersPerShaderStage_5f475d9a453af14d = function(arg0) {
-        const ret = arg0.maxUniformBuffersPerShaderStage;
+        const ret = getObject(arg0).maxUniformBuffersPerShaderStage;
         return ret;
     };
     imports.wbg.__wbg_maxVertexAttributes_4c48ca2f5d32f860 = function(arg0) {
-        const ret = arg0.maxVertexAttributes;
+        const ret = getObject(arg0).maxVertexAttributes;
         return ret;
     };
     imports.wbg.__wbg_maxVertexBufferArrayStride_2233f6933ecc5a16 = function(arg0) {
-        const ret = arg0.maxVertexBufferArrayStride;
+        const ret = getObject(arg0).maxVertexBufferArrayStride;
         return ret;
     };
     imports.wbg.__wbg_maxVertexBuffers_c47e508cd7348554 = function(arg0) {
-        const ret = arg0.maxVertexBuffers;
+        const ret = getObject(arg0).maxVertexBuffers;
         return ret;
     };
     imports.wbg.__wbg_message_0762358e59db7ed6 = function(arg0, arg1) {
-        const ret = arg1.message;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = getObject(arg1).message;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
     imports.wbg.__wbg_message_7957ab09f64c6822 = function(arg0, arg1) {
-        const ret = arg1.message;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = getObject(arg1).message;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
     imports.wbg.__wbg_message_b163994503433c9e = function(arg0, arg1) {
-        const ret = arg1.message;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = getObject(arg1).message;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
     imports.wbg.__wbg_messages_da071582f72bc978 = function(arg0) {
-        const ret = arg0.messages;
-        return ret;
+        const ret = getObject(arg0).messages;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_minStorageBufferOffsetAlignment_51b4801fac3a58de = function(arg0) {
-        const ret = arg0.minStorageBufferOffsetAlignment;
+        const ret = getObject(arg0).minStorageBufferOffsetAlignment;
         return ret;
     };
     imports.wbg.__wbg_minUniformBufferOffsetAlignment_5d62a77924b2335f = function(arg0) {
-        const ret = arg0.minUniformBufferOffsetAlignment;
+        const ret = getObject(arg0).minUniformBufferOffsetAlignment;
         return ret;
     };
     imports.wbg.__wbg_navigator_11b7299bb7886507 = function(arg0) {
-        const ret = arg0.navigator;
-        return ret;
+        const ret = getObject(arg0).navigator;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_navigator_b49edef831236138 = function(arg0) {
-        const ret = arg0.navigator;
-        return ret;
+        const ret = getObject(arg0).navigator;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
         const ret = new Object();
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_25f239778d6112b9 = function() {
         const ret = new Array();
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
         const ret = new Error();
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
         try {
@@ -1039,273 +1860,281 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return wasm_bindgen__convert__closures_____invoke__h320f3d825d3712ba(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_11945(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
             };
             const ret = new Promise(cb0);
-            return ret;
+            return addHeapObject(ret);
         } finally {
             state0.a = state0.b = 0;
         }
     };
     imports.wbg.__wbg_new_from_slice_f9c22b9153b26992 = function(arg0, arg1) {
         const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_with_byte_offset_and_length_d85c3da1fd8df149 = function(arg0, arg1, arg2) {
-        const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
-        return ret;
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_now_8cf15d6e317793e1 = function(arg0) {
-        const ret = arg0.now();
+        const ret = getObject(arg0).now();
         return ret;
     };
     imports.wbg.__wbg_offset_336f14c993863b76 = function(arg0) {
-        const ret = arg0.offset;
+        const ret = getObject(arg0).offset;
         return ret;
     };
+    imports.wbg.__wbg_performance_c77a440eff2efd9b = function(arg0) {
+        const ret = getObject(arg0).performance;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
     imports.wbg.__wbg_popErrorScope_af0b22f136a861d6 = function(arg0) {
-        const ret = arg0.popErrorScope();
-        return ret;
+        const ret = getObject(arg0).popErrorScope();
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
-        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
     };
     imports.wbg.__wbg_pushErrorScope_b52914ff10ba6ce3 = function(arg0, arg1) {
-        arg0.pushErrorScope(__wbindgen_enum_GpuErrorFilter[arg1]);
+        getObject(arg0).pushErrorScope(__wbindgen_enum_GpuErrorFilter[arg1]);
     };
     imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
-        const ret = arg0.push(arg1);
+        const ret = getObject(arg0).push(getObject(arg1));
         return ret;
     };
     imports.wbg.__wbg_querySelectorAll_aa1048eae18f6f1a = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = arg0.querySelectorAll(getStringFromWasm0(arg1, arg2));
-        return ret;
+        const ret = getObject(arg0).querySelectorAll(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
-        const ret = arg0.queueMicrotask;
-        return ret;
+        const ret = getObject(arg0).queueMicrotask;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_queueMicrotask_fca69f5bfad613a5 = function(arg0) {
-        queueMicrotask(arg0);
+        queueMicrotask(getObject(arg0));
     };
     imports.wbg.__wbg_queue_bea4017efaaf9904 = function(arg0) {
-        const ret = arg0.queue;
-        return ret;
+        const ret = getObject(arg0).queue;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_reason_43acd39cce242b50 = function(arg0) {
-        const ret = arg0.reason;
+        const ret = getObject(arg0).reason;
         return (__wbindgen_enum_GpuDeviceLostReason.indexOf(ret) + 1 || 3) - 1;
     };
     imports.wbg.__wbg_requestAdapter_e6dcfac497cafa7a = function(arg0, arg1) {
-        const ret = arg0.requestAdapter(arg1);
-        return ret;
+        const ret = getObject(arg0).requestAdapter(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_requestDevice_03b802707d5a382c = function(arg0, arg1) {
-        const ret = arg0.requestDevice(arg1);
-        return ret;
+        const ret = getObject(arg0).requestDevice(getObject(arg1));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_resolveQuerySet_811661fb23f3b699 = function(arg0, arg1, arg2, arg3, arg4, arg5) {
-        arg0.resolveQuerySet(arg1, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
+        getObject(arg0).resolveQuerySet(getObject(arg1), arg2 >>> 0, arg3 >>> 0, getObject(arg4), arg5 >>> 0);
     };
     imports.wbg.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
-        const ret = Promise.resolve(arg0);
-        return ret;
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_setBindGroup_62a3045b0921e429 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
-        arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
+        getObject(arg0).setBindGroup(arg1 >>> 0, getObject(arg2), getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
     };
     imports.wbg.__wbg_setBindGroup_6c0fd18e9a53a945 = function(arg0, arg1, arg2) {
-        arg0.setBindGroup(arg1 >>> 0, arg2);
+        getObject(arg0).setBindGroup(arg1 >>> 0, getObject(arg2));
     };
     imports.wbg.__wbg_setBindGroup_7f3b61f1f482133b = function(arg0, arg1, arg2) {
-        arg0.setBindGroup(arg1 >>> 0, arg2);
+        getObject(arg0).setBindGroup(arg1 >>> 0, getObject(arg2));
     };
     imports.wbg.__wbg_setBindGroup_bf767a5aa46a33ce = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
-        arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
+        getObject(arg0).setBindGroup(arg1 >>> 0, getObject(arg2), getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
     };
     imports.wbg.__wbg_setBindGroup_c4aaff14063226b4 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
-        arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
+        getObject(arg0).setBindGroup(arg1 >>> 0, getObject(arg2), getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
     };
     imports.wbg.__wbg_setBindGroup_f82e771dc1b69093 = function(arg0, arg1, arg2) {
-        arg0.setBindGroup(arg1 >>> 0, arg2);
+        getObject(arg0).setBindGroup(arg1 >>> 0, getObject(arg2));
     };
     imports.wbg.__wbg_setBlendConstant_016723821cfb3aa4 = function(arg0, arg1) {
-        arg0.setBlendConstant(arg1);
+        getObject(arg0).setBlendConstant(getObject(arg1));
     };
     imports.wbg.__wbg_setIndexBuffer_286a40afdff411b7 = function(arg0, arg1, arg2, arg3) {
-        arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3);
+        getObject(arg0).setIndexBuffer(getObject(arg1), __wbindgen_enum_GpuIndexFormat[arg2], arg3);
     };
     imports.wbg.__wbg_setIndexBuffer_7efd0b7a40c65fb9 = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
+        getObject(arg0).setIndexBuffer(getObject(arg1), __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
     };
     imports.wbg.__wbg_setIndexBuffer_e091a9673bb575e2 = function(arg0, arg1, arg2, arg3) {
-        arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3);
+        getObject(arg0).setIndexBuffer(getObject(arg1), __wbindgen_enum_GpuIndexFormat[arg2], arg3);
     };
     imports.wbg.__wbg_setIndexBuffer_f0759f00036f615f = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
+        getObject(arg0).setIndexBuffer(getObject(arg1), __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
     };
     imports.wbg.__wbg_setPipeline_ba92070b8ee81cf9 = function(arg0, arg1) {
-        arg0.setPipeline(arg1);
+        getObject(arg0).setPipeline(getObject(arg1));
     };
     imports.wbg.__wbg_setPipeline_c344f76bae58c4d6 = function(arg0, arg1) {
-        arg0.setPipeline(arg1);
+        getObject(arg0).setPipeline(getObject(arg1));
     };
     imports.wbg.__wbg_setPipeline_d76451c50a121598 = function(arg0, arg1) {
-        arg0.setPipeline(arg1);
+        getObject(arg0).setPipeline(getObject(arg1));
     };
     imports.wbg.__wbg_setScissorRect_0b6ee0852ef0b6b9 = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.setScissorRect(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+        getObject(arg0).setScissorRect(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
     };
     imports.wbg.__wbg_setStencilReference_34fd3d59673a5a9d = function(arg0, arg1) {
-        arg0.setStencilReference(arg1 >>> 0);
+        getObject(arg0).setStencilReference(arg1 >>> 0);
     };
     imports.wbg.__wbg_setVertexBuffer_06a90dc78e1ad9c4 = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
+        getObject(arg0).setVertexBuffer(arg1 >>> 0, getObject(arg2), arg3, arg4);
     };
     imports.wbg.__wbg_setVertexBuffer_1540e9118b6c451d = function(arg0, arg1, arg2, arg3) {
-        arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3);
+        getObject(arg0).setVertexBuffer(arg1 >>> 0, getObject(arg2), arg3);
     };
     imports.wbg.__wbg_setVertexBuffer_5166eedc06450701 = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
+        getObject(arg0).setVertexBuffer(arg1 >>> 0, getObject(arg2), arg3, arg4);
     };
     imports.wbg.__wbg_setVertexBuffer_8621784e5014065b = function(arg0, arg1, arg2, arg3) {
-        arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3);
+        getObject(arg0).setVertexBuffer(arg1 >>> 0, getObject(arg2), arg3);
     };
     imports.wbg.__wbg_setViewport_731ad30abb13f744 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
-        arg0.setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
+        getObject(arg0).setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
     };
     imports.wbg.__wbg_set_781438a03c0c3c81 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = Reflect.set(arg0, arg1, arg2);
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
         return ret;
     }, arguments) };
     imports.wbg.__wbg_set_bc3a432bdcd60886 = function(arg0, arg1, arg2) {
-        arg0.set(arg1, arg2 >>> 0);
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
     imports.wbg.__wbg_set_height_6f8f8ef4cb40e496 = function(arg0, arg1) {
-        arg0.height = arg1 >>> 0;
+        getObject(arg0).height = arg1 >>> 0;
     };
     imports.wbg.__wbg_set_height_afe09c24165867f7 = function(arg0, arg1) {
-        arg0.height = arg1 >>> 0;
+        getObject(arg0).height = arg1 >>> 0;
     };
     imports.wbg.__wbg_set_onuncapturederror_19541466822d790b = function(arg0, arg1) {
-        arg0.onuncapturederror = arg1;
+        getObject(arg0).onuncapturederror = getObject(arg1);
     };
     imports.wbg.__wbg_set_width_0a22c810f06a5152 = function(arg0, arg1) {
-        arg0.width = arg1 >>> 0;
+        getObject(arg0).width = arg1 >>> 0;
     };
     imports.wbg.__wbg_set_width_7ff7a22c6e9f423e = function(arg0, arg1) {
-        arg0.width = arg1 >>> 0;
+        getObject(arg0).width = arg1 >>> 0;
     };
     imports.wbg.__wbg_size_661bddb3f9898121 = function(arg0) {
-        const ret = arg0.size;
+        const ret = getObject(arg0).size;
         return ret;
     };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-        const ret = arg1.stack;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = getObject(arg1).stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
     imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
         const ret = typeof global === 'undefined' ? null : global;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
     imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
         const ret = typeof globalThis === 'undefined' ? null : globalThis;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
     imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
         const ret = typeof self === 'undefined' ? null : self;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
     imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
         const ret = typeof window === 'undefined' ? null : window;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
     imports.wbg.__wbg_submit_f635072bb3d05faa = function(arg0, arg1) {
-        arg0.submit(arg1);
+        getObject(arg0).submit(getObject(arg1));
     };
     imports.wbg.__wbg_then_429f7caf1026411d = function(arg0, arg1, arg2) {
-        const ret = arg0.then(arg1, arg2);
-        return ret;
+        const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
-        const ret = arg0.then(arg1);
-        return ret;
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_timeEnd_46ed224117e5f2d2 = function(arg0, arg1) {
+        console.timeEnd(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_time_c49415b636fbbf3f = function(arg0, arg1) {
+        console.time(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_type_c0d5d83032e9858a = function(arg0) {
-        const ret = arg0.type;
+        const ret = getObject(arg0).type;
         return (__wbindgen_enum_GpuCompilationMessageType.indexOf(ret) + 1 || 4) - 1;
     };
     imports.wbg.__wbg_unmap_8c2e8131b2aaa844 = function(arg0) {
-        arg0.unmap();
+        getObject(arg0).unmap();
     };
     imports.wbg.__wbg_usage_13caa02888040e9f = function(arg0) {
-        const ret = arg0.usage;
+        const ret = getObject(arg0).usage;
         return ret;
     };
     imports.wbg.__wbg_valueOf_663ea9f1ad0d6eda = function(arg0) {
-        const ret = arg0.valueOf();
-        return ret;
+        const ret = getObject(arg0).valueOf();
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
-        console.warn(arg0);
+        console.warn(getObject(arg0));
     };
     imports.wbg.__wbg_wasmvisualiser_new = function(arg0) {
         const ret = WasmVisualiser.__wrap(arg0);
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbg_width_dd0cfe94d42f5143 = function(arg0) {
-        const ret = arg0.width;
+        const ret = getObject(arg0).width;
         return ret;
     };
     imports.wbg.__wbg_writeBuffer_5ca4981365eb5ac0 = function(arg0, arg1, arg2, arg3, arg4, arg5) {
-        arg0.writeBuffer(arg1, arg2, arg3, arg4, arg5);
+        getObject(arg0).writeBuffer(getObject(arg1), arg2, getObject(arg3), arg4, arg5);
     };
     imports.wbg.__wbg_writeTexture_246118eb2f5a1592 = function(arg0, arg1, arg2, arg3, arg4) {
-        arg0.writeTexture(arg1, arg2, arg3, arg4);
-    };
-    imports.wbg.__wbindgen_cast_1ad8672233d2fd7b = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 2007, function: Function { arguments: [Externref], shim_idx: 2008, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hf5eaa61ced318e08, wasm_bindgen__convert__closures_____invoke__h53437a38721e89f7);
-        return ret;
+        getObject(arg0).writeTexture(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
     };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
-        return ret;
+        return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_762879c56a766cac = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 1873, function: Function { arguments: [NamedExternref("GPUUncapturedErrorEvent")], shim_idx: 1874, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__heb49a8f426ac2d2e, wasm_bindgen__convert__closures_____invoke__h9d1c5a23ecfcd5c8);
-        return ret;
+    imports.wbg.__wbindgen_cast_4131bd36079921a0 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 2988, function: Function { arguments: [NamedExternref("GPUUncapturedErrorEvent")], shim_idx: 2989, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_10192, __wasm_bindgen_func_elem_10256);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_4ebfb3f8f53af193 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 3193, function: Function { arguments: [Externref], shim_idx: 3194, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_11323, __wasm_bindgen_func_elem_11338);
+        return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
         const ret = getArrayU8FromWasm0(arg0, arg1);
-        return ret;
+        return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;
-        return ret;
+        return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_externrefs;
-        const offset = table.grow(4);
-        table.set(0, undefined);
-        table.set(offset + 0, undefined);
-        table.set(offset + 1, null);
-        table.set(offset + 2, true);
-        table.set(offset + 3, false);
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
     };
 
     return imports;
@@ -1320,7 +2149,7 @@ function __wbg_finalize_init(instance, module) {
     cachedUint8ArrayMemory0 = null;
 
 
-    wasm.__wbindgen_start();
+
     return wasm;
 }