@origingame/engine 0.2.0 → 0.4.0

package/dist/web/origin-engine.js

@@ -201,6 +201,42 @@ export function og_anim_retarget(world, desc) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {number} rig
+ * @returns {string}
+ */
+export function og_anim_rig2d_info(world, rig) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_anim_rig2d_info(world, rig);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_anim_skeleton2d_boxes(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_anim_skeleton2d_boxes(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} archetype_view
  * @param {string} component
@@ -469,6 +505,149 @@ export function og_commands_schedule(world, script) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} from
+ * @param {string} to
+ * @param {string | null} [desc]
+ */
+export function og_debug_arrow(world, from, to, desc) {
+    const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(to, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    wasm.og_debug_arrow(world, ptr0, len0, ptr1, len1, ptr2, len2);
+}
+
+/**
+ * @param {number} world
+ * @param {string} position
+ * @param {number} size
+ * @param {string | null} [desc]
+ */
+export function og_debug_axes(world, position, size, desc) {
+    const ptr0 = passStringToWasm0(position, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    wasm.og_debug_axes(world, ptr0, len0, size, ptr1, len1);
+}
+
+/**
+ * @param {number} world
+ * @param {string} center
+ * @param {string} size
+ * @param {string | null} [desc]
+ */
+export function og_debug_box(world, center, size, desc) {
+    const ptr0 = passStringToWasm0(center, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(size, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    wasm.og_debug_box(world, ptr0, len0, ptr1, len1, ptr2, len2);
+}
+
+/**
+ * @param {number} world
+ */
+export function og_debug_clear(world) {
+    wasm.og_debug_clear(world);
+}
+
+/**
+ * @param {number} world
+ * @returns {boolean}
+ */
+export function og_debug_enabled(world) {
+    const ret = wasm.og_debug_enabled(world);
+    return ret !== 0;
+}
+
+/**
+ * @param {number} world
+ * @param {string} from
+ * @param {string} to
+ * @param {string | null} [desc]
+ */
+export function og_debug_line(world, from, to, desc) {
+    const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(to, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    wasm.og_debug_line(world, ptr0, len0, ptr1, len1, ptr2, len2);
+}
+
+/**
+ * @param {number} world
+ * @param {boolean} enabled
+ */
+export function og_debug_set_enabled(world, enabled) {
+    wasm.og_debug_set_enabled(world, enabled);
+}
+
+/**
+ * @param {number} world
+ * @param {string} view
+ */
+export function og_debug_set_view(world, view) {
+    const ptr0 = passStringToWasm0(view, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.og_debug_set_view(world, ptr0, len0);
+}
+
+/**
+ * @param {number} world
+ * @param {string} center
+ * @param {number} radius
+ * @param {string | null} [desc]
+ */
+export function og_debug_sphere(world, center, radius, desc) {
+    const ptr0 = passStringToWasm0(center, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    wasm.og_debug_sphere(world, ptr0, len0, radius, ptr1, len1);
+}
+
+/**
+ * @param {number} world
+ * @param {string} position
+ * @param {string} text
+ * @param {string | null} [desc]
+ */
+export function og_debug_text(world, position, text, desc) {
+    const ptr0 = passStringToWasm0(position, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    wasm.og_debug_text(world, ptr0, len0, ptr1, len1, ptr2, len2);
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_debug_view(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_debug_view(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} engine
  * @param {number} steps
@@ -616,6 +795,23 @@ export function og_engine_probe_commands(engine_probe, script) {
     }
 }
 
+/**
+ * @param {number} engine_probe
+ * @returns {string}
+ */
+export function og_engine_probe_describe(engine_probe) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_engine_probe_describe(engine_probe);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} engine_probe
  * @param {string | null} [desc]
@@ -636,6 +832,43 @@ export function og_engine_probe_dump(engine_probe, desc) {
     }
 }
 
+/**
+ * @param {number} engine_probe
+ * @param {string} what
+ * @returns {string}
+ */
+export function og_engine_probe_expect(engine_probe, what) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(what, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_engine_probe_expect(engine_probe, 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);
+    }
+}
+
+/**
+ * @param {number} engine_probe
+ * @returns {string}
+ */
+export function og_engine_probe_expectations(engine_probe) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_engine_probe_expectations(engine_probe);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} engine_probe
  * @returns {string}
@@ -717,6 +950,25 @@ export function og_engine_probe_restore(engine_probe, id) {
     return ret !== 0;
 }
 
+/**
+ * @param {number} engine_probe
+ * @param {boolean | null} [write]
+ * @param {boolean | null} [spawned]
+ * @returns {string}
+ */
+export function og_engine_probe_save_scene(engine_probe, write, spawned) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_engine_probe_save_scene(engine_probe, isLikeNone(write) ? 0xFFFFFF : write ? 1 : 0, isLikeNone(spawned) ? 0xFFFFFF : spawned ? 1 : 0);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} engine_probe
  * @returns {string}
@@ -1496,6 +1748,26 @@ export function og_load_palette(world, path) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} path
+ * @returns {string}
+ */
+export function og_load_post(world, path) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_post(world, 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);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string} path
@@ -1521,13 +1793,13 @@ export function og_load_rig(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_scene(world, path) {
+export function og_load_rig2d(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_scene(world, ptr0, len0);
+        const ret = wasm.og_load_rig2d(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1541,13 +1813,13 @@ export function og_load_scene(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_shader(world, path) {
+export function og_load_scene(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_shader(world, ptr0, len0);
+        const ret = wasm.og_load_scene(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1561,13 +1833,13 @@ export function og_load_shader(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_skin(world, path) {
+export function og_load_shader(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_skin(world, ptr0, len0);
+        const ret = wasm.og_load_shader(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1637,13 +1909,13 @@ export function og_load_status(world, asset) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_texture(world, path) {
+export function og_load_style(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_texture(world, ptr0, len0);
+        const ret = wasm.og_load_style(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1657,13 +1929,13 @@ export function og_load_texture(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_texture_array(world, path) {
+export function og_load_texture(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_texture_array(world, ptr0, len0);
+        const ret = wasm.og_load_texture(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1677,13 +1949,13 @@ export function og_load_texture_array(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_tilemap(world, path) {
+export function og_load_texture_array(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_tilemap(world, ptr0, len0);
+        const ret = wasm.og_load_texture_array(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1694,16 +1966,16 @@ export function og_load_tilemap(world, path) {
 
 /**
  * @param {number} world
- * @param {string | null} [desc]
+ * @param {string} path
  * @returns {string}
  */
-export function og_nav_build(world, desc) {
+export function og_load_tilemap(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
-        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_nav_build(world, ptr0, len0);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_tilemap(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1714,17 +1986,16 @@ export function og_nav_build(world, desc) {
 
 /**
  * @param {number} world
- * @param {number} grid
- * @param {string} point
+ * @param {string} path
  * @returns {string}
  */
-export function og_nav_cell_at(world, grid, point) {
+export function og_load_timeline(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(point, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_nav_cell_at(world, grid, ptr0, len0);
+        const ret = wasm.og_load_timeline(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1735,16 +2006,95 @@ export function og_nav_cell_at(world, grid, point) {
 
 /**
  * @param {number} world
- * @param {string | null} [desc]
+ * @param {string} path
  * @returns {string}
  */
-export function og_nav_find_path(world, desc) {
+export function og_load_video(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
-        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_nav_find_path(world, ptr0, len0);
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_video(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} video
+ * @returns {string}
+ */
+export function og_load_video_info(world, video) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_load_video_info(world, video);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_nav_build(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_nav_build(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} grid
+ * @param {string} point
+ * @returns {string}
+ */
+export function og_nav_cell_at(world, grid, point) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(point, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_nav_cell_at(world, grid, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_nav_find_path(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_nav_find_path(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1960,6 +2310,158 @@ export function og_nav_set_obstacle(world, mesh, id, obstacle) {
     }
 }
 
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_net_hash(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_net_hash(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_net_status(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_net_status(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [input]
+ * @returns {string}
+ */
+export function og_net_submit(world, input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(input) ? 0 : passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_net_submit(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_path_create(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_path_create(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} name
+ * @returns {string}
+ */
+export function og_path_find(world, name) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_path_find(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} path
+ * @returns {string}
+ */
+export function og_path_length(world, path) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_path_length(world, path);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} path
+ * @param {string} point
+ * @returns {string}
+ */
+export function og_path_nearest(world, path, point) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(point, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_path_nearest(world, path, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} path
+ * @param {number} t
+ * @returns {string}
+ */
+export function og_path_sample(world, path, t) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_path_sample(world, path, t);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {number} entity
@@ -2487,16 +2989,16 @@ export function og_platform_result(world, request) {
 
 /**
  * @param {number} world
- * @param {string} value
+ * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_platform_save_settings(world, value) {
+export function og_platform_room_create(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_platform_save_settings(world, ptr0, len0);
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_room_create(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2507,46 +3009,33 @@ export function og_platform_save_settings(world, value) {
 
 /**
  * @param {number} world
- * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_platform_save_slot(world, desc) {
-    let deferred2_0;
-    let deferred2_1;
+export function og_platform_room_info(world) {
+    let deferred1_0;
+    let deferred1_1;
     try {
-        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_platform_save_slot(world, ptr0, len0);
-        deferred2_0 = ret[0];
-        deferred2_1 = ret[1];
+        const ret = wasm.og_platform_room_info(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }
 
-/**
- * @param {number} engine
- * @param {string} info
- */
-export function og_platform_set_host(engine, info) {
-    const ptr0 = passStringToWasm0(info, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.og_platform_set_host(engine, ptr0, len0);
-}
-
 /**
  * @param {number} world
- * @param {string} key
+ * @param {string} room
  * @returns {string}
  */
-export function og_platform_store_get(world, key) {
+export function og_platform_room_join(world, room) {
     let deferred2_0;
     let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(room, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_platform_store_get(world, ptr0, len0);
+        const ret = wasm.og_platform_room_join(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2557,21 +3046,164 @@ export function og_platform_store_get(world, key) {
 
 /**
  * @param {number} world
- * @returns {number}
- */
-export function og_platform_store_list(world) {
-    const ret = wasm.og_platform_store_list(world);
-    return ret >>> 0;
-}
-
-/**
- * @param {number} world
- * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_platform_store_set(world, desc) {
-    let deferred2_0;
-    let deferred2_1;
+export function og_platform_room_leave(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_leave(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} message
+ * @returns {string}
+ */
+export function og_platform_room_message(world, message) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_message(world, message);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_platform_room_peers(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_peers(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} data
+ * @param {number | null} [to]
+ * @returns {string}
+ */
+export function og_platform_room_send(world, data, to) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_room_send(world, ptr0, len0, isLikeNone(to) ? Number.MAX_SAFE_INTEGER : (to) >>> 0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} value
+ * @returns {string}
+ */
+export function og_platform_save_settings(world, value) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_save_settings(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_platform_save_slot(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_save_slot(world, 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);
+    }
+}
+
+/**
+ * @param {number} engine
+ * @param {string} info
+ */
+export function og_platform_set_host(engine, info) {
+    const ptr0 = passStringToWasm0(info, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.og_platform_set_host(engine, ptr0, len0);
+}
+
+/**
+ * @param {number} world
+ * @param {string} key
+ * @returns {string}
+ */
+export function og_platform_store_get(world, key) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_store_get(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {number}
+ */
+export function og_platform_store_list(world) {
+    const ret = wasm.og_platform_store_list(world);
+    return ret >>> 0;
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_platform_store_set(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
@@ -2787,6 +3419,43 @@ export function og_render_apply_look(world, look) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} preset
+ * @returns {string}
+ */
+export function og_render_apply_quality(world, preset) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_apply_quality(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_render_baked_lighting(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_baked_lighting(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string | null} [desc]
@@ -2807,6 +3476,26 @@ export function og_render_box_geometry(world, desc) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_buffer_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_buffer_geometry(world, 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);
+    }
+}
+
 /**
  * @param {number} world
  * @returns {string}
@@ -2829,13 +3518,73 @@ export function og_render_capabilities(world) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_floating_text(world, desc) {
+export function og_render_capsule_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_floating_text(world, ptr0, len0);
+        const ret = wasm.og_render_capsule_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_circle_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_circle_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_cone_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_cone_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_csg_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_csg_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2846,18 +3595,486 @@ export function og_render_floating_text(world, desc) {
 
 /**
  * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_cylinder_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_cylinder_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_dodecahedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_dodecahedron_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_extrude_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_extrude_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_floating_text(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_floating_text(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} geometry
+ * @returns {string}
+ */
+export function og_render_geometry_info(world, geometry) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_geometry_info(world, geometry);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_icosahedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_icosahedron_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_lathe_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_lathe_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_lines(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_lines(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_render_look(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_look(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_measure_text(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_measure_text(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_merge_geometries(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_merge_geometries(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_octahedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_octahedron_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_plane_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_plane_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_points(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_points(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_polyhedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_polyhedron_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_render_post_errors(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_post_errors(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} ray
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_raycast(world, ray, desc) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(ray, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_raycast(world, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_render_target(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_render_target(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_ribbon(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_ribbon(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_ring_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_ring_geometry(world, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} material
+ * @param {string} shader
+ * @returns {string}
+ */
+export function og_render_set_material_shader(world, material, shader) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(shader, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_set_material_shader(world, material, 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);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} post
+ * @param {string} name
+ * @param {string} value
+ * @returns {string}
+ */
+export function og_render_set_post_param(world, post, name, value) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_set_post_param(world, post, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} material
+ * @param {string} name
+ * @param {string} value
+ * @returns {string}
+ */
+export function og_render_set_shader_param(world, material, name, value) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_set_shader_param(world, material, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} shader
+ * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_look(world) {
-    let deferred1_0;
-    let deferred1_1;
+export function og_render_shader_material(world, shader, desc) {
+    let deferred2_0;
+    let deferred2_1;
     try {
-        const ret = wasm.og_render_look(world);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_shader_material(world, shader, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
 
@@ -2866,13 +4083,13 @@ export function og_render_look(world) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_measure_text(world, desc) {
+export function og_render_shape_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_measure_text(world, ptr0, len0);
+        const ret = wasm.og_render_shape_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2886,13 +4103,13 @@ export function og_render_measure_text(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_plane_geometry(world, desc) {
+export function og_render_sphere_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_plane_geometry(world, ptr0, len0);
+        const ret = wasm.og_render_sphere_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2906,13 +4123,13 @@ export function og_render_plane_geometry(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_ribbon(world, desc) {
+export function og_render_sprite(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_ribbon(world, ptr0, len0);
+        const ret = wasm.og_render_sprite(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2923,17 +4140,16 @@ export function og_render_ribbon(world, desc) {
 
 /**
  * @param {number} world
- * @param {number} material
- * @param {string} shader
+ * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_set_material_shader(world, material, shader) {
+export function og_render_standard_material(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(shader, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_set_material_shader(world, material, ptr0, len0);
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_standard_material(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2944,41 +4160,36 @@ export function og_render_set_material_shader(world, material, shader) {
 
 /**
  * @param {number} world
- * @param {number} material
- * @param {string} name
- * @param {string} value
+ * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_set_shader_param(world, material, name, value) {
-    let deferred3_0;
-    let deferred3_1;
+export function og_render_sweep_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_set_shader_param(world, material, ptr0, len0, ptr1, len1);
-        deferred3_0 = ret[0];
-        deferred3_1 = ret[1];
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_sweep_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
 
 /**
  * @param {number} world
- * @param {number} shader
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_shader_material(world, shader, desc) {
+export function og_render_tetrahedron_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_shader_material(world, shader, ptr0, len0);
+        const ret = wasm.og_render_tetrahedron_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2992,13 +4203,13 @@ export function og_render_shader_material(world, shader, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_sphere_geometry(world, desc) {
+export function og_render_text(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_sphere_geometry(world, ptr0, len0);
+        const ret = wasm.og_render_text(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3012,13 +4223,13 @@ export function og_render_sphere_geometry(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_sprite(world, desc) {
+export function og_render_torus_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_sprite(world, ptr0, len0);
+        const ret = wasm.og_render_torus_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3032,13 +4243,13 @@ export function og_render_sprite(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_standard_material(world, desc) {
+export function og_render_tube_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_standard_material(world, ptr0, len0);
+        const ret = wasm.og_render_tube_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3049,16 +4260,17 @@ export function og_render_standard_material(world, desc) {
 
 /**
  * @param {number} world
+ * @param {number} geometry
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_text(world, desc) {
+export function og_render_update_geometry(world, geometry, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_text(world, ptr0, len0);
+        const ret = wasm.og_render_update_geometry(world, geometry, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3203,6 +4415,45 @@ export function og_rng_stream_range(rng_stream, low, high) {
     return ret;
 }
 
+/**
+ * @param {number} engine
+ * @param {string} event
+ * @returns {boolean}
+ */
+export function og_room_deliver(engine, event) {
+    const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.og_room_deliver(engine, ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * @param {number} engine
+ * @param {string} info
+ */
+export function og_room_set_host(engine, info) {
+    const ptr0 = passStringToWasm0(info, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.og_room_set_host(engine, ptr0, len0);
+}
+
+/**
+ * @param {number} engine
+ * @returns {string}
+ */
+export function og_room_take(engine) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_room_take(engine);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} runtime_probe
  * @returns {number}
@@ -3786,6 +5037,97 @@ export function og_time_set_scale(world, scale) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {number} asset
+ * @returns {string}
+ */
+export function og_timeline_info(world, asset) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_info(world, asset);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_timeline_pause(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_pause(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_timeline_play(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_play(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @param {number} time
+ * @returns {string}
+ */
+export function og_timeline_seek(world, entity, time) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_seek(world, entity, time);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_timeline_stop(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_stop(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {string} position
  * @param {string} quaternion
@@ -5562,6 +6904,24 @@ export function og_web_put_texture_encoded(id, format, width, height, srgb, leve
     }
 }
 
+/**
+ * `og render`'s every-frame capture on the web, as the native host's
+ * `og_node_render_frame` (development only): the display frame drawn last
+ * as RGBA8 rows at the canvas's size, read back without drawing it again
+ * (the probe's `Capture::frame`). Empty until its readback lands: the
+ * first call turns the keeping of presented frames on, and a later one
+ * answers once that frame's copy has landed, so the Worker asks again
+ * before it draws the next frame.
+ * @param {number} engine
+ * @returns {Uint8Array}
+ */
+export function og_web_render_frame(engine) {
+    const ret = wasm.og_web_render_frame(engine);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+
 /**
  * Resize an engine's display target to `width`×`height` device pixels (the
  * shell's canvas after a resize or an orientation change). Applied before
@@ -5676,6 +7036,38 @@ export function og_web_texture_target(engine, manifest, id, bytes) {
     }
 }
 
+/**
+ * The trace (og-runtime's `trace.rs`, the shell's `trace()`): turns the
+ * engine's trace on or off.
+ * @param {number} engine
+ * @param {boolean} on
+ */
+export function og_web_trace(engine, on) {
+    wasm.og_web_trace(engine, on);
+}
+
+/**
+ * The trace's spans since the last take, as JSON (`{ now, events }`, the
+ * events Chrome trace events on the engine's clock); `last` waits for the
+ * GPU's frames in flight where it can (natively only: the web's arrive in
+ * a later take).
+ * @param {number} engine
+ * @param {boolean} last
+ * @returns {string}
+ */
+export function og_web_trace_take(engine, last) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_web_trace_take(engine, last);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Make one pipeline the engine's renderer has not used yet (og-render's
  * `Renderer::warm`): the engine Worker calls it in idle time behind the
@@ -6361,6 +7753,10 @@ function __wbg_get_imports() {
             const ret = arg0.createProgram();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createQuerySet_2dc8cde53df9849d: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createQuerySet(arg1);
+            return ret;
+        }, arguments); },
         __wbg_createQuery_ec241083d0b36197: function(arg0) {
             const ret = arg0.createQuery();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -6579,6 +7975,10 @@ function __wbg_get_imports() {
         __wbg_end_b57473834b877409: function(arg0) {
             arg0.end();
         },
+        __wbg_features_5cac120c28ba0475: function(arg0) {
+            const ret = arg0.features;
+            return ret;
+        },
         __wbg_features_dec7bd2fd3d91bd6: function(arg0) {
             const ret = arg0.features;
             return ret;
@@ -6631,6 +8031,10 @@ function __wbg_get_imports() {
         __wbg_frontFace_b064adb15b6f3772: function(arg0, arg1) {
             arg0.frontFace(arg1 >>> 0);
         },
+        __wbg_getBindGroupLayout_fb40c3b93d37f466: function(arg0, arg1) {
+            const ret = arg0.getBindGroupLayout(arg1 >>> 0);
+            return ret;
+        },
         __wbg_getBufferSubData_dd23246099b166d1: function(arg0, arg1, arg2, arg3) {
             arg0.getBufferSubData(arg1 >>> 0, arg2, arg3);
         },
@@ -6782,6 +8186,26 @@ function __wbg_get_imports() {
             const ret = arg0.info;
             return ret;
         },
+        __wbg_instanceof_GpuOutOfMemoryError_5c3b8a2499f59adb: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof GPUOutOfMemoryError;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_GpuValidationError_7659e07b12d4e184: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof GPUValidationError;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_HtmlCanvasElement_0a30c11fbbf41841: function(arg0) {
             let result;
             try {
@@ -6980,6 +8404,13 @@ function __wbg_get_imports() {
             const ret = arg0.maxVertexBuffers;
             return ret;
         },
+        __wbg_message_2aad50368e15e8f1: function(arg0, arg1) {
+            const ret = arg1.message;
+            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);
+        },
         __wbg_minStorageBufferOffsetAlignment_5ba9b77792bdadb3: function(arg0) {
             const ret = arg0.minStorageBufferOffsetAlignment;
             return ret;
@@ -7070,9 +8501,16 @@ function __wbg_get_imports() {
         __wbg_polygonOffset_8f922d9173d8849d: function(arg0, arg1, arg2) {
             arg0.polygonOffset(arg1, arg2);
         },
+        __wbg_popErrorScope_182b8e03671d81ef: function(arg0) {
+            const ret = arg0.popErrorScope();
+            return ret;
+        },
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_pushErrorScope_fa7df784c43bdb51: function(arg0, arg1) {
+            arg0.pushErrorScope(__wbindgen_enum_GpuErrorFilter[arg1]);
+        },
         __wbg_push_2baf45db356cf468: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
@@ -7128,6 +8566,9 @@ function __wbg_get_imports() {
             const ret = arg0.requestDevice(arg1);
             return ret;
         },
+        __wbg_resolveQuerySet_770f23fabac49845: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.resolveQuerySet(arg1, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
+        },
         __wbg_resolve_0076e10020304ede: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
@@ -7174,6 +8615,9 @@ function __wbg_get_imports() {
         __wbg_setVertexBuffer_cbf4ca1627c02f4c: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
         },
+        __wbg_setViewport_c0be08dcc8965ccf: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            arg0.setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
+        },
         __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
@@ -7289,6 +8733,9 @@ function __wbg_get_imports() {
         __wbg_set_count_8ff0c9474e39a849: function(arg0, arg1) {
             arg0.count = arg1 >>> 0;
         },
+        __wbg_set_count_d9dc88156fd05bc7: function(arg0, arg1) {
+            arg0.count = arg1 >>> 0;
+        },
         __wbg_set_cull_mode_85d2b4ab0ce3a564: function(arg0, arg1) {
             arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
         },
@@ -7433,6 +8880,9 @@ function __wbg_get_imports() {
         __wbg_set_label_612add98a4398f92: function(arg0, arg1, arg2) {
             arg0.label = getStringFromWasm0(arg1, arg2);
         },
+        __wbg_set_label_6f69e25822616a1b: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
         __wbg_set_label_70a09ee68d6b1b26: function(arg0, arg1, arg2) {
             arg0.label = getStringFromWasm0(arg1, arg2);
         },
@@ -7676,6 +9126,9 @@ function __wbg_get_imports() {
         __wbg_set_type_79cec55caf4cdb6d: function(arg0, arg1) {
             arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
         },
+        __wbg_set_type_7f7e54057b801caa: function(arg0, arg1) {
+            arg0.type = __wbindgen_enum_GpuQueryType[arg1];
+        },
         __wbg_set_unclipped_depth_32b7caf29fa5633d: function(arg0, arg1) {
             arg0.unclippedDepth = arg1 !== 0;
         },
@@ -8022,23 +9475,23 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4803, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 5174, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2666, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 3006, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2666, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__352);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 3006, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__429);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2666, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__353);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 3006, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__430);
             return ret;
         },
         __wbindgen_generic_0000000000000005: function(arg0) {
@@ -8116,15 +9569,15 @@ function wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bind
     }
 }
 
-function wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__352(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__352(arg0, arg1, arg2);
+function wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__429(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__429(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__353(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__353(arg0, arg1, arg2);
+function wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__430(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_b8d3fa9391980f8___convert__closures_____invoke___wasm_bindgen_b8d3fa9391980f8___sys__JsNullable_wgpu_318367e4ed152831___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_b8d3fa9391980f8___JsError___true__430(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
@@ -8162,6 +9615,9 @@ const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equa
 const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
 
 
+const __wbindgen_enum_GpuErrorFilter = ["validation", "out-of-memory", "internal"];
+
+
 const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
 
 
@@ -8183,6 +9639,9 @@ const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
 const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
 
 
+const __wbindgen_enum_GpuQueryType = ["occlusion", "timestamp"];
+
+
 const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];