@dcl-regenesislabs/bevy-explorer-web 0.1.0-20720051860.commit-d7c194b → 0.1.0-20720065819.commit-7112fce

package/pkg/webgpu_build.js

@@ -263,11 +263,90 @@ export function image_processor_run() {
     return ret;
 }
 
+/**
+ * @returns {Promise<WorkerContext>}
+ */
+export function wasm_init_scene() {
+    const ret = wasm.wasm_init_scene();
+    return ret;
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
     }
 }
+/**
+ * @param {WorkerContext} state
+ * @returns {boolean}
+ */
+export function op_continue_running(state) {
+    _assertClass(state, WorkerContext);
+    const ret = wasm.op_continue_running(state.__wbg_ptr);
+    return ret !== 0;
+}
+
+/**
+ * @param {WorkerContext} state
+ * @returns {boolean}
+ */
+export function op_communicated_with_renderer(state) {
+    _assertClass(state, WorkerContext);
+    const ret = wasm.op_communicated_with_renderer(state.__wbg_ptr);
+    return ret !== 0;
+}
+
+/**
+ * @param {WorkerContext} state
+ */
+export function drop_context(state) {
+    _assertClass(state, WorkerContext);
+    var ptr0 = state.__destroy_into_raw();
+    wasm.drop_context(ptr0);
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_1.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * @param {WorkerContext} state
+ * @param {string} path
+ * @returns {string}
+ */
+export function builtin_module(state, path) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        _assertClass(state, WorkerContext);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.builtin_module(state.__wbg_ptr, ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {WorkerContext} state
+ * @returns {boolean}
+ */
+export function is_super(state) {
+    _assertClass(state, WorkerContext);
+    const ret = wasm.is_super(state.__wbg_ptr);
+    return ret !== 0;
+}
+
 /**
  * @param {WorkerContext} state
  * @returns {number}
@@ -382,362 +461,237 @@ export function op_webstorage_has(state, key_name) {
 
 /**
  * @param {WorkerContext} state
- * @param {string} src
  * @returns {Promise<any>}
  */
-export function op_get_texture_size(state, src) {
+export function op_check_for_update(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_get_texture_size(state.__wbg_ptr, ptr0, len0);
+    const ret = wasm.op_check_for_update(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} message
- * @returns {Promise<void>}
+ * @returns {Promise<number>}
  */
-export function op_comms_send_string(state, message) {
+export function op_get_system_action_stream(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_comms_send_string(state.__wbg_ptr, ptr0, len0);
+    const ret = wasm.op_get_system_action_stream(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {ArrayBuffer} message
- * @param {string | null} [recipient]
- * @returns {Promise<void>}
+ * @param {number} rid
+ * @returns {Promise<any>}
  */
-export function op_comms_send_binary_single(state, message, recipient) {
+export function op_read_system_action_stream(state, rid) {
     _assertClass(state, WorkerContext);
-    var ptr0 = isLikeNone(recipient) ? 0 : passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_comms_send_binary_single(state.__wbg_ptr, message, ptr0, len0);
+    const ret = wasm.op_read_system_action_stream(state.__wbg_ptr, rid);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<Array<any>>}
+ * @returns {Promise<number>}
  */
-export function op_comms_recv_binary(state) {
+export function op_get_chat_stream(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_comms_recv_binary(state.__wbg_ptr);
+    const ret = wasm.op_get_chat_stream(state.__wbg_ptr);
     return ret;
 }
 
 /**
- * @param {WorkerContext} op_state
- * @param {ArrayBuffer} messages
+ * @param {WorkerContext} state
+ * @param {string} level
+ * @param {string | null | undefined} value
+ * @param {any} permission_type
+ * @param {any} allow
  */
-export function op_crdt_send_to_renderer(op_state, messages) {
-    _assertClass(op_state, WorkerContext);
-    wasm.op_crdt_send_to_renderer(op_state.__wbg_ptr, messages);
+export function op_set_permanent_permission(state, level, value, permission_type, allow) {
+    _assertClass(state, WorkerContext);
+    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.op_set_permanent_permission(state.__wbg_ptr, ptr0, len0, ptr1, len1, permission_type, allow);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
 }
 
 /**
- * @param {WorkerContext} op_state
+ * @param {WorkerContext} state
+ * @param {string} level
+ * @param {string | null} [value]
  * @returns {Promise<Array<any>>}
  */
-export function op_crdt_recv_from_renderer(op_state) {
-    _assertClass(op_state, WorkerContext);
-    const ret = wasm.op_crdt_recv_from_renderer(op_state.__wbg_ptr);
+export function op_get_permanent_permissions(state, level, value) {
+    _assertClass(state, WorkerContext);
+    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.op_get_permanent_permissions(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} arg0
+ * @returns {Array<any>}
+ */
+export function op_get_permission_types(arg0) {
+    _assertClass(arg0, WorkerContext);
+    const ret = wasm.op_get_permission_types(arg0.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} method
- * @param {string} params
- * @returns {Promise<any>}
+ * @param {number} left
+ * @param {number} top
+ * @param {number} right
+ * @param {number} bottom
  */
-export function op_send_async(state, method, params) {
+export function op_set_interactable_area(state, left, top, right, bottom) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(params, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.op_send_async(state.__wbg_ptr, ptr0, len0, ptr1, len1);
-    return ret;
+    wasm.op_set_interactable_area(state.__wbg_ptr, left, top, right, bottom);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} id
+ * @returns {Promise<any>}
  */
-export function op_subscribe(state, id) {
+export function op_get_mic_state(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.op_subscribe(state.__wbg_ptr, ptr0, len0);
+    const ret = wasm.op_get_mic_state(state.__wbg_ptr);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} id
+ * @param {boolean} enabled
+ * @returns {Promise<void>}
  */
-export function op_unsubscribe(state, id) {
+export function op_set_mic_enabled(state, enabled) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.op_unsubscribe(state.__wbg_ptr, ptr0, len0);
+    const ret = wasm.op_set_mic_enabled(state.__wbg_ptr, enabled);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Array<any>}
+ * @returns {Promise<number>}
  */
-export function op_send_batch(state) {
+export function op_get_voice_stream(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_send_batch(state.__wbg_ptr);
+    const ret = wasm.op_get_voice_stream(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} uri
- * @param {string | null} [method]
+ * @param {number} rid
  * @returns {Promise<any>}
  */
-export function op_signed_fetch_headers(state, uri, method) {
+export function op_read_voice_stream(state, rid) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(method) ? 0 : passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.op_signed_fetch_headers(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.op_read_voice_stream(state.__wbg_ptr, rid);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<string[]>}
+ * @param {number} rid
+ * @returns {Promise<any>}
  */
-export function op_get_connected_players(state) {
+export function op_read_chat_stream(state, rid) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_connected_players(state.__wbg_ptr);
+    const ret = wasm.op_read_chat_stream(state.__wbg_ptr, rid);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<string[]>}
+ * @param {string} message
+ * @param {string} channel
  */
-export function op_get_players_in_scene(state) {
+export function op_send_chat(state, message, channel) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_players_in_scene(state.__wbg_ptr);
-    return ret;
+    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(channel, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    wasm.op_send_chat(state.__wbg_ptr, ptr0, len0, ptr1, len1);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string | null} [pid]
- * @param {string | null} [ens]
  * @returns {Promise<any>}
  */
-export function op_portable_spawn(state, pid, ens) {
+export function op_get_profile_extras(state) {
     _assertClass(state, WorkerContext);
-    var ptr0 = isLikeNone(pid) ? 0 : passStringToWasm0(pid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(ens) ? 0 : passStringToWasm0(ens, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.op_portable_spawn(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.op_get_profile_extras(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} pid
- * @returns {Promise<boolean>}
  */
-export function op_portable_kill(state, pid) {
+export function op_quit(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(pid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_portable_kill(state.__wbg_ptr, ptr0, len0);
-    return ret;
+    wasm.op_quit(state.__wbg_ptr);
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<any[]>}
+ * @returns {Promise<number>}
  */
-export function op_portable_list(state) {
+export function op_get_permission_request_stream(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_portable_list(state.__wbg_ptr);
+    const ret = wasm.op_get_permission_request_stream(state.__wbg_ptr);
     return ret;
 }
 
-/**
- * @param {WorkerContext} op_state
- * @param {number} position_x
- * @param {number} position_y
- * @param {number} position_z
- * @param {boolean} camera
- * @param {number} maybe_camera_x
- * @param {number} maybe_camera_y
- * @param {number} maybe_camera_z
- * @param {boolean} looking_at
- * @param {number} maybe_looking_at_x
- * @param {number} maybe_looking_at_y
- * @param {number} maybe_looking_at_z
- */
-export function op_move_player_to(op_state, position_x, position_y, position_z, camera, maybe_camera_x, maybe_camera_y, maybe_camera_z, looking_at, maybe_looking_at_x, maybe_looking_at_y, maybe_looking_at_z) {
-    _assertClass(op_state, WorkerContext);
-    wasm.op_move_player_to(op_state.__wbg_ptr, position_x, position_y, position_z, camera, maybe_camera_x, maybe_camera_y, maybe_camera_z, looking_at, maybe_looking_at_x, maybe_looking_at_y, maybe_looking_at_z);
-}
-
 /**
  * @param {WorkerContext} state
- * @param {number} position_x
- * @param {number} position_y
- * @returns {Promise<boolean>}
+ * @param {number} rid
+ * @returns {Promise<any>}
  */
-export function op_teleport_to(state, position_x, position_y) {
+export function op_read_permission_request_stream(state, rid) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_teleport_to(state.__wbg_ptr, position_x, position_y);
+    const ret = wasm.op_read_permission_request_stream(state.__wbg_ptr, rid);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} realm
- * @param {string | null} [message]
- * @returns {Promise<boolean>}
+ * @returns {Promise<number>}
  */
-export function op_change_realm(state, realm, message) {
+export function op_get_permission_used_stream(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(realm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(message) ? 0 : passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.op_change_realm(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.op_get_permission_used_stream(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} url
- * @returns {Promise<boolean>}
- */
-export function op_external_url(state, url) {
-    _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_external_url(state.__wbg_ptr, ptr0, len0);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
- * @param {string} emote
- */
-export function op_emote(op_state, emote) {
-    _assertClass(op_state, WorkerContext);
-    const ptr0 = passStringToWasm0(emote, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.op_emote(op_state.__wbg_ptr, ptr0, len0);
-}
-
-/**
- * @param {WorkerContext} op_state
- * @param {string} emote
- * @param {boolean} looping
- * @returns {Promise<void>}
- */
-export function op_scene_emote(op_state, emote, looping) {
-    _assertClass(op_state, WorkerContext);
-    const ptr0 = passStringToWasm0(emote, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_scene_emote(op_state.__wbg_ptr, ptr0, len0, looping);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
- * @param {string} urn
- * @returns {Promise<void>}
- */
-export function op_open_nft_dialog(op_state, urn) {
-    _assertClass(op_state, WorkerContext);
-    const ptr0 = passStringToWasm0(urn, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_open_nft_dialog(op_state.__wbg_ptr, ptr0, len0);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
- * @param {boolean} apply
- * @param {string | null} [element_id]
- * @returns {Promise<any>}
- */
-export function op_ui_focus(op_state, apply, element_id) {
-    _assertClass(op_state, WorkerContext);
-    var ptr0 = isLikeNone(element_id) ? 0 : passStringToWasm0(element_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_ui_focus(op_state.__wbg_ptr, apply, ptr0, len0);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
- * @param {string} text
- * @returns {Promise<void>}
- */
-export function op_copy_to_clipboard(op_state, text) {
-    _assertClass(op_state, WorkerContext);
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_copy_to_clipboard(op_state.__wbg_ptr, ptr0, len0);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
- * @param {string} filename
- * @returns {Promise<any>}
- */
-export function op_read_file(op_state, filename) {
-    _assertClass(op_state, WorkerContext);
-    const ptr0 = passStringToWasm0(filename, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_read_file(op_state.__wbg_ptr, ptr0, len0);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
- * @returns {Promise<any>}
- */
-export function op_scene_information(op_state) {
-    _assertClass(op_state, WorkerContext);
-    const ret = wasm.op_scene_information(op_state.__wbg_ptr);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} op_state
+ * @param {number} rid
  * @returns {Promise<any>}
  */
-export function op_realm_information(op_state) {
-    _assertClass(op_state, WorkerContext);
-    const ret = wasm.op_realm_information(op_state.__wbg_ptr);
+export function op_read_permission_used_stream(state, rid) {
+    _assertClass(state, WorkerContext);
+    const ret = wasm.op_read_permission_used_stream(state.__wbg_ptr, rid);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<any>}
+ * @param {number} id
+ * @param {boolean} allow
  */
-export function op_check_for_update(state) {
+export function op_set_single_permission(state, id, allow) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_check_for_update(state.__wbg_ptr);
-    return ret;
+    wasm.op_set_single_permission(state.__wbg_ptr, id, allow);
 }
 
 /**
@@ -775,84 +729,6 @@ export function op_get_previous_login(state) {
     return ret;
 }
 
-/**
- * @param {WorkerContext} state
- * @returns {Promise<void>}
- */
-export function op_login_previous(state) {
-    _assertClass(state, WorkerContext);
-    const ret = wasm.op_login_previous(state.__wbg_ptr);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} state
- * @returns {Promise<string | undefined>}
- */
-export function op_login_new_code(state) {
-    _assertClass(state, WorkerContext);
-    const ret = wasm.op_login_new_code(state.__wbg_ptr);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} state
- * @returns {Promise<void>}
- */
-export function op_login_new_success(state) {
-    _assertClass(state, WorkerContext);
-    const ret = wasm.op_login_new_success(state.__wbg_ptr);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} state
- */
-export function op_login_guest(state) {
-    _assertClass(state, WorkerContext);
-    wasm.op_login_guest(state.__wbg_ptr);
-}
-
-/**
- * @param {WorkerContext} state
- */
-export function op_login_cancel(state) {
-    _assertClass(state, WorkerContext);
-    wasm.op_login_cancel(state.__wbg_ptr);
-}
-
-/**
- * @param {WorkerContext} state
- */
-export function op_logout(state) {
-    _assertClass(state, WorkerContext);
-    wasm.op_logout(state.__wbg_ptr);
-}
-
-/**
- * @param {WorkerContext} state
- * @returns {Promise<Array<any>>}
- */
-export function op_settings(state) {
-    _assertClass(state, WorkerContext);
-    const ret = wasm.op_settings(state.__wbg_ptr);
-    return ret;
-}
-
-/**
- * @param {WorkerContext} state
- * @param {string} name
- * @param {number} val
- * @returns {Promise<void>}
- */
-export function op_set_setting(state, name, val) {
-    _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_set_setting(state.__wbg_ptr, ptr0, len0, val);
-    return ret;
-}
-
 /**
  * @param {WorkerContext} state
  * @param {string} uri
@@ -976,429 +852,553 @@ export function op_set_home_scene(state, realm, parcel) {
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<number>}
+ * @returns {Promise<void>}
  */
-export function op_get_system_action_stream(state) {
+export function op_login_previous(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_system_action_stream(state.__wbg_ptr);
+    const ret = wasm.op_login_previous(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {number} rid
- * @returns {Promise<any>}
+ * @returns {Promise<string | undefined>}
  */
-export function op_read_system_action_stream(state, rid) {
+export function op_login_new_code(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_read_system_action_stream(state.__wbg_ptr, rid);
+    const ret = wasm.op_login_new_code(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<number>}
+ * @returns {Promise<void>}
  */
-export function op_get_chat_stream(state) {
+export function op_login_new_success(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_chat_stream(state.__wbg_ptr);
+    const ret = wasm.op_login_new_success(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {number} rid
- * @returns {Promise<any>}
  */
-export function op_read_chat_stream(state, rid) {
+export function op_login_guest(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_read_chat_stream(state.__wbg_ptr, rid);
-    return ret;
+    wasm.op_login_guest(state.__wbg_ptr);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} message
- * @param {string} channel
  */
-export function op_send_chat(state, message, channel) {
+export function op_login_cancel(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(channel, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    wasm.op_send_chat(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    wasm.op_login_cancel(state.__wbg_ptr);
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<any>}
  */
-export function op_get_profile_extras(state) {
+export function op_logout(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_profile_extras(state.__wbg_ptr);
-    return ret;
+    wasm.op_logout(state.__wbg_ptr);
 }
 
 /**
  * @param {WorkerContext} state
+ * @returns {Promise<Array<any>>}
  */
-export function op_quit(state) {
+export function op_settings(state) {
     _assertClass(state, WorkerContext);
-    wasm.op_quit(state.__wbg_ptr);
+    const ret = wasm.op_settings(state.__wbg_ptr);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<number>}
+ * @param {string} name
+ * @param {number} val
+ * @returns {Promise<void>}
  */
-export function op_get_permission_request_stream(state) {
+export function op_set_setting(state, name, val) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_permission_request_stream(state.__wbg_ptr);
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_set_setting(state.__wbg_ptr, ptr0, len0, val);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {number} rid
  * @returns {Promise<any>}
  */
-export function op_read_permission_request_stream(state, rid) {
+export function op_get_user_data(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_read_permission_request_stream(state.__wbg_ptr, rid);
+    const ret = wasm.op_get_user_data(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<number>}
+ * @param {string} id
+ * @returns {Promise<any>}
  */
-export function op_get_permission_used_stream(state) {
+export function op_get_player_data(state, id) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_permission_used_stream(state.__wbg_ptr);
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_get_player_data(state.__wbg_ptr, ptr0, len0);
     return ret;
 }
 
 /**
- * @param {WorkerContext} state
- * @param {number} rid
- * @returns {Promise<any>}
+ * @param {WorkerContext} op_state
+ * @param {number} position_x
+ * @param {number} position_y
+ * @param {number} position_z
+ * @param {boolean} camera
+ * @param {number} maybe_camera_x
+ * @param {number} maybe_camera_y
+ * @param {number} maybe_camera_z
+ * @param {boolean} looking_at
+ * @param {number} maybe_looking_at_x
+ * @param {number} maybe_looking_at_y
+ * @param {number} maybe_looking_at_z
  */
-export function op_read_permission_used_stream(state, rid) {
-    _assertClass(state, WorkerContext);
-    const ret = wasm.op_read_permission_used_stream(state.__wbg_ptr, rid);
-    return ret;
+export function op_move_player_to(op_state, position_x, position_y, position_z, camera, maybe_camera_x, maybe_camera_y, maybe_camera_z, looking_at, maybe_looking_at_x, maybe_looking_at_y, maybe_looking_at_z) {
+    _assertClass(op_state, WorkerContext);
+    wasm.op_move_player_to(op_state.__wbg_ptr, position_x, position_y, position_z, camera, maybe_camera_x, maybe_camera_y, maybe_camera_z, looking_at, maybe_looking_at_x, maybe_looking_at_y, maybe_looking_at_z);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {number} id
- * @param {boolean} allow
+ * @param {number} position_x
+ * @param {number} position_y
+ * @returns {Promise<boolean>}
  */
-export function op_set_single_permission(state, id, allow) {
+export function op_teleport_to(state, position_x, position_y) {
     _assertClass(state, WorkerContext);
-    wasm.op_set_single_permission(state.__wbg_ptr, id, allow);
+    const ret = wasm.op_teleport_to(state.__wbg_ptr, position_x, position_y);
+    return ret;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_1.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
 /**
  * @param {WorkerContext} state
- * @param {string} level
- * @param {string | null | undefined} value
- * @param {any} permission_type
- * @param {any} allow
+ * @param {string} realm
+ * @param {string | null} [message]
+ * @returns {Promise<boolean>}
  */
-export function op_set_permanent_permission(state, level, value, permission_type, allow) {
+export function op_change_realm(state, realm, message) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ptr0 = passStringToWasm0(realm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var ptr1 = isLikeNone(message) ? 0 : passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.op_set_permanent_permission(state.__wbg_ptr, ptr0, len0, ptr1, len1, permission_type, allow);
-    if (ret[1]) {
-        throw takeFromExternrefTable0(ret[0]);
-    }
+    const ret = wasm.op_change_realm(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} level
- * @param {string | null} [value]
- * @returns {Promise<Array<any>>}
+ * @param {string} url
+ * @returns {Promise<boolean>}
  */
-export function op_get_permanent_permissions(state, level, value) {
+export function op_external_url(state, url) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(value) ? 0 : passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.op_get_permanent_permissions(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.op_external_url(state.__wbg_ptr, ptr0, len0);
     return ret;
 }
 
 /**
- * @param {WorkerContext} arg0
- * @returns {Array<any>}
+ * @param {WorkerContext} op_state
+ * @param {string} emote
  */
-export function op_get_permission_types(arg0) {
-    _assertClass(arg0, WorkerContext);
-    const ret = wasm.op_get_permission_types(arg0.__wbg_ptr);
+export function op_emote(op_state, emote) {
+    _assertClass(op_state, WorkerContext);
+    const ptr0 = passStringToWasm0(emote, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.op_emote(op_state.__wbg_ptr, ptr0, len0);
+}
+
+/**
+ * @param {WorkerContext} op_state
+ * @param {string} emote
+ * @param {boolean} looping
+ * @returns {Promise<void>}
+ */
+export function op_scene_emote(op_state, emote, looping) {
+    _assertClass(op_state, WorkerContext);
+    const ptr0 = passStringToWasm0(emote, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_scene_emote(op_state.__wbg_ptr, ptr0, len0, looping);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} op_state
+ * @param {string} urn
+ * @returns {Promise<void>}
+ */
+export function op_open_nft_dialog(op_state, urn) {
+    _assertClass(op_state, WorkerContext);
+    const ptr0 = passStringToWasm0(urn, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_open_nft_dialog(op_state.__wbg_ptr, ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} op_state
+ * @param {boolean} apply
+ * @param {string | null} [element_id]
+ * @returns {Promise<any>}
+ */
+export function op_ui_focus(op_state, apply, element_id) {
+    _assertClass(op_state, WorkerContext);
+    var ptr0 = isLikeNone(element_id) ? 0 : passStringToWasm0(element_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_ui_focus(op_state.__wbg_ptr, apply, ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} op_state
+ * @param {string} text
+ * @returns {Promise<void>}
+ */
+export function op_copy_to_clipboard(op_state, text) {
+    _assertClass(op_state, WorkerContext);
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_copy_to_clipboard(op_state.__wbg_ptr, ptr0, len0);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {number} left
- * @param {number} top
- * @param {number} right
- * @param {number} bottom
+ * @param {string} method
+ * @param {string} params
+ * @returns {Promise<any>}
  */
-export function op_set_interactable_area(state, left, top, right, bottom) {
+export function op_send_async(state, method, params) {
     _assertClass(state, WorkerContext);
-    wasm.op_set_interactable_area(state.__wbg_ptr, left, top, right, bottom);
+    const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(params, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.op_send_async(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
+ * @param {string} src
  * @returns {Promise<any>}
  */
-export function op_get_mic_state(state) {
+export function op_get_texture_size(state, src) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_mic_state(state.__wbg_ptr);
+    const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_get_texture_size(state.__wbg_ptr, ptr0, len0);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {boolean} enabled
+ * @param {string} message
  * @returns {Promise<void>}
  */
-export function op_set_mic_enabled(state, enabled) {
+export function op_comms_send_string(state, message) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_set_mic_enabled(state.__wbg_ptr, enabled);
+    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_comms_send_string(state.__wbg_ptr, ptr0, len0);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<number>}
+ * @param {ArrayBuffer} message
+ * @param {string | null} [recipient]
+ * @returns {Promise<void>}
  */
-export function op_get_voice_stream(state) {
+export function op_comms_send_binary_single(state, message, recipient) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_voice_stream(state.__wbg_ptr);
+    var ptr0 = isLikeNone(recipient) ? 0 : passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_comms_send_binary_single(state.__wbg_ptr, message, ptr0, len0);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {number} rid
+ * @returns {Promise<Array<any>>}
+ */
+export function op_comms_recv_binary(state) {
+    _assertClass(state, WorkerContext);
+    const ret = wasm.op_comms_recv_binary(state.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} state
+ * @param {string} uri
+ * @param {string | null} [method]
  * @returns {Promise<any>}
  */
-export function op_read_voice_stream(state, rid) {
+export function op_signed_fetch_headers(state, uri, method) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_read_voice_stream(state.__wbg_ptr, rid);
+    const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(method) ? 0 : passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.op_signed_fetch_headers(state.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
 }
 
 /**
  * @param {WorkerContext} op_state
- * @returns {boolean}
+ * @param {ArrayBuffer} messages
  */
-export function op_testing_enabled(op_state) {
+export function op_crdt_send_to_renderer(op_state, messages) {
     _assertClass(op_state, WorkerContext);
-    const ret = wasm.op_testing_enabled(op_state.__wbg_ptr);
-    return ret !== 0;
+    wasm.op_crdt_send_to_renderer(op_state.__wbg_ptr, messages);
+}
+
+/**
+ * @param {WorkerContext} op_state
+ * @returns {Promise<Array<any>>}
+ */
+export function op_crdt_recv_from_renderer(op_state) {
+    _assertClass(op_state, WorkerContext);
+    const ret = wasm.op_crdt_recv_from_renderer(op_state.__wbg_ptr);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {any} body
+ * @param {string} id
  */
-export function op_log_test_plan(state, body) {
+export function op_subscribe(state, id) {
     _assertClass(state, WorkerContext);
-    wasm.op_log_test_plan(state.__wbg_ptr, body);
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.op_subscribe(state.__wbg_ptr, ptr0, len0);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {any} body
+ * @param {string} id
  */
-export function op_log_test_result(state, body) {
+export function op_unsubscribe(state, id) {
     _assertClass(state, WorkerContext);
-    wasm.op_log_test_result(state.__wbg_ptr, body);
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.op_unsubscribe(state.__wbg_ptr, ptr0, len0);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} name
- * @param {any} camera_position
- * @param {any} camera_target
- * @param {any} snapshot_size
- * @param {any} method
- * @returns {any}
+ * @returns {Array<any>}
  */
-export function op_take_and_compare_snapshot(state, name, camera_position, camera_target, snapshot_size, method) {
+export function op_send_batch(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_take_and_compare_snapshot(state.__wbg_ptr, ptr0, len0, camera_position, camera_target, snapshot_size, method);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+    const ret = wasm.op_send_batch(state.__wbg_ptr);
+    return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {Promise<any>}
+ * @returns {Promise<string[]>}
  */
-export function op_get_user_data(state) {
+export function op_get_connected_players(state) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_get_user_data(state.__wbg_ptr);
+    const ret = wasm.op_get_connected_players(state.__wbg_ptr);
     return ret;
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} id
- * @returns {Promise<any>}
+ * @returns {Promise<string[]>}
  */
-export function op_get_player_data(state, id) {
+export function op_get_players_in_scene(state) {
     _assertClass(state, WorkerContext);
-    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ret = wasm.op_get_players_in_scene(state.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} op_state
+ * @param {string} filename
+ * @returns {Promise<any>}
+ */
+export function op_read_file(op_state, filename) {
+    _assertClass(op_state, WorkerContext);
+    const ptr0 = passStringToWasm0(filename, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.op_get_player_data(state.__wbg_ptr, ptr0, len0);
+    const ret = wasm.op_read_file(op_state.__wbg_ptr, ptr0, len0);
     return ret;
 }
 
 /**
- * @returns {Promise<WorkerContext>}
+ * @param {WorkerContext} op_state
+ * @returns {Promise<any>}
  */
-export function wasm_init_scene() {
-    const ret = wasm.wasm_init_scene();
+export function op_scene_information(op_state) {
+    _assertClass(op_state, WorkerContext);
+    const ret = wasm.op_scene_information(op_state.__wbg_ptr);
     return ret;
 }
 
 /**
- * @param {WorkerContext} state
+ * @param {WorkerContext} op_state
+ * @returns {Promise<any>}
+ */
+export function op_realm_information(op_state) {
+    _assertClass(op_state, WorkerContext);
+    const ret = wasm.op_realm_information(op_state.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} op_state
  * @returns {boolean}
  */
-export function op_continue_running(state) {
-    _assertClass(state, WorkerContext);
-    const ret = wasm.op_continue_running(state.__wbg_ptr);
+export function op_testing_enabled(op_state) {
+    _assertClass(op_state, WorkerContext);
+    const ret = wasm.op_testing_enabled(op_state.__wbg_ptr);
     return ret !== 0;
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {boolean}
+ * @param {any} body
  */
-export function op_communicated_with_renderer(state) {
+export function op_log_test_plan(state, body) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.op_communicated_with_renderer(state.__wbg_ptr);
-    return ret !== 0;
+    wasm.op_log_test_plan(state.__wbg_ptr, body);
 }
 
 /**
  * @param {WorkerContext} state
+ * @param {any} body
  */
-export function drop_context(state) {
+export function op_log_test_result(state, body) {
     _assertClass(state, WorkerContext);
-    var ptr0 = state.__destroy_into_raw();
-    wasm.drop_context(ptr0);
+    wasm.op_log_test_result(state.__wbg_ptr, body);
 }
 
 /**
  * @param {WorkerContext} state
- * @param {string} path
- * @returns {string}
+ * @param {string} name
+ * @param {any} camera_position
+ * @param {any} camera_target
+ * @param {any} snapshot_size
+ * @param {any} method
+ * @returns {any}
  */
-export function builtin_module(state, path) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        _assertClass(state, WorkerContext);
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.builtin_module(state.__wbg_ptr, ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+export function op_take_and_compare_snapshot(state, name, camera_position, camera_target, snapshot_size, method) {
+    _assertClass(state, WorkerContext);
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_take_and_compare_snapshot(state.__wbg_ptr, ptr0, len0, camera_position, camera_target, snapshot_size, method);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
  * @param {WorkerContext} state
- * @returns {boolean}
+ * @param {string | null} [pid]
+ * @param {string | null} [ens]
+ * @returns {Promise<any>}
  */
-export function is_super(state) {
+export function op_portable_spawn(state, pid, ens) {
     _assertClass(state, WorkerContext);
-    const ret = wasm.is_super(state.__wbg_ptr);
-    return ret !== 0;
+    var ptr0 = isLikeNone(pid) ? 0 : passStringToWasm0(pid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(ens) ? 0 : passStringToWasm0(ens, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.op_portable_spawn(state.__wbg_ptr, ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} state
+ * @param {string} pid
+ * @returns {Promise<boolean>}
+ */
+export function op_portable_kill(state, pid) {
+    _assertClass(state, WorkerContext);
+    const ptr0 = passStringToWasm0(pid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.op_portable_kill(state.__wbg_ptr, ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {WorkerContext} state
+ * @returns {Promise<any[]>}
+ */
+export function op_portable_list(state) {
+    _assertClass(state, WorkerContext);
+    const ret = wasm.op_portable_list(state.__wbg_ptr);
+    return ret;
 }
 
 function __wbg_adapter_62(arg0, arg1, arg2, arg3) {
-    wasm.closure15289_externref_shim(arg0, arg1, arg2, arg3);
+    wasm.closure15184_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 function __wbg_adapter_65(arg0, arg1, arg2) {
-    wasm.closure48751_externref_shim(arg0, arg1, arg2);
+    wasm.closure48427_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_68(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7aec603de1cde302(arg0, arg1);
+    wasm._dyn_core_f2710c7f87f75ba1___ops__function__FnMut_____Output______as_wasm_bindgen_c65ede6e0f295cba___closure__WasmClosure___describe__invoke______(arg0, arg1);
 }
 
 function __wbg_adapter_71(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he5b48a15f2311f68(arg0, arg1);
+    wasm._dyn_core_f2710c7f87f75ba1___ops__function__FnMut_____Output______as_wasm_bindgen_c65ede6e0f295cba___closure__WasmClosure___describe__invoke______14(arg0, arg1);
 }
 
 function __wbg_adapter_74(arg0, arg1, arg2) {
-    wasm.closure52474_externref_shim(arg0, arg1, arg2);
+    wasm.closure52081_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_81(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha40a927305425e1c(arg0, arg1);
+    wasm._dyn_core_f2710c7f87f75ba1___ops__function__FnMut_____Output______as_wasm_bindgen_c65ede6e0f295cba___closure__WasmClosure___describe__invoke______16(arg0, arg1);
 }
 
 function __wbg_adapter_84(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7f26d1c7d4ed7f8e(arg0, arg1);
+    wasm._dyn_core_f2710c7f87f75ba1___ops__function__FnMut_____Output______as_wasm_bindgen_c65ede6e0f295cba___closure__WasmClosure___describe__invoke______17(arg0, arg1);
 }
 
 function __wbg_adapter_87(arg0, arg1, arg2) {
-    wasm.closure57522_externref_shim(arg0, arg1, arg2);
+    wasm.closure57141_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_94(arg0, arg1, arg2, arg3) {
-    wasm.closure57528_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_90(arg0, arg1, arg2, arg3) {
+    wasm.closure57145_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 function __wbg_adapter_105(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h99bd33b5f9449b5c(arg0, arg1);
+    wasm._dyn_core_f2710c7f87f75ba1___ops__function__FnMut_____Output______as_wasm_bindgen_c65ede6e0f295cba___closure__WasmClosure___describe__invoke______20(arg0, arg1);
 }
 
 function __wbg_adapter_108(arg0, arg1, arg2) {
-    wasm.closure117658_externref_shim(arg0, arg1, arg2);
+    wasm.closure116598_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_111(arg0, arg1, arg2) {
-    wasm.closure132901_externref_shim(arg0, arg1, arg2);
+    wasm.closure131626_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_1557(arg0, arg1, arg2, arg3) {
-    wasm.closure135805_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_1523(arg0, arg1, arg2, arg3) {
+    wasm.closure134522_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
@@ -2719,7 +2719,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_1557(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_1523(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -4289,88 +4289,88 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper151308 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 117659, __wbg_adapter_108);
+    imports.wbg.__wbindgen_closure_wrapper147739 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 116599, __wbg_adapter_108);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper172213 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 132902, __wbg_adapter_111);
+    imports.wbg.__wbindgen_closure_wrapper168293 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 131627, __wbg_adapter_111);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper172215 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 132902, __wbg_adapter_111);
+    imports.wbg.__wbindgen_closure_wrapper168295 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 131627, __wbg_adapter_111);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper20357 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 15290, __wbg_adapter_62);
+    imports.wbg.__wbindgen_closure_wrapper19549 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 15185, __wbg_adapter_62);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper66017 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 48752, __wbg_adapter_65);
+    imports.wbg.__wbindgen_closure_wrapper64257 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 48428, __wbg_adapter_65);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper66205 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 48857, __wbg_adapter_68);
+    imports.wbg.__wbindgen_closure_wrapper64396 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 48531, __wbg_adapter_68);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper70106 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 51828, __wbg_adapter_71);
+    imports.wbg.__wbindgen_closure_wrapper68216 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 51468, __wbg_adapter_71);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper72144 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 52475, __wbg_adapter_74);
+    imports.wbg.__wbindgen_closure_wrapper69414 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 52082, __wbg_adapter_74);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper72146 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 52475, __wbg_adapter_74);
+    imports.wbg.__wbindgen_closure_wrapper69416 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 52082, __wbg_adapter_74);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper72148 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 52475, __wbg_adapter_74);
+    imports.wbg.__wbindgen_closure_wrapper69418 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 52082, __wbg_adapter_74);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper76001 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 55700, __wbg_adapter_81);
+    imports.wbg.__wbindgen_closure_wrapper73979 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 55316, __wbg_adapter_81);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper76997 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 56066, __wbg_adapter_84);
+    imports.wbg.__wbindgen_closure_wrapper74933 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 55682, __wbg_adapter_84);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79080 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77077 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79082 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77079 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_90);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79084 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77081 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79086 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_94);
+    imports.wbg.__wbindgen_closure_wrapper77083 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79088 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77085 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79090 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77087 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79092 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77089 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79094 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_87);
+    imports.wbg.__wbindgen_closure_wrapper77091 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_87);
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper79096 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 57523, __wbg_adapter_105);
+    imports.wbg.__wbindgen_closure_wrapper77093 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 57142, __wbg_adapter_105);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
@@ -4769,7 +4769,7 @@ function __wbg_get_imports() {
 }
 
 function __wbg_init_memory(imports, memory) {
-    imports.wbg.memory = memory || new WebAssembly.Memory({initial:1017,maximum:65536,shared:true});
+    imports.wbg.memory = memory || new WebAssembly.Memory({initial:1009,maximum:65536,shared:true});
 }
 
 function __wbg_finalize_init(instance, module, thread_stack_size) {