goudengine 0.0.828 → 0.0.831

package/wasm/goud_engine.js

@@ -1,5 +1,8 @@
 /* @ts-self-types="./goud_engine.d.ts" */
 
+/**
+ * Collision contact data returned by wasm collision helper methods.
+ */
 export class WasmContact {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -19,6 +22,7 @@ export class WasmContact {
         wasm.__wbg_wasmcontact_free(ptr, 0);
     }
     /**
+     * Contact normal X component.
      * @returns {number}
      */
     get normal_x() {
@@ -26,6 +30,7 @@ export class WasmContact {
         return ret;
     }
     /**
+     * Contact normal Y component.
      * @returns {number}
      */
     get normal_y() {
@@ -33,6 +38,7 @@ export class WasmContact {
         return ret;
     }
     /**
+     * Penetration depth along the contact normal.
      * @returns {number}
      */
     get penetration() {
@@ -40,6 +46,7 @@ export class WasmContact {
         return ret;
     }
     /**
+     * Contact point X coordinate.
      * @returns {number}
      */
     get point_x() {
@@ -47,6 +54,7 @@ export class WasmContact {
         return ret;
     }
     /**
+     * Contact point Y coordinate.
      * @returns {number}
      */
     get point_y() {
@@ -54,30 +62,35 @@ export class WasmContact {
         return ret;
     }
     /**
+     * Contact normal X component.
      * @param {number} arg0
      */
     set normal_x(arg0) {
         wasm.__wbg_set_wasmcontact_normal_x(this.__wbg_ptr, arg0);
     }
     /**
+     * Contact normal Y component.
      * @param {number} arg0
      */
     set normal_y(arg0) {
         wasm.__wbg_set_wasmcontact_normal_y(this.__wbg_ptr, arg0);
     }
     /**
+     * Penetration depth along the contact normal.
      * @param {number} arg0
      */
     set penetration(arg0) {
         wasm.__wbg_set_wasmcontact_penetration(this.__wbg_ptr, arg0);
     }
     /**
+     * Contact point X coordinate.
      * @param {number} arg0
      */
     set point_x(arg0) {
         wasm.__wbg_set_wasmcontact_point_x(this.__wbg_ptr, arg0);
     }
     /**
+     * Contact point Y coordinate.
      * @param {number} arg0
      */
     set point_y(arg0) {
@@ -111,6 +124,7 @@ export class WasmGame {
         wasm.__wbg_wasmgame_free(ptr, 0);
     }
     /**
+     * Returns whether two AABBs overlap.
      * @param {number} min_ax
      * @param {number} min_ay
      * @param {number} max_ax
@@ -126,6 +140,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Inserts or replaces `Name` on the entity.
      * @param {bigint} entity_bits
      * @param {string} name
      */
@@ -135,6 +150,7 @@ export class WasmGame {
         wasm.wasmgame_add_name(this.__wbg_ptr, entity_bits, ptr0, len0);
     }
     /**
+     * Accumulates scroll delta for the current frame.
      * @param {number} dx
      * @param {number} dy
      */
@@ -142,6 +158,7 @@ export class WasmGame {
         wasm.wasmgame_add_scroll_delta(this.__wbg_ptr, dx, dy);
     }
     /**
+     * Inserts or replaces `Sprite` on the entity.
      * @param {bigint} entity_bits
      * @param {number} texture_handle
      * @param {number} r
@@ -157,6 +174,7 @@ export class WasmGame {
         wasm.wasmgame_add_sprite(this.__wbg_ptr, entity_bits, texture_handle, r, g, b, a, flip_x, flip_y, anchor_x, anchor_y);
     }
     /**
+     * Inserts or replaces `Transform2D` on the entity.
      * @param {bigint} entity_bits
      * @param {number} px
      * @param {number} py
@@ -167,6 +185,210 @@ export class WasmGame {
     add_transform2d(entity_bits, px, py, rotation, sx, sy) {
         wasm.wasmgame_add_transform2d(this.__wbg_ptr, entity_bits, px, py, rotation, sx, sy);
     }
+    /**
+     * Creates or resumes the WebAudio context.
+     *
+     * Call this from the first user gesture (click/touch/key) to satisfy
+     * browser autoplay restrictions.
+     * @returns {number}
+     */
+    audio_activate() {
+        const ret = wasm.wasmgame_audio_activate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Applies an immediate two-player mix in `[0, 1]`.
+     * @param {number} from_player_id
+     * @param {number} to_player_id
+     * @param {number} mix
+     * @returns {number}
+     */
+    audio_crossfade(from_player_id, to_player_id, mix) {
+        const ret = wasm.wasmgame_audio_crossfade(this.__wbg_ptr, from_player_id, to_player_id, mix);
+        return ret;
+    }
+    /**
+     * Pauses a player's playback.
+     * @param {number} player_id
+     * @returns {number}
+     */
+    audio_pause(player_id) {
+        const ret = wasm.wasmgame_audio_pause(this.__wbg_ptr, player_id);
+        return ret;
+    }
+    /**
+     * Plays audio without spatialization defaults.
+     * @param {Uint8Array} asset_data
+     * @returns {number}
+     */
+    audio_play(asset_data) {
+        const ptr0 = passArray8ToWasm0(asset_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_audio_play(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Plays audio with spatial attenuation in 2D (`z = 0`).
+     * @param {Uint8Array} asset_data
+     * @param {number} source_x
+     * @param {number} source_y
+     * @param {number} listener_x
+     * @param {number} listener_y
+     * @param {number} max_distance
+     * @param {number} rolloff
+     * @returns {number}
+     */
+    audio_play_spatial(asset_data, source_x, source_y, listener_x, listener_y, max_distance, rolloff) {
+        const ptr0 = passArray8ToWasm0(asset_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_audio_play_spatial(this.__wbg_ptr, ptr0, len0, source_x, source_y, listener_x, listener_y, max_distance, rolloff);
+        return ret;
+    }
+    /**
+     * Plays audio with spatial attenuation in 3D.
+     * @param {Uint8Array} asset_data
+     * @param {number} source_x
+     * @param {number} source_y
+     * @param {number} source_z
+     * @param {number} listener_x
+     * @param {number} listener_y
+     * @param {number} listener_z
+     * @param {number} max_distance
+     * @param {number} rolloff
+     * @returns {number}
+     */
+    audio_play_spatial_3d(asset_data, source_x, source_y, source_z, listener_x, listener_y, listener_z, max_distance, rolloff) {
+        const ptr0 = passArray8ToWasm0(asset_data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_audio_play_spatial_3d(this.__wbg_ptr, ptr0, len0, source_x, source_y, source_z, listener_x, listener_y, listener_z, max_distance, rolloff);
+        return ret;
+    }
+    /**
+     * Resumes a paused player.
+     * @param {number} player_id
+     * @returns {number}
+     */
+    audio_resume(player_id) {
+        const ret = wasm.wasmgame_audio_resume(this.__wbg_ptr, player_id);
+        return ret;
+    }
+    /**
+     * Sets the global spatial listener position in 2D (`z = 0`).
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    audio_set_listener_position(x, y) {
+        const ret = wasm.wasmgame_audio_set_listener_position(this.__wbg_ptr, x, y);
+        return ret;
+    }
+    /**
+     * Sets the global spatial listener position in 3D.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    audio_set_listener_position_3d(x, y, z) {
+        const ret = wasm.wasmgame_audio_set_listener_position_3d(this.__wbg_ptr, x, y, z);
+        return ret;
+    }
+    /**
+     * Sets a player's playback speed in `[0.1, 10.0]`.
+     * @param {number} player_id
+     * @param {number} speed
+     * @returns {number}
+     */
+    audio_set_player_speed(player_id, speed) {
+        const ret = wasm.wasmgame_audio_set_player_speed(this.__wbg_ptr, player_id, speed);
+        return ret;
+    }
+    /**
+     * Sets a player's base volume in `[0, 1]`.
+     * @param {number} player_id
+     * @param {number} volume
+     * @returns {number}
+     */
+    audio_set_player_volume(player_id, volume) {
+        const ret = wasm.wasmgame_audio_set_player_volume(this.__wbg_ptr, player_id, volume);
+        return ret;
+    }
+    /**
+     * Sets (or updates) a player source position in 2D (`z = 0`).
+     * @param {number} player_id
+     * @param {number} x
+     * @param {number} y
+     * @param {number} max_distance
+     * @param {number} rolloff
+     * @returns {number}
+     */
+    audio_set_source_position(player_id, x, y, max_distance, rolloff) {
+        const ret = wasm.wasmgame_audio_set_source_position(this.__wbg_ptr, player_id, x, y, max_distance, rolloff);
+        return ret;
+    }
+    /**
+     * Sets (or updates) a player source position in 3D.
+     * @param {number} player_id
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} max_distance
+     * @param {number} rolloff
+     * @returns {number}
+     */
+    audio_set_source_position_3d(player_id, x, y, z, max_distance, rolloff) {
+        const ret = wasm.wasmgame_audio_set_source_position_3d(this.__wbg_ptr, player_id, x, y, z, max_distance, rolloff);
+        return ret;
+    }
+    /**
+     * Stops a player and releases its WebAudio resources.
+     * @param {number} player_id
+     * @returns {number}
+     */
+    audio_stop(player_id) {
+        const ret = wasm.wasmgame_audio_stop(this.__wbg_ptr, player_id);
+        return ret;
+    }
+    /**
+     * Stops all active players and releases their WebAudio resources.
+     * @returns {number}
+     */
+    audio_stop_all() {
+        const ret = wasm.wasmgame_audio_stop_all(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Updates attenuation for a playing spatial source in 2D (`z = 0`).
+     * @param {number} player_id
+     * @param {number} source_x
+     * @param {number} source_y
+     * @param {number} listener_x
+     * @param {number} listener_y
+     * @param {number} max_distance
+     * @param {number} rolloff
+     * @returns {number}
+     */
+    audio_update_spatial_volume(player_id, source_x, source_y, listener_x, listener_y, max_distance, rolloff) {
+        const ret = wasm.wasmgame_audio_update_spatial_volume(this.__wbg_ptr, player_id, source_x, source_y, listener_x, listener_y, max_distance, rolloff);
+        return ret;
+    }
+    /**
+     * Updates attenuation for a playing spatial source in 3D.
+     * @param {number} player_id
+     * @param {number} source_x
+     * @param {number} source_y
+     * @param {number} source_z
+     * @param {number} listener_x
+     * @param {number} listener_y
+     * @param {number} listener_z
+     * @param {number} max_distance
+     * @param {number} rolloff
+     * @returns {number}
+     */
+    audio_update_spatial_volume_3d(player_id, source_x, source_y, source_z, listener_x, listener_y, listener_z, max_distance, rolloff) {
+        const ret = wasm.wasmgame_audio_update_spatial_volume_3d(this.__wbg_ptr, player_id, source_x, source_y, source_z, listener_x, listener_y, listener_z, max_distance, rolloff);
+        return ret;
+    }
     /**
      * Advances frame timing and prepares the wgpu surface for drawing.
      *
@@ -177,6 +399,30 @@ export class WasmGame {
         wasm.wasmgame_begin_frame(this.__wbg_ptr, delta_time);
     }
     /**
+     * Capture the canvas as a base64-encoded PNG data URL.
+     * The actual canvas capture is done in JS via canvas.toDataURL().
+     * @returns {string}
+     */
+    captureCanvasBase64() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmgame_captureCanvasBase64(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Returns whether two circles overlap.
      * @param {number} x1
      * @param {number} y1
      * @param {number} r1
@@ -190,6 +436,24 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Overlay handle selection is unsupported in browser networking mode.
+     * @returns {number}
+     */
+    clear_network_overlay_handle() {
+        const ret = wasm.wasmgame_clear_network_overlay_handle(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Network simulation controls are unsupported in browser networking mode.
+     * @param {number} _handle
+     * @returns {number}
+     */
+    clear_network_simulation(_handle) {
+        const ret = wasm.wasmgame_clear_network_simulation(this.__wbg_ptr, _handle);
+        return ret;
+    }
+    /**
+     * Tests axis-aligned box vs axis-aligned box overlap and returns contact data.
      * @param {number} center_ax
      * @param {number} center_ay
      * @param {number} half_wa
@@ -205,6 +469,7 @@ export class WasmGame {
         return ret === 0 ? undefined : WasmContact.__wrap(ret);
     }
     /**
+     * Tests circle vs axis-aligned box overlap and returns contact data.
      * @param {number} cx
      * @param {number} cy
      * @param {number} cr
@@ -219,6 +484,7 @@ export class WasmGame {
         return ret === 0 ? undefined : WasmContact.__wrap(ret);
     }
     /**
+     * Tests circle vs circle overlap and returns contact data.
      * @param {number} center_ax
      * @param {number} center_ay
      * @param {number} radius_a
@@ -254,6 +520,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Despawns an entity by packed entity bits.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -274,12 +541,45 @@ export class WasmGame {
         return ret >>> 0;
     }
     /**
+     * Destroys a loaded font and any backing atlas textures.
+     * @param {number} handle
+     * @returns {boolean}
+     */
+    destroy_font(handle) {
+        const ret = wasm.wasmgame_destroy_font(this.__wbg_ptr, handle);
+        return ret !== 0;
+    }
+    /**
+     * Releases a previously registered texture handle.
+     *
+     * Handle `0` is reserved and ignored.
      * @param {number} handle
      */
     destroy_texture(handle) {
         wasm.wasmgame_destroy_texture(this.__wbg_ptr, handle);
     }
     /**
+     * Dispatch a JSON debugger request and return the JSON response.
+     * Used by the WebSocket relay to forward IPC verbs.
+     * @param {string} json
+     * @returns {string}
+     */
+    dispatchDebuggerRequest(json) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmgame_dispatchDebuggerRequest(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Returns Euclidean distance between two points.
      * @param {number} x1
      * @param {number} y1
      * @param {number} x2
@@ -291,6 +591,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Returns squared Euclidean distance between two points.
      * @param {number} x1
      * @param {number} y1
      * @param {number} x2
@@ -302,6 +603,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Draws a solid-color quad using the renderer fallback texture.
      * @param {number} x
      * @param {number} y
      * @param {number} w
@@ -315,6 +617,9 @@ export class WasmGame {
         wasm.wasmgame_draw_quad(this.__wbg_ptr, x, y, w, h, r, g, b, a);
     }
     /**
+     * Draws a textured sprite in world or screen space.
+     *
+     * `texture` is a 1-based handle returned by `register_texture_from_bytes`.
      * @param {number} texture
      * @param {number} x
      * @param {number} y
@@ -330,6 +635,9 @@ export class WasmGame {
         wasm.wasmgame_draw_sprite(this.__wbg_ptr, texture, x, y, w, h, rotation, r, g, b, a);
     }
     /**
+     * Draws a textured sprite using a source rectangle in texture UV space.
+     *
+     * Returns `true` when the draw command is queued.
      * @param {number} texture
      * @param {number} x
      * @param {number} y
@@ -350,6 +658,32 @@ export class WasmGame {
         const ret = wasm.wasmgame_draw_sprite_rect(this.__wbg_ptr, texture, x, y, w, h, rotation, src_x, src_y, src_w, src_h, r, g, b, a);
         return ret !== 0;
     }
+    /**
+     * Draws shaped text with alignment, wrapping, spacing, direction, and tint.
+     *
+     * `alignment`: 0 = Left, 1 = Center, 2 = Right
+     * `direction`: 0 = Auto, 1 = LTR, 2 = RTL
+     * @param {number} font_handle
+     * @param {string} text
+     * @param {number} x
+     * @param {number} y
+     * @param {number} font_size
+     * @param {number} alignment
+     * @param {number} max_width
+     * @param {number} line_spacing
+     * @param {number} direction
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     * @returns {boolean}
+     */
+    draw_text(font_handle, text, x, y, font_size, alignment, max_width, line_spacing, direction, r, g, b, a) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_draw_text(this.__wbg_ptr, font_handle, ptr0, len0, x, y, font_size, alignment, max_width, line_spacing, direction, r, g, b, a);
+        return ret !== 0;
+    }
     /**
      * Flushes queued draw calls and presents the frame to the canvas.
      *
@@ -359,6 +693,7 @@ export class WasmGame {
         wasm.wasmgame_end_frame(this.__wbg_ptr);
     }
     /**
+     * Returns the number of currently alive entities.
      * @returns {number}
      */
     entity_count() {
@@ -382,6 +717,23 @@ export class WasmGame {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * Get the debugger snapshot as JSON.
+     * @returns {string}
+     */
+    getDebuggerSnapshotJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmgame_getDebuggerSnapshotJson(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Gets the entity's `Name`.
      * @param {bigint} entity_bits
      * @returns {string | undefined}
      */
@@ -394,6 +746,23 @@ export class WasmGame {
         }
         return v1;
     }
+    /**
+     * Returns network capabilities for browser/WebSocket mode.
+     * @returns {WasmNetworkCapabilities}
+     */
+    get_network_capabilities() {
+        const ret = wasm.wasmgame_get_network_capabilities(this.__wbg_ptr);
+        return WasmNetworkCapabilities.__wrap(ret);
+    }
+    /**
+     * Returns aggregate stats for a specific network handle.
+     * @param {number} handle
+     * @returns {WasmNetworkStats}
+     */
+    get_network_stats(handle) {
+        const ret = wasm.wasmgame_get_network_stats(this.__wbg_ptr, handle);
+        return WasmNetworkStats.__wrap(ret);
+    }
     /**
      * Returns render statistics for the current frame, or `None` if
      * rendering is not active.
@@ -404,6 +773,7 @@ export class WasmGame {
         return ret === 0 ? undefined : WasmRenderStats.__wrap(ret);
     }
     /**
+     * Gets the entity's `Sprite` as a wasm-safe DTO.
      * @param {bigint} entity_bits
      * @returns {WasmSprite | undefined}
      */
@@ -412,6 +782,7 @@ export class WasmGame {
         return ret === 0 ? undefined : WasmSprite.__wrap(ret);
     }
     /**
+     * Gets the entity's `Transform2D` as a wasm-safe DTO.
      * @param {bigint} entity_bits
      * @returns {WasmTransform2D | undefined}
      */
@@ -420,6 +791,7 @@ export class WasmGame {
         return ret === 0 ? undefined : WasmTransform2D.__wrap(ret);
     }
     /**
+     * Returns whether the entity has a `Name` component.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -437,6 +809,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether the entity has a `Sprite` component.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -445,6 +818,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether the entity has a `Transform2D` component.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -452,6 +826,16 @@ export class WasmGame {
         const ret = wasm.wasmgame_has_transform2d(this.__wbg_ptr, entity_bits);
         return ret !== 0;
     }
+    /**
+     * Initialize the debugger route for this game instance.
+     * Call this once after construction to enable debugger support.
+     * @param {string} route_label
+     */
+    initDebugger(route_label) {
+        const ptr0 = passStringToWasm0(route_label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmgame_initDebugger(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Returns `true` if any key mapped to the given action was just pressed
      * this frame (not held from previous frame).
@@ -488,6 +872,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether the entity bits identify a live entity.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -496,6 +881,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether a key transitioned to pressed in this frame.
      * @param {number} key_code
      * @returns {boolean}
      */
@@ -504,6 +890,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether a key transitioned to released in this frame.
      * @param {number} key_code
      * @returns {boolean}
      */
@@ -512,6 +899,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether a key is currently held down.
      * @param {number} key_code
      * @returns {boolean}
      */
@@ -520,6 +908,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether a mouse button transitioned to pressed in this frame.
      * @param {number} button
      * @returns {boolean}
      */
@@ -528,6 +917,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether a mouse button transitioned to released in this frame.
      * @param {number} button
      * @returns {boolean}
      */
@@ -536,6 +926,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether a mouse button is currently held down.
      * @param {number} button
      * @returns {boolean}
      */
@@ -557,6 +948,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns the current mouse X position.
      * @returns {number}
      */
     mouse_x() {
@@ -564,12 +956,116 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Returns the current mouse Y position.
      * @returns {number}
      */
     mouse_y() {
         const ret = wasm.wasmgame_mouse_y(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Convenience connect returning the connection handle only.
+     * @param {number} protocol
+     * @param {string} address
+     * @param {number} port
+     * @returns {number}
+     */
+    network_connect(protocol, address, port) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_network_connect(this.__wbg_ptr, protocol, ptr0, len0, port);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Connects to a remote WebSocket endpoint and returns a connection handle.
+     * @param {number} protocol
+     * @param {string} address
+     * @param {number} port
+     * @returns {WasmNetworkConnectResult}
+     */
+    network_connect_with_peer(protocol, address, port) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_network_connect_with_peer(this.__wbg_ptr, protocol, ptr0, len0, port);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmNetworkConnectResult.__wrap(ret[0]);
+    }
+    /**
+     * Disconnects and removes a network connection.
+     * @param {number} handle
+     * @returns {number}
+     */
+    network_disconnect(handle) {
+        const ret = wasm.wasmgame_network_disconnect(this.__wbg_ptr, handle);
+        return ret;
+    }
+    /**
+     * Browser-hosting is not supported for WASM networking.
+     * @param {number} _protocol
+     * @param {number} _port
+     * @returns {number}
+     */
+    network_host(_protocol, _port) {
+        const ret = wasm.wasmgame_network_host(this.__wbg_ptr, _protocol, _port);
+        return ret;
+    }
+    /**
+     * Returns active peer count for the connection.
+     * @param {number} handle
+     * @returns {number}
+     */
+    network_peer_count(handle) {
+        const ret = wasm.wasmgame_network_peer_count(this.__wbg_ptr, handle);
+        return ret;
+    }
+    /**
+     * Poll is a no-op for browser sockets (event-driven), but validates the handle.
+     * @param {number} handle
+     * @returns {number}
+     */
+    network_poll(handle) {
+        const ret = wasm.wasmgame_network_poll(this.__wbg_ptr, handle);
+        return ret;
+    }
+    /**
+     * Legacy receive path returning payload bytes only.
+     * @param {number} handle
+     * @returns {Uint8Array}
+     */
+    network_receive(handle) {
+        const ret = wasm.wasmgame_network_receive(this.__wbg_ptr, handle);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Receives the next queued packet with peer metadata.
+     * @param {number} handle
+     * @returns {WasmNetworkPacket | undefined}
+     */
+    network_receive_packet(handle) {
+        const ret = wasm.wasmgame_network_receive_packet(this.__wbg_ptr, handle);
+        return ret === 0 ? undefined : WasmNetworkPacket.__wrap(ret);
+    }
+    /**
+     * Sends a binary packet on an existing connection.
+     * @param {number} handle
+     * @param {bigint} _peer_id
+     * @param {Uint8Array} data
+     * @param {number} _channel
+     * @returns {number}
+     */
+    network_send(handle, _peer_id, data, _channel) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_network_send(this.__wbg_ptr, handle, _peer_id, ptr0, len0, _channel);
+        return ret;
+    }
     /**
      * Creates a new game instance without rendering (ECS-only mode).
      * @param {number} width
@@ -585,6 +1081,7 @@ export class WasmGame {
         return this;
     }
     /**
+     * Returns whether point `(px, py)` is inside the circle.
      * @param {number} px
      * @param {number} py
      * @param {number} cx
@@ -597,6 +1094,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns whether point `(px, py)` is inside the rectangle.
      * @param {number} px
      * @param {number} py
      * @param {number} rx
@@ -610,17 +1108,35 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Marks a key as pressed for the current frame.
      * @param {number} key_code
      */
     press_key(key_code) {
         wasm.wasmgame_press_key(this.__wbg_ptr, key_code);
     }
     /**
+     * Marks a mouse button as pressed for the current frame.
      * @param {number} button
      */
     press_mouse_button(button) {
         wasm.wasmgame_press_mouse_button(this.__wbg_ptr, button);
     }
+    /**
+     * Registers a font from raw bytes.
+     *
+     * Returns a 1-based handle suitable for `draw_text`.
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    register_font_from_bytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_register_font_from_bytes(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Registers a texture from raw image bytes (PNG, JPG, etc.).
      *
@@ -641,18 +1157,21 @@ export class WasmGame {
         return ret[0] >>> 0;
     }
     /**
+     * Marks a key as released for the current frame.
      * @param {number} key_code
      */
     release_key(key_code) {
         wasm.wasmgame_release_key(this.__wbg_ptr, key_code);
     }
     /**
+     * Marks a mouse button as released for the current frame.
      * @param {number} button
      */
     release_mouse_button(button) {
         wasm.wasmgame_release_mouse_button(this.__wbg_ptr, button);
     }
     /**
+     * Removes `Name` from the entity.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -661,6 +1180,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Removes `Sprite` from the entity.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -669,6 +1189,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Removes `Transform2D` from the entity.
      * @param {bigint} entity_bits
      * @returns {boolean}
      */
@@ -677,6 +1198,7 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
+     * Returns accumulated horizontal scroll delta.
      * @returns {number}
      */
     scroll_dx() {
@@ -684,6 +1206,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Returns accumulated vertical scroll delta.
      * @returns {number}
      */
     scroll_dy() {
@@ -711,6 +1234,7 @@ export class WasmGame {
         wasm.wasmgame_set_clear_color(this.__wbg_ptr, r, g, b, a);
     }
     /**
+     * Updates the current mouse position in logical coordinates.
      * @param {number} x
      * @param {number} y
      */
@@ -718,6 +1242,28 @@ export class WasmGame {
         wasm.wasmgame_set_mouse_position(this.__wbg_ptr, x, y);
     }
     /**
+     * Overlay handle selection is unsupported in browser networking mode.
+     * @param {number} _handle
+     * @returns {number}
+     */
+    set_network_overlay_handle(_handle) {
+        const ret = wasm.wasmgame_set_network_overlay_handle(this.__wbg_ptr, _handle);
+        return ret;
+    }
+    /**
+     * Network simulation controls are unsupported in browser networking mode.
+     * @param {number} _handle
+     * @param {number} _one_way_latency_ms
+     * @param {number} _jitter_ms
+     * @param {number} _packet_loss_percent
+     * @returns {number}
+     */
+    set_network_simulation(_handle, _one_way_latency_ms, _jitter_ms, _packet_loss_percent) {
+        const ret = wasm.wasmgame_set_network_simulation(this.__wbg_ptr, _handle, _one_way_latency_ms, _jitter_ms, _packet_loss_percent);
+        return ret;
+    }
+    /**
+     * Updates an existing `Sprite` if present.
      * @param {bigint} entity_bits
      * @param {number} texture_handle
      * @param {number} r
@@ -733,6 +1279,7 @@ export class WasmGame {
         wasm.wasmgame_set_sprite(this.__wbg_ptr, entity_bits, texture_handle, r, g, b, a, flip_x, flip_y, anchor_x, anchor_y);
     }
     /**
+     * Updates an existing `Transform2D` if present.
      * @param {bigint} entity_bits
      * @param {number} px
      * @param {number} py
@@ -744,6 +1291,7 @@ export class WasmGame {
         wasm.wasmgame_set_transform2d(this.__wbg_ptr, entity_bits, px, py, rotation, sx, sy);
     }
     /**
+     * Spawns `count` empty entities and returns their packed entity bits.
      * @param {number} count
      * @returns {BigUint64Array}
      */
@@ -754,6 +1302,7 @@ export class WasmGame {
         return v1;
     }
     /**
+     * Spawns a single empty entity and returns its packed entity bits.
      * @returns {bigint}
      */
     spawn_empty() {
@@ -793,15 +1342,323 @@ export class WasmGame {
         return ret >>> 0;
     }
     /**
-     * Logical canvas width in pixels.
-     * @returns {number}
+     * Logical canvas width in pixels.
+     * @returns {number}
+     */
+    get window_width() {
+        const ret = wasm.wasmgame_window_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WasmGame.prototype[Symbol.dispose] = WasmGame.prototype.free;
+
+export class WasmNetworkCapabilities {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmNetworkCapabilities.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmNetworkCapabilitiesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmNetworkCapabilitiesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmnetworkcapabilities_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get max_channels() {
+        const ret = wasm.__wbg_get_wasmnetworkcapabilities_max_channels(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get max_connections() {
+        const ret = wasm.__wbg_get_wasmnetworkcapabilities_max_connections(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get max_message_size() {
+        const ret = wasm.__wbg_get_wasmnetworkcapabilities_max_message_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get supports_hosting() {
+        const ret = wasm.__wbg_get_wasmnetworkcapabilities_supports_hosting(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set max_channels(arg0) {
+        wasm.__wbg_set_wasmnetworkcapabilities_max_channels(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set max_connections(arg0) {
+        wasm.__wbg_set_wasmnetworkcapabilities_max_connections(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set max_message_size(arg0) {
+        wasm.__wbg_set_wasmnetworkcapabilities_max_message_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set supports_hosting(arg0) {
+        wasm.__wbg_set_wasmnetworkcapabilities_supports_hosting(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) WasmNetworkCapabilities.prototype[Symbol.dispose] = WasmNetworkCapabilities.prototype.free;
+
+export class WasmNetworkConnectResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmNetworkConnectResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmNetworkConnectResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmNetworkConnectResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmnetworkconnectresult_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get handle() {
+        const ret = wasm.__wbg_get_wasmnetworkconnectresult_handle(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get peer_id() {
+        const ret = wasm.__wbg_get_wasmnetworkconnectresult_peer_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set handle(arg0) {
+        wasm.__wbg_set_wasmnetworkconnectresult_handle(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set peer_id(arg0) {
+        wasm.__wbg_set_wasmnetworkconnectresult_peer_id(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) WasmNetworkConnectResult.prototype[Symbol.dispose] = WasmNetworkConnectResult.prototype.free;
+
+export class WasmNetworkPacket {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmNetworkPacket.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmNetworkPacketFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmNetworkPacketFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmnetworkpacket_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get data() {
+        const ret = wasm.wasmnetworkpacket_data(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get peer_id() {
+        const ret = wasm.wasmnetworkpacket_peer_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+}
+if (Symbol.dispose) WasmNetworkPacket.prototype[Symbol.dispose] = WasmNetworkPacket.prototype.free;
+
+export class WasmNetworkStats {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmNetworkStats.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmNetworkStatsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmNetworkStatsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmnetworkstats_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get bytes_received() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_bytes_received(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get bytes_sent() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_bytes_sent(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get jitter_ms() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_jitter_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get packet_loss_percent() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_packet_loss_percent(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get packets_lost() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_packets_lost(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get packets_received() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_packets_received(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get packets_sent() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_packets_sent(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get receive_bandwidth_bytes_per_sec() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_receive_bandwidth_bytes_per_sec(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get rtt_ms() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_rtt_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get send_bandwidth_bytes_per_sec() {
+        const ret = wasm.__wbg_get_wasmnetworkstats_send_bandwidth_bytes_per_sec(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set bytes_received(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_bytes_received(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set bytes_sent(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_bytes_sent(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set jitter_ms(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_jitter_ms(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set packet_loss_percent(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_packet_loss_percent(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set packets_lost(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_packets_lost(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set packets_received(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_packets_received(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {bigint} arg0
+     */
+    set packets_sent(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_packets_sent(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set receive_bandwidth_bytes_per_sec(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_receive_bandwidth_bytes_per_sec(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set rtt_ms(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_rtt_ms(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
      */
-    get window_width() {
-        const ret = wasm.wasmgame_window_width(this.__wbg_ptr);
-        return ret >>> 0;
+    set send_bandwidth_bytes_per_sec(arg0) {
+        wasm.__wbg_set_wasmnetworkstats_send_bandwidth_bytes_per_sec(this.__wbg_ptr, arg0);
     }
 }
-if (Symbol.dispose) WasmGame.prototype[Symbol.dispose] = WasmGame.prototype.free;
+if (Symbol.dispose) WasmNetworkStats.prototype[Symbol.dispose] = WasmNetworkStats.prototype.free;
 
 /**
  * Per-frame rendering statistics exposed to JavaScript.
@@ -825,6 +1682,7 @@ export class WasmRenderStats {
         wasm.__wbg_wasmrenderstats_free(ptr, 0);
     }
     /**
+     * Number of draw calls submitted this frame.
      * @returns {number}
      */
     get draw_calls() {
@@ -832,6 +1690,7 @@ export class WasmRenderStats {
         return ret >>> 0;
     }
     /**
+     * Number of texture bind switches this frame.
      * @returns {number}
      */
     get texture_binds() {
@@ -839,6 +1698,7 @@ export class WasmRenderStats {
         return ret >>> 0;
     }
     /**
+     * Number of triangles submitted this frame.
      * @returns {number}
      */
     get triangles() {
@@ -846,18 +1706,21 @@ export class WasmRenderStats {
         return ret >>> 0;
     }
     /**
+     * Number of draw calls submitted this frame.
      * @param {number} arg0
      */
     set draw_calls(arg0) {
         wasm.__wbg_set_wasmrenderstats_draw_calls(this.__wbg_ptr, arg0);
     }
     /**
+     * Number of texture bind switches this frame.
      * @param {number} arg0
      */
     set texture_binds(arg0) {
         wasm.__wbg_set_wasmrenderstats_texture_binds(this.__wbg_ptr, arg0);
     }
     /**
+     * Number of triangles submitted this frame.
      * @param {number} arg0
      */
     set triangles(arg0) {
@@ -889,6 +1752,7 @@ export class WasmSprite {
         wasm.__wbg_wasmsprite_free(ptr, 0);
     }
     /**
+     * Alpha channel tint.
      * @returns {number}
      */
     get a() {
@@ -896,6 +1760,7 @@ export class WasmSprite {
         return ret;
     }
     /**
+     * X anchor in normalized sprite space.
      * @returns {number}
      */
     get anchor_x() {
@@ -903,6 +1768,7 @@ export class WasmSprite {
         return ret;
     }
     /**
+     * Y anchor in normalized sprite space.
      * @returns {number}
      */
     get anchor_y() {
@@ -910,6 +1776,7 @@ export class WasmSprite {
         return ret;
     }
     /**
+     * Blue channel tint.
      * @returns {number}
      */
     get b() {
@@ -917,6 +1784,7 @@ export class WasmSprite {
         return ret;
     }
     /**
+     * Horizontal texture flip flag.
      * @returns {boolean}
      */
     get flip_x() {
@@ -924,6 +1792,7 @@ export class WasmSprite {
         return ret !== 0;
     }
     /**
+     * Vertical texture flip flag.
      * @returns {boolean}
      */
     get flip_y() {
@@ -931,6 +1800,7 @@ export class WasmSprite {
         return ret !== 0;
     }
     /**
+     * Green channel tint.
      * @returns {number}
      */
     get g() {
@@ -938,6 +1808,7 @@ export class WasmSprite {
         return ret;
     }
     /**
+     * Red channel tint.
      * @returns {number}
      */
     get r() {
@@ -945,6 +1816,7 @@ export class WasmSprite {
         return ret;
     }
     /**
+     * Texture handle backing this sprite.
      * @returns {number}
      */
     get texture_handle() {
@@ -952,54 +1824,63 @@ export class WasmSprite {
         return ret >>> 0;
     }
     /**
+     * Alpha channel tint.
      * @param {number} arg0
      */
     set a(arg0) {
         wasm.__wbg_set_wasmsprite_a(this.__wbg_ptr, arg0);
     }
     /**
+     * X anchor in normalized sprite space.
      * @param {number} arg0
      */
     set anchor_x(arg0) {
         wasm.__wbg_set_wasmsprite_anchor_x(this.__wbg_ptr, arg0);
     }
     /**
+     * Y anchor in normalized sprite space.
      * @param {number} arg0
      */
     set anchor_y(arg0) {
         wasm.__wbg_set_wasmsprite_anchor_y(this.__wbg_ptr, arg0);
     }
     /**
+     * Blue channel tint.
      * @param {number} arg0
      */
     set b(arg0) {
         wasm.__wbg_set_wasmsprite_b(this.__wbg_ptr, arg0);
     }
     /**
+     * Horizontal texture flip flag.
      * @param {boolean} arg0
      */
     set flip_x(arg0) {
         wasm.__wbg_set_wasmsprite_flip_x(this.__wbg_ptr, arg0);
     }
     /**
+     * Vertical texture flip flag.
      * @param {boolean} arg0
      */
     set flip_y(arg0) {
         wasm.__wbg_set_wasmsprite_flip_y(this.__wbg_ptr, arg0);
     }
     /**
+     * Green channel tint.
      * @param {number} arg0
      */
     set g(arg0) {
         wasm.__wbg_set_wasmsprite_g(this.__wbg_ptr, arg0);
     }
     /**
+     * Red channel tint.
      * @param {number} arg0
      */
     set r(arg0) {
         wasm.__wbg_set_wasmsprite_r(this.__wbg_ptr, arg0);
     }
     /**
+     * Texture handle backing this sprite.
      * @param {number} arg0
      */
     set texture_handle(arg0) {
@@ -1031,6 +1912,7 @@ export class WasmTransform2D {
         wasm.__wbg_wasmtransform2d_free(ptr, 0);
     }
     /**
+     * X position.
      * @returns {number}
      */
     get position_x() {
@@ -1038,6 +1920,7 @@ export class WasmTransform2D {
         return ret;
     }
     /**
+     * Y position.
      * @returns {number}
      */
     get position_y() {
@@ -1045,6 +1928,7 @@ export class WasmTransform2D {
         return ret;
     }
     /**
+     * Rotation in radians.
      * @returns {number}
      */
     get rotation() {
@@ -1052,6 +1936,7 @@ export class WasmTransform2D {
         return ret;
     }
     /**
+     * X scale.
      * @returns {number}
      */
     get scale_x() {
@@ -1059,6 +1944,7 @@ export class WasmTransform2D {
         return ret;
     }
     /**
+     * Y scale.
      * @returns {number}
      */
     get scale_y() {
@@ -1066,30 +1952,35 @@ export class WasmTransform2D {
         return ret;
     }
     /**
+     * X position.
      * @param {number} arg0
      */
     set position_x(arg0) {
         wasm.__wbg_set_wasmtransform2d_position_x(this.__wbg_ptr, arg0);
     }
     /**
+     * Y position.
      * @param {number} arg0
      */
     set position_y(arg0) {
         wasm.__wbg_set_wasmtransform2d_position_y(this.__wbg_ptr, arg0);
     }
     /**
+     * Rotation in radians.
      * @param {number} arg0
      */
     set rotation(arg0) {
         wasm.__wbg_set_wasmtransform2d_rotation(this.__wbg_ptr, arg0);
     }
     /**
+     * X scale.
      * @param {number} arg0
      */
     set scale_x(arg0) {
         wasm.__wbg_set_wasmtransform2d_scale_x(this.__wbg_ptr, arg0);
     }
     /**
+     * Y scale.
      * @param {number} arg0
      */
     set scale_y(arg0) {
@@ -1098,6 +1989,299 @@ export class WasmTransform2D {
 }
 if (Symbol.dispose) WasmTransform2D.prototype[Symbol.dispose] = WasmTransform2D.prototype.free;
 
+/**
+ * Serializable UI event record exposed to JavaScript.
+ */
+export class WasmUiEvent {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmUiEvent.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmUiEventFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmUiEventFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmuievent_free(ptr, 0);
+    }
+    /**
+     * Packed current focus/hover node or `u64::MAX`.
+     * @returns {bigint}
+     */
+    get current_node_id() {
+        const ret = wasm.__wbg_get_wasmuievent_current_node_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Numeric UI event kind.
+     * @returns {number}
+     */
+    get event_kind() {
+        const ret = wasm.__wbg_get_wasmuievent_event_kind(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Packed `UiNodeId` for the source node.
+     * @returns {bigint}
+     */
+    get node_id() {
+        const ret = wasm.__wbg_get_wasmuievent_node_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Packed previous focus/hover node or `u64::MAX`.
+     * @returns {bigint}
+     */
+    get previous_node_id() {
+        const ret = wasm.__wbg_get_wasmuievent_previous_node_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Packed current focus/hover node or `u64::MAX`.
+     * @param {bigint} arg0
+     */
+    set current_node_id(arg0) {
+        wasm.__wbg_set_wasmuievent_current_node_id(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Numeric UI event kind.
+     * @param {number} arg0
+     */
+    set event_kind(arg0) {
+        wasm.__wbg_set_wasmuievent_event_kind(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Packed `UiNodeId` for the source node.
+     * @param {bigint} arg0
+     */
+    set node_id(arg0) {
+        wasm.__wbg_set_wasmuievent_node_id(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Packed previous focus/hover node or `u64::MAX`.
+     * @param {bigint} arg0
+     */
+    set previous_node_id(arg0) {
+        wasm.__wbg_set_wasmuievent_previous_node_id(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) WasmUiEvent.prototype[Symbol.dispose] = WasmUiEvent.prototype.free;
+
+/**
+ * Standalone UI manager exported for browser/WASM SDK consumers.
+ *
+ * This mirrors the native `UiManager` lifecycle and widget/style/event APIs
+ * while preserving Rust-side ownership of layout and event processing.
+ */
+export class WasmUiManager {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmUiManagerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmuimanager_free(ptr, 0);
+    }
+    /**
+     * Creates a UI node with the given component type code.
+     * @param {number} component_type
+     * @returns {bigint}
+     */
+    create_node(component_type) {
+        const ret = wasm.wasmuimanager_create_node(this.__wbg_ptr, component_type);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Returns the count of events captured during the latest `update`.
+     * @returns {number}
+     */
+    event_count() {
+        const ret = wasm.wasmuimanager_event_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Reads one captured event by index.
+     * @param {number} index
+     * @returns {WasmUiEvent | undefined}
+     */
+    event_read(index) {
+        const ret = wasm.wasmuimanager_event_read(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : WasmUiEvent.__wrap(ret);
+    }
+    /**
+     * Returns the child at an index, or `u64::MAX` if out of bounds.
+     * @param {bigint} node_id
+     * @param {number} index
+     * @returns {bigint}
+     */
+    get_child_at(node_id, index) {
+        const ret = wasm.wasmuimanager_get_child_at(this.__wbg_ptr, node_id, index);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Returns the number of children for the given node.
+     * @param {bigint} node_id
+     * @returns {number}
+     */
+    get_child_count(node_id) {
+        const ret = wasm.wasmuimanager_get_child_count(this.__wbg_ptr, node_id);
+        return ret >>> 0;
+    }
+    /**
+     * Returns a node's parent, or `u64::MAX` if missing/root.
+     * @param {bigint} node_id
+     * @returns {bigint}
+     */
+    get_parent(node_id) {
+        const ret = wasm.wasmuimanager_get_parent(this.__wbg_ptr, node_id);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Creates a standalone UI manager for web/WASM consumers.
+     */
+    constructor() {
+        const ret = wasm.wasmuimanager_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmUiManagerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the number of live UI nodes.
+     * @returns {number}
+     */
+    node_count() {
+        const ret = wasm.wasmuimanager_node_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Removes a UI node and its subtree.
+     * @param {bigint} node_id
+     * @returns {number}
+     */
+    remove_node(node_id) {
+        const ret = wasm.wasmuimanager_remove_node(this.__wbg_ptr, node_id);
+        return ret;
+    }
+    /**
+     * Builds render commands for the current UI tree.
+     */
+    render() {
+        wasm.wasmuimanager_render(this.__wbg_ptr);
+    }
+    /**
+     * Sets/creates a button widget and updates its enabled flag.
+     * @param {bigint} node_id
+     * @param {boolean} enabled
+     * @returns {number}
+     */
+    set_button_enabled(node_id, enabled) {
+        const ret = wasm.wasmuimanager_set_button_enabled(this.__wbg_ptr, node_id, enabled);
+        return ret;
+    }
+    /**
+     * Sets/creates an image widget and updates its texture path.
+     * @param {bigint} node_id
+     * @param {string} path
+     * @returns {number}
+     */
+    set_image_texture_path(node_id, path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuimanager_set_image_texture_path(this.__wbg_ptr, node_id, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Sets/creates a label widget and updates its text.
+     * @param {bigint} node_id
+     * @param {string} text
+     * @returns {number}
+     */
+    set_label_text(node_id, text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuimanager_set_label_text(this.__wbg_ptr, node_id, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Sets or clears a node's parent (`u64::MAX` detaches to root).
+     * @param {bigint} child_id
+     * @param {bigint} parent_id
+     * @returns {number}
+     */
+    set_parent(child_id, parent_id) {
+        const ret = wasm.wasmuimanager_set_parent(this.__wbg_ptr, child_id, parent_id);
+        return ret;
+    }
+    /**
+     * Sets/creates a slider widget and updates range/value/enabled state.
+     * @param {bigint} node_id
+     * @param {number} min
+     * @param {number} max
+     * @param {number} value
+     * @param {boolean} enabled
+     * @returns {number}
+     */
+    set_slider(node_id, min, max, value, enabled) {
+        const ret = wasm.wasmuimanager_set_slider(this.__wbg_ptr, node_id, min, max, value, enabled);
+        return ret;
+    }
+    /**
+     * Applies per-node visual style overrides.
+     * @param {bigint} node_id
+     * @param {number | null} [background_r]
+     * @param {number | null} [background_g]
+     * @param {number | null} [background_b]
+     * @param {number | null} [background_a]
+     * @param {number | null} [foreground_r]
+     * @param {number | null} [foreground_g]
+     * @param {number | null} [foreground_b]
+     * @param {number | null} [foreground_a]
+     * @param {number | null} [border_r]
+     * @param {number | null} [border_g]
+     * @param {number | null} [border_b]
+     * @param {number | null} [border_a]
+     * @param {number | null} [border_width]
+     * @param {string | null} [font_family]
+     * @param {number | null} [font_size]
+     * @param {string | null} [texture_path]
+     * @param {number | null} [widget_spacing]
+     * @returns {number}
+     */
+    set_style(node_id, background_r, background_g, background_b, background_a, foreground_r, foreground_g, foreground_b, foreground_a, border_r, border_g, border_b, border_a, border_width, font_family, font_size, texture_path, widget_spacing) {
+        var ptr0 = isLikeNone(font_family) ? 0 : passStringToWasm0(font_family, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(texture_path) ? 0 : passStringToWasm0(texture_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmuimanager_set_style(this.__wbg_ptr, node_id, isLikeNone(background_r) ? 0x100000001 : Math.fround(background_r), isLikeNone(background_g) ? 0x100000001 : Math.fround(background_g), isLikeNone(background_b) ? 0x100000001 : Math.fround(background_b), isLikeNone(background_a) ? 0x100000001 : Math.fround(background_a), isLikeNone(foreground_r) ? 0x100000001 : Math.fround(foreground_r), isLikeNone(foreground_g) ? 0x100000001 : Math.fround(foreground_g), isLikeNone(foreground_b) ? 0x100000001 : Math.fround(foreground_b), isLikeNone(foreground_a) ? 0x100000001 : Math.fround(foreground_a), isLikeNone(border_r) ? 0x100000001 : Math.fround(border_r), isLikeNone(border_g) ? 0x100000001 : Math.fround(border_g), isLikeNone(border_b) ? 0x100000001 : Math.fround(border_b), isLikeNone(border_a) ? 0x100000001 : Math.fround(border_a), isLikeNone(border_width) ? 0x100000001 : Math.fround(border_width), ptr0, len0, isLikeNone(font_size) ? 0x100000001 : Math.fround(font_size), ptr1, len1, isLikeNone(widget_spacing) ? 0x100000001 : Math.fround(widget_spacing));
+        return ret;
+    }
+    /**
+     * Sets or clears the node widget component by widget-kind code.
+     * @param {bigint} node_id
+     * @param {number} widget_kind
+     * @returns {number}
+     */
+    set_widget(node_id, widget_kind) {
+        const ret = wasm.wasmuimanager_set_widget(this.__wbg_ptr, node_id, widget_kind);
+        return ret;
+    }
+    /**
+     * Runs a layout/input update tick and snapshots the emitted UI events.
+     */
+    update() {
+        wasm.wasmuimanager_update(this.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) WasmUiManager.prototype[Symbol.dispose] = WasmUiManager.prototype.free;
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -1146,9 +2330,16 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_close_af26905c832a88cb: function() { return handleError(function (arg0) {
+            arg0.close();
+        }, arguments); },
         __wbg_configure_3800e43cc1d4df6c: function() { return handleError(function (arg0, arg1) {
             arg0.configure(arg1);
         }, arguments); },
+        __wbg_connect_3ca85e8e3b8d9828: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.connect(arg1);
+            return ret;
+        }, arguments); },
         __wbg_createBindGroupLayout_38abd4e4c5dded7c: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.createBindGroupLayout(arg1);
             return ret;
@@ -1165,6 +2356,21 @@ function __wbg_get_imports() {
             const ret = arg0.createCommandEncoder(arg1);
             return ret;
         },
+        __wbg_createGain_94d1140dbe2da90d: function() { return handleError(function (arg0) {
+            const ret = arg0.createGain();
+            return ret;
+        }, arguments); },
+        __wbg_createMediaElementSource_bfc16374db84a671: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createMediaElementSource(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_createObjectURL_f141426bcc1f70aa: function() { return handleError(function (arg0, arg1) {
+            const ret = URL.createObjectURL(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
         __wbg_createPipelineLayout_10a02d78a5e801aa: function(arg0, arg1) {
             const ret = arg0.createPipelineLayout(arg1);
             return ret;
@@ -1181,6 +2387,10 @@ function __wbg_get_imports() {
             const ret = arg0.createShaderModule(arg1);
             return ret;
         },
+        __wbg_createStereoPanner_e8bc9c6bea047898: function() { return handleError(function (arg0) {
+            const ret = arg0.createStereoPanner();
+            return ret;
+        }, arguments); },
         __wbg_createTexture_7de0f1ac17578a0c: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.createTexture(arg1);
             return ret;
@@ -1189,6 +2399,14 @@ function __wbg_get_imports() {
             const ret = arg0.createView(arg1);
             return ret;
         }, arguments); },
+        __wbg_data_a3d9ff9cdd801002: function(arg0) {
+            const ret = arg0.data;
+            return ret;
+        },
+        __wbg_destination_d1f70fe081ff0932: function(arg0) {
+            const ret = arg0.destination;
+            return ret;
+        },
         __wbg_document_c0320cd4183c6d9b: function(arg0) {
             const ret = arg0.document;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1210,6 +2428,10 @@ function __wbg_get_imports() {
             const ret = arg0.finish();
             return ret;
         },
+        __wbg_gain_c5b40ffb38909ac5: function(arg0) {
+            const ret = arg0.gain;
+            return ret;
+        },
         __wbg_getContext_a9236f98f1f7fe7c: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1238,6 +2460,16 @@ function __wbg_get_imports() {
             const ret = arg0.gpu;
             return ret;
         },
+        __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_GpuAdapter_b2c1300e425af95c: function(arg0) {
             let result;
             try {
@@ -1258,6 +2490,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Window_23e677d2c6843922: function(arg0) {
             let result;
             try {
@@ -1291,10 +2533,26 @@ function __wbg_get_imports() {
             const ret = arg0.navigator;
             return ret;
         },
+        __wbg_new_5e532409c6c7bba4: function() { return handleError(function () {
+            const ret = new lAudioContext();
+            return ret;
+        }, arguments); },
+        __wbg_new_5f486cdf45a04d78: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_a70fbab9066b301f: function() {
+            const ret = new Array();
+            return ret;
+        },
         __wbg_new_ab79df5bd7c26067: function() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_dd50bcc3f60ba434: function() { return handleError(function (arg0, arg1) {
+            const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
         __wbg_new_from_slice_22da9388ac046e50: function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
@@ -1306,7 +2564,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h40c8324309a93f8a(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h0f058dd9c7531832(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1325,10 +2583,33 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
+        __wbg_new_with_src_a50a81c022cd450e: function() { return handleError(function (arg0, arg1) {
+            const ret = new Audio(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
+        __wbg_new_with_u8_array_sequence_1366bd1ced0ec6b9: function() { return handleError(function (arg0) {
+            const ret = new Blob(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_numberOfInputs_657d26b943855bfc: function(arg0) {
+            const ret = arg0.numberOfInputs;
+            return ret;
+        },
         __wbg_onSubmittedWorkDone_a33e32762de21b3d: function(arg0) {
             const ret = arg0.onSubmittedWorkDone();
             return ret;
         },
+        __wbg_pan_4182a9bbd48792d9: function(arg0) {
+            const ret = arg0.pan;
+            return ret;
+        },
+        __wbg_pause_fe6c9b27e2a39a14: function() { return handleError(function (arg0) {
+            arg0.pause();
+        }, arguments); },
+        __wbg_play_61507f47e1a45940: function() { return handleError(function (arg0) {
+            const ret = arg0.play();
+            return ret;
+        }, arguments); },
         __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
@@ -1351,6 +2632,10 @@ function __wbg_get_imports() {
             const ret = arg0.queue;
             return ret;
         },
+        __wbg_readyState_1f1e7f1bdf9f4d42: function(arg0) {
+            const ret = arg0.readyState;
+            return ret;
+        },
         __wbg_requestAdapter_3cddf363b0bc9baf: function(arg0, arg1) {
             const ret = arg0.requestAdapter(arg1);
             return ret;
@@ -1363,6 +2648,16 @@ function __wbg_get_imports() {
             const ret = Promise.resolve(arg0);
             return ret;
         },
+        __wbg_resume_7cf56c82bfdf6c58: function() { return handleError(function (arg0) {
+            const ret = arg0.resume();
+            return ret;
+        }, arguments); },
+        __wbg_revokeObjectURL_c4a7ed8e1908b794: function() { return handleError(function (arg0, arg1) {
+            URL.revokeObjectURL(getStringFromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_send_d31a693c975dea74: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.send(getArrayU8FromWasm0(arg1, arg2));
+        }, arguments); },
         __wbg_setBindGroup_24fcfe125e006dd4: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
         }, arguments); },
@@ -1433,6 +2728,9 @@ function __wbg_get_imports() {
         __wbg_set_beginning_of_pass_write_index_ff16e69caf566bee: function(arg0, arg1) {
             arg0.beginningOfPassWriteIndex = arg1 >>> 0;
         },
+        __wbg_set_binaryType_3dcf8281ec100a8f: function(arg0, arg1) {
+            arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+        },
         __wbg_set_bind_group_layouts_ddc70fed7170a2ee: function(arg0, arg1) {
             arg0.bindGroupLayouts = arg1;
         },
@@ -1481,6 +2779,9 @@ function __wbg_get_imports() {
         __wbg_set_cull_mode_8c42221bd938897d: function(arg0, arg1) {
             arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
         },
+        __wbg_set_currentTime_0bd5c83ef1810a8f: function(arg0, arg1) {
+            arg0.currentTime = arg1;
+        },
         __wbg_set_depth_bias_8de79219aa9d3e44: function(arg0, arg1) {
             arg0.depthBias = arg1;
         },
@@ -1652,6 +2953,9 @@ function __wbg_get_imports() {
         __wbg_set_lod_min_clamp_35ccf45d8ee31c7e: function(arg0, arg1) {
             arg0.lodMinClamp = arg1;
         },
+        __wbg_set_loop_3edfdf296459469a: function(arg0, arg1) {
+            arg0.loop = arg1 !== 0;
+        },
         __wbg_set_mag_filter_8f8d84435d8db92a: function(arg0, arg1) {
             arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
         },
@@ -1703,6 +3007,18 @@ function __wbg_get_imports() {
         __wbg_set_offset_fa633343238c309f: function(arg0, arg1) {
             arg0.offset = arg1;
         },
+        __wbg_set_onclose_8da801226bdd7a7b: function(arg0, arg1) {
+            arg0.onclose = arg1;
+        },
+        __wbg_set_onerror_901ca711f94a5bbb: function(arg0, arg1) {
+            arg0.onerror = arg1;
+        },
+        __wbg_set_onmessage_6f80ab771bf151aa: function(arg0, arg1) {
+            arg0.onmessage = arg1;
+        },
+        __wbg_set_onopen_34e3e24cf9337ddd: function(arg0, arg1) {
+            arg0.onopen = arg1;
+        },
         __wbg_set_operation_3a748fcc4d122201: function(arg0, arg1) {
             arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
         },
@@ -1712,9 +3028,15 @@ function __wbg_get_imports() {
         __wbg_set_pass_op_e82189d4f2d5c48d: function(arg0, arg1) {
             arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
         },
+        __wbg_set_playbackRate_4b4212c0d2c84b0e: function(arg0, arg1) {
+            arg0.playbackRate = arg1;
+        },
         __wbg_set_power_preference_f8956c3fea27c41d: function(arg0, arg1) {
             arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
         },
+        __wbg_set_preload_3c04b4c7f95193ba: function(arg0, arg1, arg2) {
+            arg0.preload = getStringFromWasm0(arg1, arg2);
+        },
         __wbg_set_primitive_65a118359b90be29: function(arg0, arg1) {
             arg0.primitive = arg1;
         },
@@ -1832,6 +3154,9 @@ function __wbg_get_imports() {
         __wbg_set_usage_ece80ba45b896722: function(arg0, arg1) {
             arg0.usage = arg1 >>> 0;
         },
+        __wbg_set_value_4379db49464da2c7: function(arg0, arg1) {
+            arg0.value = arg1;
+        },
         __wbg_set_vertex_879729b1ef5390a2: function(arg0, arg1) {
             arg0.vertex = arg1;
         },
@@ -1877,6 +3202,10 @@ function __wbg_get_imports() {
         __wbg_set_z_bb89b8ff0b9f8f74: function(arg0, arg1) {
             arg0.z = arg1 >>> 0;
         },
+        __wbg_state_a4d9e52dfc1783cb: function(arg0) {
+            const ret = arg0.state;
+            return (__wbindgen_enum_AudioContextState.indexOf(ret) + 1 || 4) - 1;
+        },
         __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1922,26 +3251,41 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, arg2, arg3, arg4);
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 61, function: Function { arguments: [Externref], shim_idx: 62, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h34b32f47e9536ad7, wasm_bindgen__convert__closures_____invoke__h8b43903f8a91b24f);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 1000, function: Function { arguments: [Externref], shim_idx: 1001, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h789bc42e2f1b9970, wasm_bindgen__convert__closures_____invoke__he47406ccb328564e);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 766, function: Function { arguments: [Externref], shim_idx: 767, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hb7ee5c5d3fd608d4, wasm_bindgen__convert__closures_____invoke__h6c9ef6970fdda1f4);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 121, function: Function { arguments: [Externref], shim_idx: 122, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h8ef9cafea49c0c6c, wasm_bindgen__convert__closures_____invoke__h7379c539a866d2ef);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 46, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 47, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h173e94978d19fd44, wasm_bindgen__convert__closures_____invoke__h1155117ea4dcfb6a);
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 46, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 47, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h173e94978d19fd44, wasm_bindgen__convert__closures_____invoke__h1155117ea4dcfb6a_3);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 93, function: Function { arguments: [NamedExternref("Event")], shim_idx: 94, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h19c7764ad1550135, wasm_bindgen__convert__closures_____invoke__h20ce9aa610e9cd25);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000006: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -1962,22 +3306,41 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h8b43903f8a91b24f(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h8b43903f8a91b24f(arg0, arg1, arg2);
+const lAudioContext = (typeof AudioContext !== 'undefined' ? AudioContext : (typeof webkitAudioContext !== 'undefined' ? webkitAudioContext : undefined));
+function wasm_bindgen__convert__closures_____invoke__h7379c539a866d2ef(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h7379c539a866d2ef(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h6c9ef6970fdda1f4(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h6c9ef6970fdda1f4(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h1155117ea4dcfb6a(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h1155117ea4dcfb6a(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h1155117ea4dcfb6a_3(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h1155117ea4dcfb6a_3(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h20ce9aa610e9cd25(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h20ce9aa610e9cd25(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__he47406ccb328564e(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__he47406ccb328564e(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h40c8324309a93f8a(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h40c8324309a93f8a(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h0f058dd9c7531832(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h0f058dd9c7531832(arg0, arg1, arg2, arg3);
 }
 
 
+const __wbindgen_enum_AudioContextState = ["suspended", "running", "closed"];
+
+
+const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+
+
 const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
 
 
@@ -2057,6 +3420,18 @@ const WasmContactFinalization = (typeof FinalizationRegistry === 'undefined')
 const WasmGameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgame_free(ptr >>> 0, 1));
+const WasmNetworkCapabilitiesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnetworkcapabilities_free(ptr >>> 0, 1));
+const WasmNetworkConnectResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnetworkconnectresult_free(ptr >>> 0, 1));
+const WasmNetworkPacketFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnetworkpacket_free(ptr >>> 0, 1));
+const WasmNetworkStatsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmnetworkstats_free(ptr >>> 0, 1));
 const WasmRenderStatsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmrenderstats_free(ptr >>> 0, 1));
@@ -2066,6 +3441,12 @@ const WasmSpriteFinalization = (typeof FinalizationRegistry === 'undefined')
 const WasmTransform2DFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtransform2d_free(ptr >>> 0, 1));
+const WasmUiEventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmuievent_free(ptr >>> 0, 1));
+const WasmUiManagerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmuimanager_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();