@dcl-regenesislabs/bevy-explorer-web 0.1.0-18292430673.commit-e417a13 → 0.1.0-18309830955.commit-236d8ba

package/.env

@@ -1 +1 @@
-PUBLIC_URL="https://cdn.decentraland.org/@dcl-regenesislabs/bevy-explorer-web/0.1.0-18292430673.commit-e417a13"
+PUBLIC_URL="https://cdn.decentraland.org/@dcl-regenesislabs/bevy-explorer-web/0.1.0-18309830955.commit-236d8ba"

package/index.html

@@ -129,6 +129,6 @@
     </div>
     <script src="https://cdn.jsdelivr.net/npm/livekit-client/dist/livekit-client.umd.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/hls.js@1"></script>
-    <script type="module" src="https://cdn.decentraland.org/@dcl-regenesislabs/bevy-explorer-web/0.1.0-18292430673.commit-e417a13/main.js"></script>
+    <script type="module" src="https://cdn.decentraland.org/@dcl-regenesislabs/bevy-explorer-web/0.1.0-18309830955.commit-236d8ba/main.js"></script>
 </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl-regenesislabs/bevy-explorer-web",
-  "version": "0.1.0-18292430673.commit-e417a13",
+  "version": "0.1.0-18309830955.commit-236d8ba",
   "scripts": {
     "postinstall": "node ./scripts/prebuild.js"
   },
@@ -8,6 +8,6 @@
     "type": "git",
     "url": "git+https://github.com/decentraland/bevy-explorer.git"
   },
-  "homepage": "https://cdn.decentraland.org/@dcl-regenesislabs/bevy-explorer-web/0.1.0-18292430673.commit-e417a13",
-  "commit": "e417a13a3f400f2500a7ad42506101b00696fe20"
+  "homepage": "https://cdn.decentraland.org/@dcl-regenesislabs/bevy-explorer-web/0.1.0-18309830955.commit-236d8ba",
+  "commit": "236d8ba1971d3d6f756b681da590504e32d56124"
 }

package/pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "decentra-bevy",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "webgpu_build_bg.wasm",
+    "webgpu_build.js",
+    "webgpu_build.d.ts"
+  ],
+  "main": "webgpu_build.js",
+  "types": "webgpu_build.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/pkg/snippets/comms-53217a45365bb5fa/livekit_web_bindings.js

@@ -0,0 +1,270 @@
+let currentMicTrack = null;
+const activeRooms = new Set();
+
+// Store audio elements and panner nodes for spatial audio
+const participantAudioNodes = new Map();
+
+export async function connect_room(url, token) {
+    const room = new LivekitClient.Room({
+        autoSubscribe: true,
+        adaptiveStream: false,
+        dynacast: false,
+    });
+    
+    await room.connect(url, token);
+    
+    // Add to active rooms set
+    activeRooms.add(room);
+    
+    // Don't automatically set up microphone - let it be controlled by the mic state
+    
+    return room;
+}
+
+export function set_microphone_enabled(enabled) {
+    if (activeRooms.size === 0) {
+        console.warn('No rooms available for microphone control');
+        return;
+    }
+    
+    if (enabled) {
+        // Enable microphone
+        if (!currentMicTrack) {
+            LivekitClient.createLocalAudioTrack({
+                echoCancellation: true,
+                noiseSuppression: true,
+                autoGainControl: true,
+            }).then(audioTrack => {
+                currentMicTrack = audioTrack;
+                
+                // Publish to all active rooms
+                const publishPromises = Array.from(activeRooms).map(room => 
+                    room.localParticipant.publishTrack(audioTrack, {
+                        source: LivekitClient.Track.Source.Microphone,
+                    }).catch(error => {
+                        console.error(`Failed to publish to room: ${error}`);
+                    })
+                );
+                
+                return Promise.all(publishPromises);
+            }).then(() => {
+                console.log('Microphone enabled successfully for all rooms');
+            }).catch(error => {
+                console.error('Failed to enable microphone:', error);
+                currentMicTrack = null;
+            });
+        }
+    } else {
+        // Disable microphone
+        if (currentMicTrack) {
+            // Unpublish from all active rooms
+            const unpublishPromises = Array.from(activeRooms).map(room => 
+                room.localParticipant.unpublishTrack(currentMicTrack).catch(error => {
+                    console.error(`Failed to unpublish from room: ${error}`);
+                })
+            );
+            
+            Promise.all(unpublishPromises).then(() => {
+                currentMicTrack.stop();
+                currentMicTrack = null;
+                console.log('Microphone disabled successfully for all rooms');
+            }).catch(error => {
+                console.error('Failed to disable microphone:', error);
+            });
+        }
+    }
+}
+
+export function is_microphone_available() {
+    // Check if getUserMedia is available
+    const res = !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia)
+    return res;
+}
+
+export async function publish_data(room, data, reliable, destinations) {
+    const options = {
+        reliable: reliable,
+        destination: destinations.length > 0 ? destinations : undefined,
+    };
+    
+    await room.localParticipant.publishData(data, options);
+}
+
+export async function publish_audio_track(room, track) {
+    const publication = await room.localParticipant.publishTrack(track, {
+        source: LivekitClient.Track.Source.Microphone,
+    });
+    return publication.trackSid;
+}
+
+export async function unpublish_track(room, sid) {
+    const publication = room.localParticipant.trackPublications.get(sid);
+    if (publication) {
+        await room.localParticipant.unpublishTrack(publication.track);
+    }
+}
+
+export async function close_room(room) {
+    // Remove from active rooms set
+    activeRooms.delete(room);
+    
+    // If this was the last room and mic is active, clean up
+    if (activeRooms.size === 0 && currentMicTrack) {
+        currentMicTrack.stop();
+        currentMicTrack = null;
+    }
+    
+    await room.disconnect();
+}
+
+export function set_room_event_handler(room, handler) {
+    room.on(LivekitClient.RoomEvent.DataReceived, (payload, participant) => {
+        handler({
+            type: 'dataReceived',
+            payload,
+            participant: {
+                identity: participant.identity,
+                metadata: participant.metadata || ''
+            }
+        });
+    });
+    
+    room.on(LivekitClient.RoomEvent.TrackSubscribed, (track, publication, participant) => {
+        // For audio tracks, set up spatial audio
+        if (track.kind === 'audio') {
+            const audioElement = track.attach();
+            
+            // Create Web Audio API nodes for spatial audio
+            const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+            const source = audioContext.createMediaElementSource(audioElement);
+            const pannerNode = audioContext.createStereoPanner();
+            const gainNode = audioContext.createGain();
+            
+            // Connect the audio graph: source -> panner -> gain -> destination
+            source.connect(pannerNode);
+            pannerNode.connect(gainNode);
+            gainNode.connect(audioContext.destination);
+            
+            // Store the nodes for later control
+            participantAudioNodes.set(participant.identity, {
+                audioElement,
+                audioContext,
+                source,
+                pannerNode,
+                gainNode,
+                track
+            });
+            
+            // Start playing
+            audioElement.play().catch(e => console.warn('Failed to play audio:', e));
+        }
+        
+        handler({
+            type: 'trackSubscribed',
+            participant: {
+                identity: participant.identity,
+                metadata: participant.metadata || ''
+            }
+        });
+    });
+    
+    room.on(LivekitClient.RoomEvent.TrackUnsubscribed, (track, publication, participant) => {
+        // Clean up spatial audio nodes
+        if (track.kind === 'audio') {
+            const nodes = participantAudioNodes.get(participant.identity);
+            if (nodes) {
+                nodes.source.disconnect();
+                nodes.pannerNode.disconnect();
+                nodes.gainNode.disconnect();
+                nodes.audioContext.close();
+                track.detach(nodes.audioElement);
+                participantAudioNodes.delete(participant.identity);
+            }
+        }
+        
+        handler({
+            type: 'trackUnsubscribed',
+            participant: {
+                identity: participant.identity,
+                metadata: participant.metadata || ''
+            }
+        });
+    });
+    
+    room.on(LivekitClient.RoomEvent.ParticipantConnected, (participant) => {
+        handler({
+            type: 'participantConnected',
+            participant: {
+                identity: participant.identity,
+                metadata: participant.metadata || ''
+            }
+        });
+    });
+    
+    room.on(LivekitClient.RoomEvent.ParticipantDisconnected, (participant) => {
+        // Clean up any audio nodes when participant disconnects
+        const nodes = participantAudioNodes.get(participant.identity);
+        if (nodes) {
+            nodes.source.disconnect();
+            nodes.pannerNode.disconnect();
+            nodes.gainNode.disconnect();
+            nodes.audioContext.close();
+            participantAudioNodes.delete(participant.identity);
+        }
+        
+        handler({
+            type: 'participantDisconnected',
+            participant: {
+                identity: participant.identity,
+                metadata: participant.metadata || ''
+            }
+        });
+    });
+}
+
+// Spatial audio control functions
+export function set_participant_spatial_audio(participantIdentity, pan, volume) {
+    const nodes = participantAudioNodes.get(participantIdentity);
+    if (nodes) {
+        // Pan value should be between -1 (left) and 1 (right)
+        nodes.pannerNode.pan.value = Math.max(-1, Math.min(1, pan));
+        // Volume should be between 0 and 1 (or higher for boost)
+        nodes.gainNode.gain.value = Math.max(0, volume);
+        
+        console.log(`Set spatial audio for ${participantIdentity}: pan=${pan}, volume=${volume}`);
+    }
+}
+
+// Set pan value only (-1 to 1, where -1 is left, 0 is center, 1 is right)
+export function set_participant_pan(participantIdentity, pan) {
+    const nodes = participantAudioNodes.get(participantIdentity);
+    if (nodes) {
+        nodes.pannerNode.pan.value = Math.max(-1, Math.min(1, pan));
+    }
+}
+
+// Set volume only (0 to 1, or higher for boost)
+export function set_participant_volume(participantIdentity, volume) {
+    const nodes = participantAudioNodes.get(participantIdentity);
+    if (nodes) {
+        nodes.gainNode.gain.value = Math.max(0, volume);
+    }
+}
+
+// Get all active participant identities with audio
+export function get_audio_participants() {
+    return Array.from(participantAudioNodes.keys());
+}
+
+// Helper function to clean up audio resources
+export function cleanup_audio_track(track) {
+    if (track._audioContext) {
+        track._audioContext.close();
+    }
+    if (track._scriptNode) {
+        track._scriptNode.disconnect();
+    }
+    if (track._audioElement) {
+        track.detach(track._audioElement);
+    }
+}

package/pkg/webgpu_build.d.ts

@@ -0,0 +1,237 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * call from a separate worker to initialize a channel for asset load processing
+ */
+export function init_asset_load_thread(): void;
+export function engine_init(): Promise<any>;
+export function engine_run(platform: string, realm: string, location: string, system_scene: string, with_thread_loader: boolean, rabpf: number): void;
+export function op_webstorage_length(state: WorkerContext): number;
+export function op_webstorage_key(state: WorkerContext, index: number): string | undefined;
+export function op_webstorage_set(state: WorkerContext, key_name: string, value: string): void;
+export function op_webstorage_get(state: WorkerContext, key_name: string): string | undefined;
+export function op_webstorage_remove(state: WorkerContext, key_name: string): void;
+export function op_webstorage_clear(state: WorkerContext): void;
+export function op_webstorage_iterate_keys(state: WorkerContext): string[];
+export function op_webstorage_has(state: WorkerContext, key_name: string): boolean;
+export function op_get_texture_size(state: WorkerContext, src: string): Promise<any>;
+export function op_comms_send_string(state: WorkerContext, message: string): Promise<void>;
+export function op_comms_send_binary_single(state: WorkerContext, message: ArrayBuffer, recipient?: string | null): Promise<void>;
+export function op_comms_recv_binary(state: WorkerContext): Promise<Array<any>>;
+export function op_crdt_send_to_renderer(op_state: WorkerContext, messages: ArrayBuffer): void;
+export function op_crdt_recv_from_renderer(op_state: WorkerContext): Promise<Array<any>>;
+export function op_send_async(state: WorkerContext, method: string, params: string): Promise<any>;
+export function op_subscribe(state: WorkerContext, id: string): void;
+export function op_unsubscribe(state: WorkerContext, id: string): void;
+export function op_send_batch(state: WorkerContext): Array<any>;
+export function op_signed_fetch_headers(state: WorkerContext, uri: string, method?: string | null): Promise<any>;
+export function op_get_connected_players(state: WorkerContext): Promise<string[]>;
+export function op_get_players_in_scene(state: WorkerContext): Promise<string[]>;
+export function op_portable_spawn(state: WorkerContext, pid?: string | null, ens?: string | null): Promise<any>;
+export function op_portable_kill(state: WorkerContext, pid: string): Promise<boolean>;
+export function op_portable_list(state: WorkerContext): Promise<any[]>;
+export function op_move_player_to(op_state: WorkerContext, position_x: number, position_y: number, position_z: number, camera: boolean, maybe_camera_x: number, maybe_camera_y: number, maybe_camera_z: number, looking_at: boolean, maybe_looking_at_x: number, maybe_looking_at_y: number, maybe_looking_at_z: number): void;
+export function op_teleport_to(state: WorkerContext, position_x: number, position_y: number): Promise<boolean>;
+export function op_change_realm(state: WorkerContext, realm: string, message?: string | null): Promise<boolean>;
+export function op_external_url(state: WorkerContext, url: string): Promise<boolean>;
+export function op_emote(op_state: WorkerContext, emote: string): void;
+export function op_scene_emote(op_state: WorkerContext, emote: string, looping: boolean): Promise<void>;
+export function op_open_nft_dialog(op_state: WorkerContext, urn: string): Promise<void>;
+export function op_set_ui_focus(op_state: WorkerContext, element_id: string): Promise<void>;
+export function op_copy_to_clipboard(op_state: WorkerContext, text: string): Promise<void>;
+export function op_read_file(op_state: WorkerContext, filename: string): Promise<any>;
+export function op_scene_information(op_state: WorkerContext): Promise<any>;
+export function op_realm_information(op_state: WorkerContext): Promise<any>;
+export function op_check_for_update(state: WorkerContext): Promise<any>;
+export function op_motd(state: WorkerContext): Promise<string>;
+export function op_get_current_login(state: WorkerContext): string | undefined;
+export function op_get_previous_login(state: WorkerContext): Promise<string | undefined>;
+export function op_login_previous(state: WorkerContext): Promise<void>;
+export function op_login_new_code(state: WorkerContext): Promise<string | undefined>;
+export function op_login_new_success(state: WorkerContext): Promise<void>;
+export function op_login_guest(state: WorkerContext): void;
+export function op_login_cancel(state: WorkerContext): void;
+export function op_logout(state: WorkerContext): void;
+export function op_settings(state: WorkerContext): Promise<Array<any>>;
+export function op_set_setting(state: WorkerContext, name: string, val: number): Promise<void>;
+export function op_kernel_fetch_headers(state: WorkerContext, uri: string, method?: string | null, meta?: string | null): Promise<Array<any>>;
+export function op_set_avatar(state: WorkerContext, base: any, equip: any, has_claimed_name: boolean | null | undefined, profile_extras: any): Promise<number>;
+export function op_native_input(state: WorkerContext): Promise<string>;
+export function op_get_bindings(state: WorkerContext): Promise<any>;
+export function op_set_bindings(state: WorkerContext, bindings: any): Promise<void>;
+export function op_console_command(state: WorkerContext, cmd: string, args: string[]): Promise<string>;
+export function op_live_scene_info(state: WorkerContext): Promise<Array<any>>;
+export function op_get_home_scene(state: WorkerContext): Promise<any>;
+export function op_set_home_scene(state: WorkerContext, realm: string, parcel: any): void;
+export function op_get_system_action_stream(state: WorkerContext): Promise<number>;
+export function op_read_system_action_stream(state: WorkerContext, rid: number): Promise<any>;
+export function op_get_chat_stream(state: WorkerContext): Promise<number>;
+export function op_read_chat_stream(state: WorkerContext, rid: number): Promise<any>;
+export function op_send_chat(state: WorkerContext, message: string, channel: string): void;
+export function op_get_profile_extras(state: WorkerContext): Promise<any>;
+export function op_quit(state: WorkerContext): void;
+export function op_get_permission_request_stream(state: WorkerContext): Promise<number>;
+export function op_read_permission_request_stream(state: WorkerContext, rid: number): Promise<any>;
+export function op_get_permission_used_stream(state: WorkerContext): Promise<number>;
+export function op_read_permission_used_stream(state: WorkerContext, rid: number): Promise<any>;
+export function op_set_single_permission(state: WorkerContext, id: number, allow: boolean): void;
+export function op_set_permanent_permission(state: WorkerContext, level: string, value: string | null | undefined, permission_type: any, allow: any): void;
+export function op_get_permanent_permissions(state: WorkerContext, level: string, value?: string | null): Promise<Array<any>>;
+export function op_get_permission_types(arg0: WorkerContext): Array<any>;
+export function op_testing_enabled(op_state: WorkerContext): boolean;
+export function op_log_test_plan(state: WorkerContext, body: any): void;
+export function op_log_test_result(state: WorkerContext, body: any): void;
+export function op_take_and_compare_snapshot(state: WorkerContext, name: string, camera_position: any, camera_target: any, snapshot_size: any, method: any): any;
+export function op_get_user_data(state: WorkerContext): Promise<any>;
+export function op_get_player_data(state: WorkerContext, id: string): Promise<any>;
+export function wasm_init_scene(): Promise<WorkerContext>;
+export function op_continue_running(state: WorkerContext): boolean;
+export function drop_context(state: WorkerContext): void;
+export function builtin_module(state: WorkerContext, path: string): string;
+export function is_super(state: WorkerContext): boolean;
+export class WorkerContext {
+  private constructor();
+  free(): void;
+  get_source(): any;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly engine_init: () => any;
+  readonly engine_run: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+  readonly init_asset_load_thread: () => void;
+  readonly op_webstorage_length: (a: number) => number;
+  readonly op_webstorage_key: (a: number, b: number) => [number, number];
+  readonly op_webstorage_set: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly op_webstorage_get: (a: number, b: number, c: number) => [number, number];
+  readonly op_webstorage_remove: (a: number, b: number, c: number) => void;
+  readonly op_webstorage_clear: (a: number) => void;
+  readonly op_webstorage_iterate_keys: (a: number) => [number, number];
+  readonly op_webstorage_has: (a: number, b: number, c: number) => number;
+  readonly op_get_texture_size: (a: number, b: number, c: number) => any;
+  readonly op_comms_send_string: (a: number, b: number, c: number) => any;
+  readonly op_comms_send_binary_single: (a: number, b: any, c: number, d: number) => any;
+  readonly op_comms_recv_binary: (a: number) => any;
+  readonly op_crdt_send_to_renderer: (a: number, b: any) => void;
+  readonly op_crdt_recv_from_renderer: (a: number) => any;
+  readonly op_send_async: (a: number, b: number, c: number, d: number, e: number) => any;
+  readonly op_subscribe: (a: number, b: number, c: number) => void;
+  readonly op_unsubscribe: (a: number, b: number, c: number) => void;
+  readonly op_send_batch: (a: number) => any;
+  readonly op_signed_fetch_headers: (a: number, b: number, c: number, d: number, e: number) => any;
+  readonly op_get_connected_players: (a: number) => any;
+  readonly op_get_players_in_scene: (a: number) => any;
+  readonly op_portable_spawn: (a: number, b: number, c: number, d: number, e: number) => any;
+  readonly op_portable_kill: (a: number, b: number, c: number) => any;
+  readonly op_portable_list: (a: number) => any;
+  readonly op_move_player_to: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+  readonly op_teleport_to: (a: number, b: number, c: number) => any;
+  readonly op_change_realm: (a: number, b: number, c: number, d: number, e: number) => any;
+  readonly op_external_url: (a: number, b: number, c: number) => any;
+  readonly op_emote: (a: number, b: number, c: number) => void;
+  readonly op_scene_emote: (a: number, b: number, c: number, d: number) => any;
+  readonly op_open_nft_dialog: (a: number, b: number, c: number) => any;
+  readonly op_set_ui_focus: (a: number, b: number, c: number) => any;
+  readonly op_copy_to_clipboard: (a: number, b: number, c: number) => any;
+  readonly op_read_file: (a: number, b: number, c: number) => any;
+  readonly op_scene_information: (a: number) => any;
+  readonly op_realm_information: (a: number) => any;
+  readonly op_check_for_update: (a: number) => any;
+  readonly op_motd: (a: number) => any;
+  readonly op_get_current_login: (a: number) => [number, number];
+  readonly op_get_previous_login: (a: number) => any;
+  readonly op_login_previous: (a: number) => any;
+  readonly op_login_new_code: (a: number) => any;
+  readonly op_login_new_success: (a: number) => any;
+  readonly op_login_guest: (a: number) => void;
+  readonly op_login_cancel: (a: number) => void;
+  readonly op_logout: (a: number) => void;
+  readonly op_settings: (a: number) => any;
+  readonly op_set_setting: (a: number, b: number, c: number, d: number) => any;
+  readonly op_kernel_fetch_headers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+  readonly op_set_avatar: (a: number, b: any, c: any, d: number, e: any) => any;
+  readonly op_native_input: (a: number) => any;
+  readonly op_get_bindings: (a: number) => any;
+  readonly op_set_bindings: (a: number, b: any) => any;
+  readonly op_console_command: (a: number, b: number, c: number, d: number, e: number) => any;
+  readonly op_live_scene_info: (a: number) => any;
+  readonly op_get_home_scene: (a: number) => any;
+  readonly op_set_home_scene: (a: number, b: number, c: number, d: any) => void;
+  readonly op_get_system_action_stream: (a: number) => any;
+  readonly op_read_system_action_stream: (a: number, b: number) => any;
+  readonly op_get_chat_stream: (a: number) => any;
+  readonly op_read_chat_stream: (a: number, b: number) => any;
+  readonly op_send_chat: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly op_get_profile_extras: (a: number) => any;
+  readonly op_quit: (a: number) => void;
+  readonly op_get_permission_request_stream: (a: number) => any;
+  readonly op_read_permission_request_stream: (a: number, b: number) => any;
+  readonly op_get_permission_used_stream: (a: number) => any;
+  readonly op_read_permission_used_stream: (a: number, b: number) => any;
+  readonly op_set_single_permission: (a: number, b: number, c: number) => void;
+  readonly op_set_permanent_permission: (a: number, b: number, c: number, d: number, e: number, f: any, g: any) => [number, number];
+  readonly op_get_permanent_permissions: (a: number, b: number, c: number, d: number, e: number) => any;
+  readonly op_get_permission_types: (a: number) => any;
+  readonly op_testing_enabled: (a: number) => number;
+  readonly op_log_test_plan: (a: number, b: any) => void;
+  readonly op_log_test_result: (a: number, b: any) => void;
+  readonly op_take_and_compare_snapshot: (a: number, b: number, c: number, d: any, e: any, f: any, g: any) => [number, number, number];
+  readonly op_get_user_data: (a: number) => any;
+  readonly op_get_player_data: (a: number, b: number, c: number) => any;
+  readonly wasm_init_scene: () => any;
+  readonly __wbg_workercontext_free: (a: number, b: number) => void;
+  readonly workercontext_get_source: (a: number) => any;
+  readonly op_continue_running: (a: number) => number;
+  readonly drop_context: (a: number) => void;
+  readonly builtin_module: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly is_super: (a: number) => number;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_1: WebAssembly.Table;
+  readonly memory: WebAssembly.Memory;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_export_7: WebAssembly.Table;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly closure15202_externref_shim: (a: number, b: number, c: number, d: any) => void;
+  readonly closure47507_externref_shim: (a: number, b: number, c: any) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__haf6d1d6eca19ebd1: (a: number, b: number) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h88ef16e697def3fb: (a: number, b: number) => void;
+  readonly closure51410_externref_shim: (a: number, b: number, c: any) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__heedd0a6395901798: (a: number, b: number) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h9bfa50ac2770910f: (a: number, b: number) => void;
+  readonly closure56371_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly closure56375_externref_shim: (a: number, b: number, c: any) => void;
+  readonly _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h704fbbb35af0f5c1: (a: number, b: number) => void;
+  readonly closure116419_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure131351_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure134255_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly __wbindgen_thread_destroy: (a?: number, b?: number, c?: number) => void;
+  readonly __wbindgen_start: (a: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput, memory?: WebAssembly.Memory, thread_stack_size?: number }} module - Passing `SyncInitInput` directly is deprecated.
+* @param {WebAssembly.Memory} memory - Deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput, memory?: WebAssembly.Memory, thread_stack_size?: number } | SyncInitInput, memory?: WebAssembly.Memory): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput>, memory?: WebAssembly.Memory, thread_stack_size?: number }} module_or_path - Passing `InitInput` directly is deprecated.
+* @param {WebAssembly.Memory} memory - Deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput>, memory?: WebAssembly.Memory, thread_stack_size?: number } | InitInput | Promise<InitInput>, memory?: WebAssembly.Memory): Promise<InitOutput>;