@perspective-dev/client 4.1.1 → 4.2.0

package/dist/wasm/perspective-js.js

@@ -1,372 +1,692 @@
-let wasm;
+/* @ts-self-types="./perspective-js.wasm.d.ts" */
 
-let heap = new Array(128).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-function getObject(idx) { return heap[idx]; }
-
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-function getCachedStringFromWasm0(ptr, len) {
-    if (ptr === 0) {
-        return getObject(len);
-    } else {
-        return getStringFromWasm0(ptr, len);
+/**
+ * An instance of a [`Client`] is a connection to a single
+ * `perspective_server::Server`, whether locally in-memory or remote over some
+ * transport like a WebSocket.
+ *
+ * The browser and node.js libraries both support the `websocket(url)`
+ * constructor, which connects to a remote `perspective_server::Server`
+ * instance over a WebSocket transport.
+ *
+ * In the browser, the `worker()` constructor creates a new Web Worker
+ * `perspective_server::Server` and returns a [`Client`] connected to it.
+ *
+ * In node.js, a pre-instantied [`Client`] connected synhronously to a global
+ * singleton `perspective_server::Server` is the default module export.
+ *
+ * # JavaScript Examples
+ *
+ * Create a Web Worker `perspective_server::Server` in the browser and return a
+ * [`Client`] instance connected for it:
+ *
+ * ```javascript
+ * import perspective from "@perspective-dev/client";
+ * const client = await perspective.worker();
+ * ```
+ *
+ * Create a WebSocket connection to a remote `perspective_server::Server`:
+ *
+ * ```javascript
+ * import perspective from "@perspective-dev/client";
+ * const client = await perspective.websocket("ws://locahost:8080/ws");
+ * ```
+ *
+ * Access the synchronous client in node.js:
+ *
+ * ```javascript
+ * import { default as client } from "@perspective-dev/client";
+ * ```
+ */
+export class Client {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Client.prototype);
+        obj.__wbg_ptr = ptr;
+        ClientFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
     }
-}
-
-let heap_next = heap.length;
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const cachedTextEncoder = new TextEncoder();
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClientFinalization.unregister(this);
         return ptr;
     }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_client_free(ptr, 0);
     }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
+    /**
+     * @returns {string}
+     */
+    __getClassname() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.client___getClassname(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    /**
+     * Retrieves the names of all tables that this client has access to.
+     *
+     * `name` is a string identifier unique to the [`Table`] (per [`Client`]),
+     * which can be used in conjunction with [`Client::open_table`] to get
+     * a [`Table`] instance without the use of [`Client::table`]
+     * constructor directly (e.g., one created by another [`Client`]).
+     *
+     * # JavaScript Examples
+     *
+     * ```javascript
+     * const tables = await client.get_hosted_table_names();
+     * ```
+     * @returns {Promise<string[]>}
+     */
+    get_hosted_table_names() {
+        const ret = wasm.client_get_hosted_table_names(this.__wbg_ptr);
+        return takeObject(ret);
     }
-    return cachedDataViewMemory0;
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
+    /**
+     * @param {string} error
+     * @param {Function | null} [reconnect]
+     * @returns {Promise<void>}
+     */
+    handle_error(error, reconnect) {
+        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.client_handle_error(this.__wbg_ptr, ptr0, len0, isLikeNone(reconnect) ? 0 : addHeapObject(reconnect));
+        return takeObject(ret);
     }
-    if (type == 'string') {
-        return `"${val}"`;
+    /**
+     * @param {any} value
+     * @returns {Promise<void>}
+     */
+    handle_response(value) {
+        const ret = wasm.client_handle_response(this.__wbg_ptr, addHeapObject(value));
+        return takeObject(ret);
     }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
+    /**
+     * @param {Function} send_request
+     * @param {Function | null} [close]
+     */
+    constructor(send_request, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.client_new(retptr, addHeapObject(send_request), isLikeNone(close) ? 0 : addHeapObject(close));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            ClientFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
+    /**
+     * @param {Function} on_response
+     * @returns {ProxySession}
+     */
+    new_proxy_session(on_response) {
+        try {
+            const ret = wasm.client_new_proxy_session(this.__wbg_ptr, addBorrowedObject(on_response));
+            return ProxySession.__wrap(ret);
+        } finally {
+            heap[stack_pointer++] = undefined;
         }
     }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
+    /**
+     * @param {Function} callback
+     * @returns {Promise<number>}
+     */
+    on_error(callback) {
+        const ret = wasm.client_on_error(this.__wbg_ptr, addHeapObject(callback));
+        return takeObject(ret);
+    }
+    /**
+     * Register a callback which is invoked whenever [`Client::table`] (on this
+     * [`Client`]) or [`Table::delete`] (on a [`Table`] belinging to this
+     * [`Client`]) are called.
+     * @param {Function} on_update_js
+     * @returns {Promise<number>}
+     */
+    on_hosted_tables_update(on_update_js) {
+        const ret = wasm.client_on_hosted_tables_update(this.__wbg_ptr, addHeapObject(on_update_js));
+        return takeObject(ret);
+    }
+    /**
+     * Opens a [`Table`] that is hosted on the `perspective_server::Server`
+     * that is connected to this [`Client`].
+     *
+     * The `name` property of [`TableInitOptions`] is used to identify each
+     * [`Table`]. [`Table`] `name`s can be looked up for each [`Client`]
+     * via [`Client::get_hosted_table_names`].
+     *
+     * # JavaScript Examples
+     *
+     * Get a virtual [`Table`] named "table_one" from this [`Client`]
+     *
+     * ```javascript
+     * const tables = await client.open_table("table_one");
+     * ```
+     * @param {string} entity_id
+     * @returns {Promise<Table>}
+     */
+    open_table(entity_id) {
+        const ptr0 = passStringToWasm0(entity_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.client_open_table(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Remove a callback previously registered via
+     * `Client::on_hosted_tables_update`.
+     * @param {number} update_id
+     * @returns {Promise<void>}
+     */
+    remove_hosted_tables_update(update_id) {
+        const ret = wasm.client_remove_hosted_tables_update(this.__wbg_ptr, update_id);
+        return takeObject(ret);
+    }
+    /**
+     * Provides the [`SystemInfo`] struct, implementation-specific metadata
+     * about the [`perspective_server::Server`] runtime such as Memory and
+     * CPU usage.
+     *
+     * For WebAssembly servers, this method includes the WebAssembly heap size.
+     *
+     * # JavaScript Examples
+     *
+     * ```javascript
+     * const info = await client.system_info();
+     * ```
+     * @returns {Promise<SystemInfo>}
+     */
+    system_info() {
+        const ret = wasm.client_system_info(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Creates a new [`Table`] from either a _schema_ or _data_.
+     *
+     * The [`Client::table`] factory function can be initialized with either a
+     * _schema_ (see [`Table::schema`]), or data in one of these formats:
+     *
+     * - Apache Arrow
+     * - CSV
+     * - JSON row-oriented
+     * - JSON column-oriented
+     * - NDJSON
+     *
+     * When instantiated with _data_, the schema is inferred from this data.
+     * While this is convenient, inferrence is sometimes imperfect e.g.
+     * when the input is empty, null or ambiguous. For these cases,
+     * [`Client::table`] can first be instantiated with a explicit schema.
+     *
+     * When instantiated with a _schema_, the resulting [`Table`] is empty but
+     * with known column names and column types. When subsqeuently
+     * populated with [`Table::update`], these columns will be _coerced_ to
+     * the schema's type. This behavior can be useful when
+     * [`Client::table`]'s column type inferences doesn't work.
+     *
+     * The resulting [`Table`] is _virtual_, and invoking its methods
+     * dispatches events to the `perspective_server::Server` this
+     * [`Client`] connects to, where the data is stored and all calculation
+     * occurs.
+     *
+     * # Arguments
+     *
+     * - `arg` - Either _schema_ or initialization _data_.
+     * - `options` - Optional configuration which provides one of:
+     *     - `limit` - The max number of rows the resulting [`Table`] can
+     *       store.
+     *     - `index` - The column name to use as an _index_ column. If this
+     *       `Table` is being instantiated by _data_, this column name must be
+     *       present in the data.
+     *     - `name` - The name of the table. This will be generated if it is
+     *       not provided.
+     *     - `format` - The explicit format of the input data, can be one of
+     *       `"json"`, `"columns"`, `"csv"` or `"arrow"`. This overrides
+     *       language-specific type dispatch behavior, which allows stringified
+     *       and byte array alternative inputs.
+     *
+     * # JavaScript Examples
+     *
+     * Load a CSV from a `string`:
+     *
+     * ```javascript
+     * const table = await client.table("x,y\n1,2\n3,4");
+     * ```
+     *
+     * Load an Arrow from an `ArrayBuffer`:
+     *
+     * ```javascript
+     * import * as fs from "node:fs/promises";
+     * const table2 = await client.table(await fs.readFile("superstore.arrow"));
+     * ```
+     *
+     * Load a CSV from a `UInt8Array` (the default for this type is Arrow)
+     * using a format override:
+     *
+     * ```javascript
+     * const enc = new TextEncoder();
+     * const table = await client.table(enc.encode("x,y\n1,2\n3,4"), {
+     *     format: "csv",
+     * });
+     * ```
+     *
+     * Create a table with an `index`:
+     *
+     * ```javascript
+     * const table = await client.table(data, { index: "Row ID" });
+     * ```
+     * @param {string | ArrayBuffer | Record<string, unknown[]> | Record<string, unknown>[] | Record<string, ColumnType>} value
+     * @param {TableInitOptions | null} [options]
+     * @returns {Promise<Table>}
+     */
+    table(value, options) {
+        const ret = wasm.client_table(this.__wbg_ptr, addHeapObject(value), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Terminates this [`Client`], cleaning up any [`crate::View`] handles the
+     * [`Client`] has open as well as its callbacks.
+     * @returns {any}
+     */
+    terminate() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.client_terminate(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
+    }
+}
+if (Symbol.dispose) Client.prototype[Symbol.dispose] = Client.prototype.free;
+
+/**
+ * JavaScript-facing DuckDB SQL query builder.
+ *
+ * This struct wraps the Rust `DuckDBSqlBuilder` and exposes it to JavaScript
+ * via wasm_bindgen.
+ */
+export class GenericSQLVirtualServerModel {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GenericSQLVirtualServerModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_genericsqlvirtualservermodel_free(ptr, 0);
+    }
+    /**
+     * Returns the SQL query to list all hosted tables.
+     * @returns {string}
+     */
+    getHostedTables() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.genericsqlvirtualservermodel_getHostedTables(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-        debug += ']';
-        return debug;
     }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
+    /**
+     * Creates a new `JsDuckDBSqlBuilder` instance.
+     * @param {any | null} [args]
+     */
+    constructor(args) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.genericsqlvirtualservermodel_new(retptr, isLikeNone(args) ? 0 : addHeapObject(args));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            GenericSQLVirtualServerModelFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
+    /**
+     * Returns the SQL query to create a view from a table with the given
+     * configuration.
+     * @param {string} table_id
+     * @param {string} view_id
+     * @param {any} config
+     * @returns {string}
+     */
+    tableMakeView(table_id, view_id, config) {
         try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(table_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(view_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_tableMakeView(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(config));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the SQL query to describe a table's schema.
+     * @param {string} table_id
+     * @returns {string}
+     */
+    tableSchema(table_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(table_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_tableSchema(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the SQL query to get the row count of a table.
+     * @param {string} table_id
+     * @returns {string}
+     */
+    tableSize(table_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(table_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_tableSize(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the SQL query to validate an expression against a table.
+     * @param {string} table_id
+     * @param {string} expression
+     * @returns {string}
+     */
+    tableValidateExpression(table_id, expression) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(table_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(expression, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_tableValidateExpression(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v3 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_export3(addHeapObject(e));
-    }
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(takeObject(mem.getUint32(i, true)));
+    /**
+     * Returns the SQL query to get the column count of a view.
+     * @param {string} view_id
+     * @returns {string}
+     */
+    viewColumnSize(view_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(view_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_viewColumnSize(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
-    return result;
-}
-
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
+    /**
+     * Returns the SQL query to delete a view.
+     * @param {string} view_id
+     * @returns {string}
+     */
+    viewDelete(view_id) {
         try {
-            return f(a, state.b, ...args);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(view_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_viewDelete(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
         } finally {
-            state.a = a;
-            real._wbg_cb_unref();
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-    };
-    real._wbg_cb_unref = () => {
-        if (--state.cnt === 0) {
-            state.dtor(state.a, state.b);
-            state.a = 0;
-            CLOSURE_DTORS.unregister(state);
+    }
+    /**
+     * Returns the SQL query to fetch data from a view with the given viewport.
+     * @param {string} view_id
+     * @param {any} config
+     * @param {any} viewport
+     * @param {any} schema
+     * @returns {string}
+     */
+    viewGetData(view_id, config, viewport, schema) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(view_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_viewGetData(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(config), addHeapObject(viewport), addHeapObject(schema));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-    };
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
-function makeClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
+    }
+    /**
+     * Returns the SQL query to describe a view's schema.
+     * @param {string} view_id
+     * @returns {string}
+     */
+    viewSchema(view_id) {
         try {
-            return f(state.a, state.b, ...args);
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(view_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_viewSchema(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
         } finally {
-            real._wbg_cb_unref();
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-    };
-    real._wbg_cb_unref = () => {
-        if (--state.cnt === 0) {
-            state.dtor(state.a, state.b);
-            state.a = 0;
-            CLOSURE_DTORS.unregister(state);
+    }
+    /**
+     * Returns the SQL query to get the row count of a view.
+     * @param {string} view_id
+     * @returns {string}
+     */
+    viewSize(view_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(view_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.genericsqlvirtualservermodel_viewSize(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getCachedStringFromWasm0(r0, r1);
+            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
         }
-    };
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
     }
 }
+if (Symbol.dispose) GenericSQLVirtualServerModel.prototype[Symbol.dispose] = GenericSQLVirtualServerModel.prototype.free;
 
-let stack_pointer = 128;
-
-function addBorrowedObject(obj) {
-    if (stack_pointer == 1) throw new Error('out of js stack');
-    heap[--stack_pointer] = obj;
-    return stack_pointer;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-export function init() {
-    wasm.init();
-}
-
-function __wasm_bindgen_func_elem_553(arg0, arg1) {
-    const ret = wasm.__wasm_bindgen_func_elem_553(arg0, arg1);
-    return takeObject(ret);
-}
-
-function __wasm_bindgen_func_elem_3515(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_3515(arg0, arg1, addHeapObject(arg2));
-}
-
-function __wasm_bindgen_func_elem_5070(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_5070(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
-}
-
-const ClientFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_client_free(ptr >>> 0, 1));
-/**
- * An instance of a [`Client`] is a connection to a single
- * `perspective_server::Server`, whether locally in-memory or remote over some
- * transport like a WebSocket.
- *
- * The browser and node.js libraries both support the `websocket(url)`
- * constructor, which connects to a remote `perspective_server::Server`
- * instance over a WebSocket transport.
- *
- * In the browser, the `worker()` constructor creates a new Web Worker
- * `perspective_server::Server` and returns a [`Client`] connected to it.
- *
- * In node.js, a pre-instantied [`Client`] connected synhronously to a global
- * singleton `perspective_server::Server` is the default module export.
- *
- * # JavaScript Examples
- *
- * Create a Web Worker `perspective_server::Server` in the browser and return a
- * [`Client`] instance connected for it:
- *
- * ```javascript
- * import perspective from "@perspective-dev/client";
- * const client = await perspective.worker();
- * ```
- *
- * Create a WebSocket connection to a remote `perspective_server::Server`:
- *
- * ```javascript
- * import perspective from "@perspective-dev/client";
- * const client = await perspective.websocket("ws://locahost:8080/ws");
- * ```
- *
- * Access the synchronous client in node.js:
- *
- * ```javascript
- * import { default as client } from "@perspective-dev/client";
- * ```
- */
-export class Client {
+export class ProxySession {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProxySession.prototype);
+        obj.__wbg_ptr = ptr;
+        ProxySessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProxySessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_proxysession_free(ptr, 0);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    close() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.proxysession_close(ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} value
+     * @returns {Promise<void>}
+     */
+    handle_request(value) {
+        const ret = wasm.proxysession_handle_request(this.__wbg_ptr, addHeapObject(value));
+        return takeObject(ret);
+    }
+    /**
+     * @param {Client} client
+     * @param {Function} on_response
+     */
+    constructor(client, on_response) {
+        try {
+            _assertClass(client, Client);
+            const ret = wasm.proxysession_new(client.__wbg_ptr, addBorrowedObject(on_response));
+            this.__wbg_ptr = ret >>> 0;
+            ProxySessionFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            heap[stack_pointer++] = undefined;
+        }
+    }
+}
+if (Symbol.dispose) ProxySession.prototype[Symbol.dispose] = ProxySession.prototype.free;
 
+export class Table {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Client.prototype);
+        const obj = Object.create(Table.prototype);
         obj.__wbg_ptr = ptr;
-        ClientFinalization.register(obj, obj.__wbg_ptr, obj);
+        TableFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ClientFinalization.unregister(this);
+        TableFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_client_free(ptr, 0);
+        wasm.__wbg_table_free(ptr, 0);
     }
     /**
      * @returns {string}
@@ -374,7 +694,7 @@ export class Client {
     __getClassname() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.client___getClassname(retptr, this.__wbg_ptr);
+            wasm.table___getClassname(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getCachedStringFromWasm0(r0, r1);
@@ -385,1790 +705,1748 @@ export class Client {
         }
     }
     /**
-     * @param {Function} send_request
-     * @param {Function | null} [close]
-     */
-    constructor(send_request, close) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.client_new(retptr, addHeapObject(send_request), isLikeNone(close) ? 0 : addHeapObject(close));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            this.__wbg_ptr = r0 >>> 0;
-            ClientFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * @param {Function} on_response
-     * @returns {ProxySession}
-     */
-    new_proxy_session(on_response) {
-        try {
-            const ret = wasm.client_new_proxy_session(this.__wbg_ptr, addBorrowedObject(on_response));
-            return ProxySession.__wrap(ret);
-        } finally {
-            heap[stack_pointer++] = undefined;
-        }
-    }
-    /**
-     * @param {any} value
-     * @returns {Promise<void>}
-     */
-    handle_response(value) {
-        const ret = wasm.client_handle_response(this.__wbg_ptr, addHeapObject(value));
-        return takeObject(ret);
-    }
-    /**
-     * @param {string} error
-     * @param {Function | null} [reconnect]
+     * Removes all the rows in the [`Table`], but preserves everything else
+     * including the schema, index, and any callbacks or registered
+     * [`View`] instances.
+     *
+     * Calling [`Table::clear`], like [`Table::update`] and [`Table::remove`],
+     * will trigger an update event to any registered listeners via
+     * [`View::on_update`].
      * @returns {Promise<void>}
      */
-    handle_error(error, reconnect) {
-        const ptr0 = passStringToWasm0(error, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.client_handle_error(this.__wbg_ptr, ptr0, len0, isLikeNone(reconnect) ? 0 : addHeapObject(reconnect));
+    clear() {
+        const ret = wasm.table_clear(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * @param {Function} callback
-     * @returns {Promise<number>}
+     * Returns the column names of this [`Table`] in "natural" order (the
+     * ordering implied by the input format).
+     *
+     *  # JavaScript Examples
+     *
+     *  ```javascript
+     *  const columns = await table.columns();
+     *  ```
+     * @returns {Promise<any>}
      */
-    on_error(callback) {
-        const ret = wasm.client_on_error(this.__wbg_ptr, addHeapObject(callback));
+    columns() {
+        const ret = wasm.table_columns(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * Creates a new [`Table`] from either a _schema_ or _data_.
-     *
-     * The [`Client::table`] factory function can be initialized with either a
-     * _schema_ (see [`Table::schema`]), or data in one of these formats:
-     *
-     * - Apache Arrow
-     * - CSV
-     * - JSON row-oriented
-     * - JSON column-oriented
-     * - NDJSON
-     *
-     * When instantiated with _data_, the schema is inferred from this data.
-     * While this is convenient, inferrence is sometimes imperfect e.g.
-     * when the input is empty, null or ambiguous. For these cases,
-     * [`Client::table`] can first be instantiated with a explicit schema.
-     *
-     * When instantiated with a _schema_, the resulting [`Table`] is empty but
-     * with known column names and column types. When subsqeuently
-     * populated with [`Table::update`], these columns will be _coerced_ to
-     * the schema's type. This behavior can be useful when
-     * [`Client::table`]'s column type inferences doesn't work.
+     * Delete this [`Table`] and cleans up associated resources.
      *
-     * The resulting [`Table`] is _virtual_, and invoking its methods
-     * dispatches events to the `perspective_server::Server` this
-     * [`Client`] connects to, where the data is stored and all calculation
-     * occurs.
+     * [`Table`]s do not stop consuming resources or processing updates when
+     * they are garbage collected in their host language - you must call
+     * this method to reclaim these.
      *
      * # Arguments
      *
-     * - `arg` - Either _schema_ or initialization _data_.
-     * - `options` - Optional configuration which provides one of:
-     *     - `limit` - The max number of rows the resulting [`Table`] can
-     *       store.
-     *     - `index` - The column name to use as an _index_ column. If this
-     *       `Table` is being instantiated by _data_, this column name must be
-     *       present in the data.
-     *     - `name` - The name of the table. This will be generated if it is
-     *       not provided.
-     *     - `format` - The explicit format of the input data, can be one of
-     *       `"json"`, `"columns"`, `"csv"` or `"arrow"`. This overrides
-     *       language-specific type dispatch behavior, which allows stringified
-     *       and byte array alternative inputs.
+     * - `options` An options dictionary.
+     *     - `lazy` Whether to delete this [`Table`] _lazily_. When false (the
+     *       default), the delete will occur immediately, assuming it has no
+     *       [`View`] instances registered to it (which must be deleted first,
+     *       otherwise this method will throw an error). When true, the
+     *       [`Table`] will only be marked for deltion once its [`View`]
+     *       dependency count reaches 0.
      *
      * # JavaScript Examples
      *
-     * Load a CSV from a `string`:
-     *
      * ```javascript
      * const table = await client.table("x,y\n1,2\n3,4");
-     * ```
-     *
-     * Load an Arrow from an `ArrayBuffer`:
-     *
-     * ```javascript
-     * import * as fs from "node:fs/promises";
-     * const table2 = await client.table(await fs.readFile("superstore.arrow"));
-     * ```
-     *
-     * Load a CSV from a `UInt8Array` (the default for this type is Arrow)
-     * using a format override:
-     *
-     * ```javascript
-     * const enc = new TextEncoder();
-     * const table = await client.table(enc.encode("x,y\n1,2\n3,4"), {
-     *     format: "csv",
-     * });
-     * ```
-     *
-     * Create a table with an `index`:
-     *
-     * ```javascript
-     * const table = await client.table(data, { index: "Row ID" });
-     * ```
-     * @param {string | ArrayBuffer | Record<string, unknown[]> | Record<string, unknown>[] | Record<string, ColumnType>} value
-     * @param {TableInitOptions | null} [options]
-     * @returns {Promise<Table>}
-     */
-    table(value, options) {
-        const ret = wasm.client_table(this.__wbg_ptr, addHeapObject(value), isLikeNone(options) ? 0 : addHeapObject(options));
-        return takeObject(ret);
-    }
-    /**
-     * Terminates this [`Client`], cleaning up any [`crate::View`] handles the
-     * [`Client`] has open as well as its callbacks.
-     * @returns {any}
-     */
-    terminate() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.client_terminate(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Opens a [`Table`] that is hosted on the `perspective_server::Server`
-     * that is connected to this [`Client`].
-     *
-     * The `name` property of [`TableInitOptions`] is used to identify each
-     * [`Table`]. [`Table`] `name`s can be looked up for each [`Client`]
-     * via [`Client::get_hosted_table_names`].
-     *
-     * # JavaScript Examples
-     *
-     * Get a virtual [`Table`] named "table_one" from this [`Client`]
-     *
-     * ```javascript
-     * const tables = await client.open_table("table_one");
-     * ```
-     * @param {string} entity_id
-     * @returns {Promise<Table>}
-     */
-    open_table(entity_id) {
-        const ptr0 = passStringToWasm0(entity_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.client_open_table(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * Retrieves the names of all tables that this client has access to.
-     *
-     * `name` is a string identifier unique to the [`Table`] (per [`Client`]),
-     * which can be used in conjunction with [`Client::open_table`] to get
-     * a [`Table`] instance without the use of [`Client::table`]
-     * constructor directly (e.g., one created by another [`Client`]).
      *
-     * # JavaScript Examples
+     * // ...
      *
-     * ```javascript
-     * const tables = await client.get_hosted_table_names();
+     * await table.delete({ lazy: true });
      * ```
-     * @returns {Promise<string[]>}
-     */
-    get_hosted_table_names() {
-        const ret = wasm.client_get_hosted_table_names(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * Register a callback which is invoked whenever [`Client::table`] (on this
-     * [`Client`]) or [`Table::delete`] (on a [`Table`] belinging to this
-     * [`Client`]) are called.
-     * @param {Function} on_update_js
-     * @returns {Promise<number>}
+     * @param {DeleteOptions | null} [options]
+     * @returns {Promise<void>}
      */
-    on_hosted_tables_update(on_update_js) {
-        const ret = wasm.client_on_hosted_tables_update(this.__wbg_ptr, addHeapObject(on_update_js));
+    delete(options) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.table_delete(ptr, isLikeNone(options) ? 0 : addHeapObject(options));
         return takeObject(ret);
     }
     /**
-     * Remove a callback previously registered via
-     * `Client::on_hosted_tables_update`.
-     * @param {number} update_id
-     * @returns {Promise<void>}
+     * Get a copy of the [`Client`] this [`Table`] came from.
+     * @returns {Promise<Client>}
      */
-    remove_hosted_tables_update(update_id) {
-        const ret = wasm.client_remove_hosted_tables_update(this.__wbg_ptr, update_id);
+    get_client() {
+        const ret = wasm.table_get_client(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * Provides the [`SystemInfo`] struct, implementation-specific metadata
-     * about the [`perspective_server::Server`] runtime such as Memory and
-     * CPU usage.
-     *
-     * For WebAssembly servers, this method includes the WebAssembly heap size.
+     * Returns the name of the index column for the table.
      *
      * # JavaScript Examples
      *
      * ```javascript
-     * const info = await client.system_info();
+     * const table = await client.table("x,y\n1,2\n3,4", { index: "x" });
+     * const index = table.get_index(); // "x"
      * ```
-     * @returns {Promise<SystemInfo>}
+     * @returns {Promise<string>}
      */
-    system_info() {
-        const ret = wasm.client_system_info(this.__wbg_ptr);
+    get_index() {
+        const ret = wasm.table_get_index(this.__wbg_ptr);
         return takeObject(ret);
     }
-}
-if (Symbol.dispose) Client.prototype[Symbol.dispose] = Client.prototype.free;
-
-const JsVirtualDataSliceFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsvirtualdataslice_free(ptr >>> 0, 1));
-
-export class JsVirtualDataSlice {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsVirtualDataSlice.prototype);
-        obj.__wbg_ptr = ptr;
-        JsVirtualDataSliceFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsVirtualDataSliceFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsvirtualdataslice_free(ptr, 0);
-    }
-    constructor() {
-        const ret = wasm.jsvirtualdataslice_new();
-        this.__wbg_ptr = ret >>> 0;
-        JsVirtualDataSliceFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * Returns the user-specified row limit for this table.
+     * @returns {Promise<number | undefined>}
+     */
+    get_limit() {
+        const ret = wasm.table_get_limit(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-     * @param {string} dtype
-     * @param {string} name
-     * @param {number} index
-     * @param {any} val
-     * @param {number | null} [group_by_index]
+     * Returns the user-specified name for this table, or the auto-generated
+     * name if a name was not specified when the table was created.
+     * @returns {Promise<string>}
      */
-    setCol(dtype, name, index, val, group_by_index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(dtype, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.jsvirtualdataslice_setCol(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    get_name() {
+        const ret = wasm.table_get_name(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-     * @param {string} name
-     * @param {number} index
-     * @param {any} val
-     * @param {number | null} [group_by_index]
+     * Create a unique channel ID on this [`Table`], which allows
+     * `View::on_update` callback calls to be associated with the
+     * `Table::update` which caused them.
+     * @returns {Promise<number>}
      */
-    setStringCol(name, index, val, group_by_index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.jsvirtualdataslice_setStringCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    make_port() {
+        const ret = wasm.table_make_port(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-     * @param {string} name
-     * @param {number} index
-     * @param {any} val
-     * @param {number | null} [group_by_index]
+     * Register a callback which is called exactly once, when this [`Table`] is
+     * deleted with the [`Table::delete`] method.
+     *
+     * [`Table::on_delete`] resolves when the subscription message is sent, not
+     * when the _delete_ event occurs.
+     * @param {Function} on_delete
+     * @returns {Promise<any>}
      */
-    setIntegerCol(name, index, val, group_by_index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.jsvirtualdataslice_setIntegerCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    on_delete(on_delete) {
+        const ret = wasm.table_on_delete(this.__wbg_ptr, addHeapObject(on_delete));
+        return takeObject(ret);
     }
     /**
-     * @param {string} name
-     * @param {number} index
-     * @param {any} val
-     * @param {number | null} [group_by_index]
+     * Removes rows from this [`Table`] with the `index` column values
+     * supplied.
+     *
+     * # Arguments
+     *
+     * - `indices` - A list of `index` column values for rows that should be
+     *   removed.
+     *
+     * # JavaScript Examples
+     *
+     * ```javascript
+     * await table.remove([1, 2, 3]);
+     * ```
+     * @param {any} value
+     * @param {UpdateOptions | null} [options]
+     * @returns {Promise<void>}
      */
-    setFloatCol(name, index, val, group_by_index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.jsvirtualdataslice_setFloatCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    remove(value, options) {
+        const ret = wasm.table_remove(this.__wbg_ptr, addHeapObject(value), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
     }
     /**
-     * @param {string} name
-     * @param {number} index
-     * @param {any} val
-     * @param {number | null} [group_by_index]
+     * Removes a listener with a given ID, as returned by a previous call to
+     * [`Table::on_delete`].
+     * @param {number} callback_id
+     * @returns {Promise<any>}
      */
-    setBooleanCol(name, index, val, group_by_index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.jsvirtualdataslice_setBooleanCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    remove_delete(callback_id) {
+        const ret = wasm.table_remove_delete(this.__wbg_ptr, callback_id);
+        return takeObject(ret);
     }
     /**
-     * @param {string} name
-     * @param {number} index
-     * @param {any} val
-     * @param {number | null} [group_by_index]
+     * Replace all rows in this [`Table`] with the input data, coerced to this
+     * [`Table`]'s existing [`perspective_client::Schema`], notifying any
+     * derived [`View`] and [`View::on_update`] callbacks.
+     *
+     * Calling [`Table::replace`] is an easy way to replace _all_ the data in a
+     * [`Table`] without losing any derived [`View`] instances or
+     * [`View::on_update`] callbacks. [`Table::replace`] does _not_ infer
+     * data types like [`Client::table`] does, rather it _coerces_ input
+     * data to the `Schema` like [`Table::update`]. If you need a [`Table`]
+     * with a different `Schema`, you must create a new one.
+     *
+     * # JavaScript Examples
+     *
+     * ```javascript
+     * await table.replace("x,y\n1,2");
+     * ```
+     * @param {any} input
+     * @param {UpdateOptions | null} [options]
+     * @returns {Promise<void>}
      */
-    setDatetimeCol(name, index, val, group_by_index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.jsvirtualdataslice_setDatetimeCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
-            }
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    replace(input, options) {
+        const ret = wasm.table_replace(this.__wbg_ptr, addHeapObject(input), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
     }
-}
-if (Symbol.dispose) JsVirtualDataSlice.prototype[Symbol.dispose] = JsVirtualDataSlice.prototype.free;
-
-const JsVirtualServerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsvirtualserver_free(ptr >>> 0, 1));
-
-export class JsVirtualServer {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsVirtualServerFinalization.unregister(this);
-        return ptr;
+    /**
+     * Returns a table's [`Schema`], a mapping of column names to column types.
+     *
+     * The mapping of a [`Table`]'s column names to data types is referred to
+     * as a [`Schema`]. Each column has a unique name and a data type, one
+     * of:
+     *
+     * - `"boolean"` - A boolean type
+     * - `"date"` - A timesonze-agnostic date type (month/day/year)
+     * - `"datetime"` - A millisecond-precision datetime type in the UTC
+     *   timezone
+     * - `"float"` - A 64 bit float
+     * - `"integer"` - A signed 32 bit integer (the integer type supported by
+     *   JavaScript)
+     * - `"string"` - A [`String`] data type (encoded internally as a
+     *   _dictionary_)
+     *
+     * Note that all [`Table`] columns are _nullable_, regardless of the data
+     * type.
+     * @returns {Record<string, ColumnType>}
+     */
+    schema() {
+        const ret = wasm.table_schema(this.__wbg_ptr);
+        return takeObject(ret);
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsvirtualserver_free(ptr, 0);
+    /**
+     * Returns the number of rows in a [`Table`].
+     * @returns {Promise<number>}
+     */
+    size() {
+        const ret = wasm.table_size(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-     * @param {object} handler
+     * Updates the rows of this table and any derived [`View`] instances.
+     *
+     * Calling [`Table::update`] will trigger the [`View::on_update`] callbacks
+     * register to derived [`View`], and the call itself will not resolve until
+     * _all_ derived [`View`]'s are notified.
+     *
+     * When updating a [`Table`] with an `index`, [`Table::update`] supports
+     * partial updates, by omitting columns from the update data.
+     *
+     * # Arguments
+     *
+     * - `input` - The input data for this [`Table`]. The schema of a [`Table`]
+     *   is immutable after creation, so this method cannot be called with a
+     *   schema.
+     * - `options` - Options for this update step - see [`UpdateOptions`].
+     *
+     * # JavaScript Examples
+     *
+     * ```javascript
+     * await table.update("x,y\n1,2");
+     * ```
+     * @param {string | ArrayBuffer | Record<string, unknown[]> | Record<string, unknown>[] | Record<string, ColumnType>} input
+     * @param {UpdateOptions | null} [options]
+     * @returns {Promise<any>}
      */
-    constructor(handler) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.jsvirtualserver_new(retptr, addHeapObject(handler));
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            this.__wbg_ptr = r0 >>> 0;
-            JsVirtualServerFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    update(input, options) {
+        const ret = wasm.table_update(this.__wbg_ptr, addHeapObject(input), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
     }
     /**
-     * @param {Uint8Array} bytes
+     * Validates the given expressions.
+     * @param {any} exprs
      * @returns {Promise<any>}
      */
-    handleRequest(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jsvirtualserver_handleRequest(this.__wbg_ptr, ptr0, len0);
+    validate_expressions(exprs) {
+        const ret = wasm.table_validate_expressions(this.__wbg_ptr, addHeapObject(exprs));
+        return takeObject(ret);
+    }
+    /**
+     * Create a new [`View`] from this table with a specified
+     * [`ViewConfigUpdate`].
+     *
+     * See [`View`] struct.
+     *
+     * # JavaScript Examples
+     *
+     * ```javascript
+     * const view = await table.view({
+     *     columns: ["Sales"],
+     *     aggregates: { Sales: "sum" },
+     *     group_by: ["Region", "Country"],
+     *     filter: [["Category", "in", ["Furniture", "Technology"]]],
+     * });
+     * ```
+     * @param {ViewConfigUpdate | null} [config]
+     * @returns {Promise<View>}
+     */
+    view(config) {
+        const ret = wasm.table_view(this.__wbg_ptr, isLikeNone(config) ? 0 : addHeapObject(config));
         return takeObject(ret);
     }
 }
-if (Symbol.dispose) JsVirtualServer.prototype[Symbol.dispose] = JsVirtualServer.prototype.free;
-
-const ProxySessionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_proxysession_free(ptr >>> 0, 1));
-
-export class ProxySession {
+if (Symbol.dispose) Table.prototype[Symbol.dispose] = Table.prototype.free;
 
+/**
+ * The [`View`] struct is Perspective's query and serialization interface. It
+ * represents a query on the `Table`'s dataset and is always created from an
+ * existing `Table` instance via the [`Table::view`] method.
+ *
+ * [`View`]s are immutable with respect to the arguments provided to the
+ * [`Table::view`] method; to change these parameters, you must create a new
+ * [`View`] on the same [`Table`]. However, each [`View`] is _live_ with
+ * respect to the [`Table`]'s data, and will (within a conflation window)
+ * update with the latest state as its parent [`Table`] updates, including
+ * incrementally recalculating all aggregates, pivots, filters, etc. [`View`]
+ * query parameters are composable, in that each parameter works independently
+ * _and_ in conjunction with each other, and there is no limit to the number of
+ * pivots, filters, etc. which can be applied.
+ */
+export class View {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ProxySession.prototype);
+        const obj = Object.create(View.prototype);
         obj.__wbg_ptr = ptr;
-        ProxySessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        ViewFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof View)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ProxySessionFinalization.unregister(this);
+        ViewFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_proxysession_free(ptr, 0);
+        wasm.__wbg_view_free(ptr, 0);
     }
     /**
-     * @param {Client} client
-     * @param {Function} on_response
+     * @returns {View}
      */
-    constructor(client, on_response) {
-        try {
-            _assertClass(client, Client);
-            const ret = wasm.client_new_proxy_session(client.__wbg_ptr, addBorrowedObject(on_response));
-            this.__wbg_ptr = ret >>> 0;
-            ProxySessionFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            heap[stack_pointer++] = undefined;
-        }
+    __get_model() {
+        const ret = wasm.view___get_model(this.__wbg_ptr);
+        return View.__wrap(ret);
     }
     /**
-     * @param {any} value
-     * @returns {Promise<void>}
+     * Collapses the `group_by` row at `row_index`.
+     * @param {number} row_index
+     * @returns {Promise<number>}
      */
-    handle_request(value) {
-        const ret = wasm.proxysession_handle_request(this.__wbg_ptr, addHeapObject(value));
+    collapse(row_index) {
+        const ret = wasm.view_collapse(this.__wbg_ptr, row_index);
+        return takeObject(ret);
+    }
+    /**
+     * Returns an array of strings containing the column paths of the [`View`]
+     * without any of the source columns.
+     *
+     * A column path shows the columns that a given cell belongs to after
+     * pivots are applied.
+     * @param {ColumnWindow | null} [window]
+     * @returns {Promise<any>}
+     */
+    column_paths(window) {
+        const ret = wasm.view_column_paths(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
     /**
+     * Delete this [`View`] and clean up all resources associated with it.
+     * [`View`] objects do not stop consuming resources or processing
+     * updates when they are garbage collected - you must call this method
+     * to reclaim these.
      * @returns {Promise<void>}
      */
-    close() {
+    delete() {
         const ptr = this.__destroy_into_raw();
-        const ret = wasm.proxysession_close(ptr);
+        const ret = wasm.view_delete(ptr);
         return takeObject(ret);
     }
-}
-if (Symbol.dispose) ProxySession.prototype[Symbol.dispose] = ProxySession.prototype.free;
-
-const TableFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_table_free(ptr >>> 0, 1));
-
-export class Table {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Table.prototype);
-        obj.__wbg_ptr = ptr;
-        TableFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TableFinalization.unregister(this);
-        return ptr;
+    /**
+     * Returns this [`View`]'s _dimensions_, row and column count, as well as
+     * those of the [`crate::Table`] from which it was derived.
+     *
+     * - `num_table_rows` - The number of rows in the underlying
+     *   [`crate::Table`].
+     * - `num_table_columns` - The number of columns in the underlying
+     *   [`crate::Table`] (including the `index` column if this
+     *   [`crate::Table`] was constructed with one).
+     * - `num_view_rows` - The number of rows in this [`View`]. If this
+     *   [`View`] has a `group_by` clause, `num_view_rows` will also include
+     *   aggregated rows.
+     * - `num_view_columns` - The number of columns in this [`View`]. If this
+     *   [`View`] has a `split_by` clause, `num_view_columns` will include all
+     *   _column paths_, e.g. the number of `columns` clause times the number
+     *   of `split_by` groups.
+     * @returns {Promise<any>}
+     */
+    dimensions() {
+        const ret = wasm.view_dimensions(this.__wbg_ptr);
+        return takeObject(ret);
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_table_free(ptr, 0);
+    /**
+     * Expand the `group_by` row at `row_index`.
+     * @param {number} row_index
+     * @returns {Promise<number>}
+     */
+    expand(row_index) {
+        const ret = wasm.view_expand(this.__wbg_ptr, row_index);
+        return takeObject(ret);
     }
     /**
-     * @returns {string}
+     * The expression schema of this [`View`], which contains only the
+     * expressions created on this [`View`]. See [`View::schema`] for
+     * details.
+     * @returns {Promise<any>}
      */
-    __getClassname() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.table___getClassname(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getCachedStringFromWasm0(r0, r1);
-            if (r0 !== 0) { wasm.__wbindgen_export4(r0, r1, 1); }
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    expression_schema() {
+        const ret = wasm.view_expression_schema(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-     * Returns the name of the index column for the table.
-     *
-     * # JavaScript Examples
-     *
-     * ```javascript
-     * const table = await client.table("x,y\n1,2\n3,4", { index: "x" });
-     * const index = table.get_index(); // "x"
-     * ```
-     * @returns {Promise<string>}
+     * A copy of the config object passed to the [`Table::view`] method which
+     * created this [`View`].
+     * @returns {Promise<any>}
      */
-    get_index() {
-        const ret = wasm.table_get_index(this.__wbg_ptr);
+    get_config() {
+        const ret = wasm.view_get_config(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * Get a copy of the [`Client`] this [`Table`] came from.
-     * @returns {Promise<Client>}
+     * Calculates the [min, max] of the leaf nodes of a column `column_name`.
+     *
+     * # Returns
+     *
+     * A tuple of [min, max], whose types are column and aggregate dependent.
+     * @param {string} name
+     * @returns {Promise<Array<any>>}
      */
-    get_client() {
-        const ret = wasm.table_get_client(this.__wbg_ptr);
+    get_min_max(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.view_get_min_max(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
-     * Returns the user-specified name for this table, or the auto-generated
-     * name if a name was not specified when the table was created.
-     * @returns {Promise<string>}
+     * The number of aggregated columns in this [`View`]. This is affected by
+     * the "split_by" configuration parameter supplied to this view's
+     * contructor.
+     *
+     * # Returns
+     *
+     * The number of aggregated columns.
+     * @returns {Promise<number>}
      */
-    get_name() {
-        const ret = wasm.table_get_name(this.__wbg_ptr);
+    num_columns() {
+        const ret = wasm.view_num_columns(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * Returns the user-specified row limit for this table.
-     * @returns {Promise<number | undefined>}
+     * The number of aggregated rows in this [`View`]. This is affected by the
+     * "group_by" configuration parameter supplied to this view's contructor.
+     *
+     * # Returns
+     *
+     * The number of aggregated rows.
+     * @returns {Promise<number>}
      */
-    get_limit() {
-        const ret = wasm.table_get_limit(this.__wbg_ptr);
+    num_rows() {
+        const ret = wasm.view_num_rows(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * Removes all the rows in the [`Table`], but preserves everything else
-     * including the schema, index, and any callbacks or registered
-     * [`View`] instances.
-     *
-     * Calling [`Table::clear`], like [`Table::update`] and [`Table::remove`],
-     * will trigger an update event to any registered listeners via
-     * [`View::on_update`].
-     * @returns {Promise<void>}
+     * Register a callback with this [`View`]. Whenever the [`View`] is
+     * deleted, this callback will be invoked.
+     * @param {Function} on_delete
+     * @returns {Promise<any>}
      */
-    clear() {
-        const ret = wasm.table_clear(this.__wbg_ptr);
+    on_delete(on_delete) {
+        const ret = wasm.view_on_delete(this.__wbg_ptr, addHeapObject(on_delete));
         return takeObject(ret);
     }
     /**
-     * Delete this [`Table`] and cleans up associated resources.
-     *
-     * [`Table`]s do not stop consuming resources or processing updates when
-     * they are garbage collected in their host language - you must call
-     * this method to reclaim these.
+     * Register a callback with this [`View`]. Whenever the view's underlying
+     * table emits an update, this callback will be invoked with an object
+     * containing `port_id`, indicating which port the update fired on, and
+     * optionally `delta`, which is the new data that was updated for each
+     * cell or each row.
      *
      * # Arguments
      *
-     * - `options` An options dictionary.
-     *     - `lazy` Whether to delete this [`Table`] _lazily_. When false (the
-     *       default), the delete will occur immediately, assuming it has no
-     *       [`View`] instances registered to it (which must be deleted first,
-     *       otherwise this method will throw an error). When true, the
-     *       [`Table`] will only be marked for deltion once its [`View`]
-     *       dependency count reaches 0.
+     * - `on_update` - A callback function invoked on update, which receives an
+     *   object with two keys: `port_id`, indicating which port the update was
+     *   triggered on, and `delta`, whose value is dependent on the mode
+     *   parameter.
+     * - `options` - If this is provided as `OnUpdateOptions { mode:
+     *   Some(OnUpdateMode::Row) }`, then `delta` is an Arrow of the updated
+     *   rows. Otherwise `delta` will be [`Option::None`].
      *
      * # JavaScript Examples
      *
      * ```javascript
-     * const table = await client.table("x,y\n1,2\n3,4");
-     *
-     * // ...
+     * // Attach an `on_update` callback
+     * view.on_update((updated) => console.log(updated.port_id));
+     * ```
      *
-     * await table.delete({ lazy: true });
+     * ```javascript
+     * // `on_update` with row deltas
+     * view.on_update((updated) => console.log(updated.delta), { mode: "row" });
      * ```
-     * @param {DeleteOptions | null} [options]
-     * @returns {Promise<void>}
+     * @param {Function} on_update_js
+     * @param {OnUpdateOptions | null} [options]
+     * @returns {Promise<any>}
      */
-    delete(options) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.table_delete(ptr, isLikeNone(options) ? 0 : addHeapObject(options));
+    on_update(on_update_js, options) {
+        const ret = wasm.view_on_update(this.__wbg_ptr, addHeapObject(on_update_js), isLikeNone(options) ? 0 : addHeapObject(options));
         return takeObject(ret);
     }
     /**
-     * Returns the number of rows in a [`Table`].
-     * @returns {Promise<number>}
+     * Unregister a previously registered [`View::on_delete`] callback.
+     * @param {number} callback_id
+     * @returns {Promise<any>}
      */
-    size() {
-        const ret = wasm.table_size(this.__wbg_ptr);
+    remove_delete(callback_id) {
+        const ret = wasm.view_remove_delete(this.__wbg_ptr, callback_id);
         return takeObject(ret);
     }
     /**
-     * Returns a table's [`Schema`], a mapping of column names to column types.
-     *
-     * The mapping of a [`Table`]'s column names to data types is referred to
-     * as a [`Schema`]. Each column has a unique name and a data type, one
-     * of:
+     * Unregister a previously registered update callback with this [`View`].
      *
-     * - `"boolean"` - A boolean type
-     * - `"date"` - A timesonze-agnostic date type (month/day/year)
-     * - `"datetime"` - A millisecond-precision datetime type in the UTC
-     *   timezone
-     * - `"float"` - A 64 bit float
-     * - `"integer"` - A signed 32 bit integer (the integer type supported by
-     *   JavaScript)
-     * - `"string"` - A [`String`] data type (encoded internally as a
-     *   _dictionary_)
+     * # Arguments
      *
-     * Note that all [`Table`] columns are _nullable_, regardless of the data
-     * type.
-     * @returns {Record<string, ColumnType>}
+     * - `id` - A callback `id` as returned by a recipricol call to
+     *   [`View::on_update`].
+     * @param {number} callback_id
+     * @returns {Promise<void>}
      */
-    schema() {
-        const ret = wasm.table_schema(this.__wbg_ptr);
+    remove_update(callback_id) {
+        const ret = wasm.view_remove_update(this.__wbg_ptr, callback_id);
         return takeObject(ret);
     }
     /**
-     * Returns the column names of this [`Table`] in "natural" order (the
-     * ordering implied by the input format).
-     *
-     *  # JavaScript Examples
+     * The schema of this [`View`].
      *
-     *  ```javascript
-     *  const columns = await table.columns();
-     *  ```
+     * The [`View`] schema differs from the `schema` returned by
+     * [`Table::schema`]; it may have different column names due to
+     * `expressions` or `columns` configs, or it maye have _different
+     * column types_ due to the application og `group_by` and `aggregates`
+     * config. You can think of [`Table::schema`] as the _input_ schema and
+     * [`View::schema`] as the _output_ schema of a Perspective pipeline.
      * @returns {Promise<any>}
      */
-    columns() {
-        const ret = wasm.table_columns(this.__wbg_ptr);
+    schema() {
+        const ret = wasm.view_schema(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-     * Create a unique channel ID on this [`Table`], which allows
-     * `View::on_update` callback calls to be associated with the
-     * `Table::update` which caused them.
-     * @returns {Promise<number>}
+     * Set expansion `depth` of the `group_by` tree.
+     * @param {number} depth
+     * @returns {Promise<void>}
      */
-    make_port() {
-        const ret = wasm.table_make_port(this.__wbg_ptr);
+    set_depth(depth) {
+        const ret = wasm.view_set_depth(this.__wbg_ptr, depth);
         return takeObject(ret);
     }
     /**
-     * Register a callback which is called exactly once, when this [`Table`] is
-     * deleted with the [`Table::delete`] method.
-     *
-     * [`Table::on_delete`] resolves when the subscription message is sent, not
-     * when the _delete_ event occurs.
-     * @param {Function} on_delete
-     * @returns {Promise<any>}
+     * Serializes a [`View`] to the Apache Arrow data format.
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<ArrayBuffer>}
      */
-    on_delete(on_delete) {
-        const ret = wasm.table_on_delete(this.__wbg_ptr, addHeapObject(on_delete));
+    to_arrow(window) {
+        const ret = wasm.view_to_arrow(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
     /**
-     * Removes a listener with a given ID, as returned by a previous call to
-     * [`Table::on_delete`].
-     * @param {number} callback_id
-     * @returns {Promise<any>}
+     * Serializes this [`View`] to JavaScript objects in a column-oriented
+     * format.
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<object>}
      */
-    remove_delete(callback_id) {
-        const ret = wasm.table_remove_delete(this.__wbg_ptr, callback_id);
+    to_columns(window) {
+        const ret = wasm.view_to_columns(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
     /**
-     * Removes rows from this [`Table`] with the `index` column values
-     * supplied.
-     *
-     * # Arguments
-     *
-     * - `indices` - A list of `index` column values for rows that should be
-     *   removed.
-     *
-     * # JavaScript Examples
-     *
-     * ```javascript
-     * await table.remove([1, 2, 3]);
-     * ```
-     * @param {any} value
-     * @param {UpdateOptions | null} [options]
-     * @returns {Promise<void>}
+     * Serializes this [`View`] to a string of JSON data. Useful if you want to
+     * save additional round trip serialize/deserialize cycles.
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<string>}
      */
-    remove(value, options) {
-        const ret = wasm.table_remove(this.__wbg_ptr, addHeapObject(value), isLikeNone(options) ? 0 : addHeapObject(options));
+    to_columns_string(window) {
+        const ret = wasm.view_to_columns_string(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
-    }
-    /**
-     * Replace all rows in this [`Table`] with the input data, coerced to this
-     * [`Table`]'s existing [`perspective_client::Schema`], notifying any
-     * derived [`View`] and [`View::on_update`] callbacks.
-     *
-     * Calling [`Table::replace`] is an easy way to replace _all_ the data in a
-     * [`Table`] without losing any derived [`View`] instances or
-     * [`View::on_update`] callbacks. [`Table::replace`] does _not_ infer
-     * data types like [`Client::table`] does, rather it _coerces_ input
-     * data to the `Schema` like [`Table::update`]. If you need a [`Table`]
-     * with a different `Schema`, you must create a new one.
-     *
-     * # JavaScript Examples
-     *
-     * ```javascript
-     * await table.replace("x,y\n1,2");
-     * ```
-     * @param {any} input
-     * @param {UpdateOptions | null} [options]
-     * @returns {Promise<void>}
+    }
+    /**
+     * Serializes this [`View`] to CSV data in a standard format.
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<string>}
      */
-    replace(input, options) {
-        const ret = wasm.table_replace(this.__wbg_ptr, addHeapObject(input), isLikeNone(options) ? 0 : addHeapObject(options));
+    to_csv(window) {
+        const ret = wasm.view_to_csv(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
     /**
-     * Updates the rows of this table and any derived [`View`] instances.
-     *
-     * Calling [`Table::update`] will trigger the [`View::on_update`] callbacks
-     * register to derived [`View`], and the call itself will not resolve until
-     * _all_ derived [`View`]'s are notified.
-     *
-     * When updating a [`Table`] with an `index`, [`Table::update`] supports
-     * partial updates, by omitting columns from the update data.
-     *
-     * # Arguments
-     *
-     * - `input` - The input data for this [`Table`]. The schema of a [`Table`]
-     *   is immutable after creation, so this method cannot be called with a
-     *   schema.
-     * - `options` - Options for this update step - see [`UpdateOptions`].
-     *
-     * # JavaScript Examples
-     *
-     * ```javascript
-     * await table.update("x,y\n1,2");
-     * ```
-     * @param {string | ArrayBuffer | Record<string, unknown[]> | Record<string, unknown>[] | Record<string, ColumnType>} input
-     * @param {UpdateOptions | null} [options]
-     * @returns {Promise<any>}
+     * Serializes this [`View`] to JavaScript objects in a row-oriented
+     * format.
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<Array<any>>}
      */
-    update(input, options) {
-        const ret = wasm.table_update(this.__wbg_ptr, addHeapObject(input), isLikeNone(options) ? 0 : addHeapObject(options));
+    to_json(window) {
+        const ret = wasm.view_to_json(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
     /**
-     * Create a new [`View`] from this table with a specified
-     * [`ViewConfigUpdate`].
-     *
-     * See [`View`] struct.
-     *
-     * # JavaScript Examples
-     *
-     * ```javascript
-     * const view = await table.view({
-     *     columns: ["Sales"],
-     *     aggregates: { Sales: "sum" },
-     *     group_by: ["Region", "Country"],
-     *     filter: [["Category", "in", ["Furniture", "Technology"]]],
-     * });
-     * ```
-     * @param {ViewConfigUpdate | null} [config]
-     * @returns {Promise<View>}
+     * Render this `View` as a JSON string.
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<string>}
      */
-    view(config) {
-        const ret = wasm.table_view(this.__wbg_ptr, isLikeNone(config) ? 0 : addHeapObject(config));
+    to_json_string(window) {
+        const ret = wasm.view_to_json_string(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
     /**
-     * Validates the given expressions.
-     * @param {any} exprs
-     * @returns {Promise<any>}
+     * Renders this [`View`] as an [NDJSON](https://github.com/ndjson/ndjson-spec)
+     * formatted [`String`].
+     * @param {ViewWindow | null} [window]
+     * @returns {Promise<string>}
      */
-    validate_expressions(exprs) {
-        const ret = wasm.table_validate_expressions(this.__wbg_ptr, addHeapObject(exprs));
+    to_ndjson(window) {
+        const ret = wasm.view_to_ndjson(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
         return takeObject(ret);
     }
 }
-if (Symbol.dispose) Table.prototype[Symbol.dispose] = Table.prototype.free;
-
-const ViewFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_view_free(ptr >>> 0, 1));
-/**
- * The [`View`] struct is Perspective's query and serialization interface. It
- * represents a query on the `Table`'s dataset and is always created from an
- * existing `Table` instance via the [`Table::view`] method.
- *
- * [`View`]s are immutable with respect to the arguments provided to the
- * [`Table::view`] method; to change these parameters, you must create a new
- * [`View`] on the same [`Table`]. However, each [`View`] is _live_ with
- * respect to the [`Table`]'s data, and will (within a conflation window)
- * update with the latest state as its parent [`Table`] updates, including
- * incrementally recalculating all aggregates, pivots, filters, etc. [`View`]
- * query parameters are composable, in that each parameter works independently
- * _and_ in conjunction with each other, and there is no limit to the number of
- * pivots, filters, etc. which can be applied.
- */
-export class View {
+if (Symbol.dispose) View.prototype[Symbol.dispose] = View.prototype.free;
 
+export class VirtualDataSlice {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(View.prototype);
+        const obj = Object.create(VirtualDataSlice.prototype);
         obj.__wbg_ptr = ptr;
-        ViewFinalization.register(obj, obj.__wbg_ptr, obj);
+        VirtualDataSliceFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof View)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ViewFinalization.unregister(this);
+        VirtualDataSliceFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_view_free(ptr, 0);
+        wasm.__wbg_virtualdataslice_free(ptr, 0);
     }
     /**
-     * @returns {View}
+     * @param {ViewConfigUpdate} config
      */
-    __get_model() {
-        const ret = wasm.view___get_model(this.__wbg_ptr);
-        return View.__wrap(ret);
+    constructor(config) {
+        const ret = wasm.virtualdataslice_new(addHeapObject(config));
+        this.__wbg_ptr = ret >>> 0;
+        VirtualDataSliceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Returns an array of strings containing the column paths of the [`View`]
-     * without any of the source columns.
-     *
-     * A column path shows the columns that a given cell belongs to after
-     * pivots are applied.
-     * @param {ColumnWindow | null} [window]
-     * @returns {Promise<any>}
+     * @param {string} name
+     * @param {number} index
+     * @param {any} val
+     * @param {number | null} [group_by_index]
      */
-    column_paths(window) {
-        const ret = wasm.view_column_paths(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+    setBooleanCol(name, index, val, group_by_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.virtualdataslice_setBooleanCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Delete this [`View`] and clean up all resources associated with it.
-     * [`View`] objects do not stop consuming resources or processing
-     * updates when they are garbage collected - you must call this method
-     * to reclaim these.
-     * @returns {Promise<void>}
+     * @param {string} dtype
+     * @param {string} name
+     * @param {number} index
+     * @param {any} val
+     * @param {number | null} [group_by_index]
      */
-    delete() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.view_delete(ptr);
-        return takeObject(ret);
+    setCol(dtype, name, index, val, group_by_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(dtype, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.virtualdataslice_setCol(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Returns this [`View`]'s _dimensions_, row and column count, as well as
-     * those of the [`crate::Table`] from which it was derived.
-     *
-     * - `num_table_rows` - The number of rows in the underlying
-     *   [`crate::Table`].
-     * - `num_table_columns` - The number of columns in the underlying
-     *   [`crate::Table`] (including the `index` column if this
-     *   [`crate::Table`] was constructed with one).
-     * - `num_view_rows` - The number of rows in this [`View`]. If this
-     *   [`View`] has a `group_by` clause, `num_view_rows` will also include
-     *   aggregated rows.
-     * - `num_view_columns` - The number of columns in this [`View`]. If this
-     *   [`View`] has a `split_by` clause, `num_view_columns` will include all
-     *   _column paths_, e.g. the number of `columns` clause times the number
-     *   of `split_by` groups.
-     * @returns {Promise<any>}
+     * @param {string} name
+     * @param {number} index
+     * @param {any} val
+     * @param {number | null} [group_by_index]
      */
-    dimensions() {
-        const ret = wasm.view_dimensions(this.__wbg_ptr);
-        return takeObject(ret);
+    setDatetimeCol(name, index, val, group_by_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.virtualdataslice_setDatetimeCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * The expression schema of this [`View`], which contains only the
-     * expressions created on this [`View`]. See [`View::schema`] for
-     * details.
-     * @returns {Promise<any>}
+     * @param {string} name
+     * @param {number} index
+     * @param {any} val
+     * @param {number | null} [group_by_index]
      */
-    expression_schema() {
-        const ret = wasm.view_expression_schema(this.__wbg_ptr);
-        return takeObject(ret);
+    setFloatCol(name, index, val, group_by_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.virtualdataslice_setFloatCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * A copy of the config object passed to the [`Table::view`] method which
-     * created this [`View`].
-     * @returns {Promise<any>}
+     * @param {string} name
+     * @param {number} index
+     * @param {any} val
+     * @param {number | null} [group_by_index]
      */
-    get_config() {
-        const ret = wasm.view_get_config(this.__wbg_ptr);
-        return takeObject(ret);
+    setIntegerCol(name, index, val, group_by_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.virtualdataslice_setIntegerCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Calculates the [min, max] of the leaf nodes of a column `column_name`.
-     *
-     * # Returns
-     *
-     * A tuple of [min, max], whose types are column and aggregate dependent.
      * @param {string} name
-     * @returns {Promise<Array<any>>}
+     * @param {number} index
+     * @param {any} val
+     * @param {number | null} [group_by_index]
      */
-    get_min_max(name) {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.view_get_min_max(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+    setStringCol(name, index, val, group_by_index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.virtualdataslice_setStringCol(retptr, this.__wbg_ptr, ptr0, len0, index, addHeapObject(val), isLikeNone(group_by_index) ? 0x100000001 : (group_by_index) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
-    /**
-     * The number of aggregated rows in this [`View`]. This is affected by the
-     * "group_by" configuration parameter supplied to this view's contructor.
-     *
-     * # Returns
-     *
-     * The number of aggregated rows.
-     * @returns {Promise<number>}
-     */
-    num_rows() {
-        const ret = wasm.view_num_rows(this.__wbg_ptr);
-        return takeObject(ret);
+}
+if (Symbol.dispose) VirtualDataSlice.prototype[Symbol.dispose] = VirtualDataSlice.prototype.free;
+
+export class VirtualServer {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VirtualServerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_virtualserver_free(ptr, 0);
     }
     /**
-     * The schema of this [`View`].
-     *
-     * The [`View`] schema differs from the `schema` returned by
-     * [`Table::schema`]; it may have different column names due to
-     * `expressions` or `columns` configs, or it maye have _different
-     * column types_ due to the application og `group_by` and `aggregates`
-     * config. You can think of [`Table::schema`] as the _input_ schema and
-     * [`View::schema`] as the _output_ schema of a Perspective pipeline.
+     * @param {Uint8Array} bytes
      * @returns {Promise<any>}
      */
-    schema() {
-        const ret = wasm.view_schema(this.__wbg_ptr);
+    handleRequest(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.virtualserver_handleRequest(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
-     * Serializes a [`View`] to the Apache Arrow data format.
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<ArrayBuffer>}
+     * @param {object} handler
      */
-    to_arrow(window) {
-        const ret = wasm.view_to_arrow(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+    constructor(handler) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.virtualserver_new(retptr, addHeapObject(handler));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            VirtualServerFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
-    /**
-     * Serializes this [`View`] to a string of JSON data. Useful if you want to
-     * save additional round trip serialize/deserialize cycles.
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<string>}
-     */
-    to_columns_string(window) {
-        const ret = wasm.view_to_columns_string(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+}
+if (Symbol.dispose) VirtualServer.prototype[Symbol.dispose] = VirtualServer.prototype.free;
+
+export function init() {
+    wasm.init();
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+            var v0 = getCachedStringFromWasm0(arg0, arg1);
+            const ret = Error(v0);
+            return addHeapObject(ret);
+        },
+        __wbg_Number_04624de7d0e8332d: function(arg0) {
+            const ret = Number(getObject(arg0));
+            return ret;
+        },
+        __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
+            const v = getObject(arg1);
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
+            const ret = getObject(arg0) in getObject(arg1);
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_ac34f5003991759a: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_11888390b0186270: function(arg0, arg1) {
+            const ret = getObject(arg0) === getObject(arg1);
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+            const ret = getObject(arg0) == getObject(arg1);
+            return ret;
+        },
+        __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            var v0 = getCachedStringFromWasm0(arg0, arg1);
+            throw new Error(v0);
+        },
+        __wbg__wbg_cb_unref_d9b87ff7982e3b21: function(arg0) {
+            getObject(arg0)._wbg_cb_unref();
+        },
+        __wbg_apply_ada2ee1a60ac7b3c: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_at_dfc235641cc0e40c: function(arg0, arg1) {
+            const ret = getObject(arg0).at(arg1);
+            return addHeapObject(ret);
+        },
+        __wbg_buffer_26d0910f3a5bc899: function(arg0) {
+            const ret = getObject(arg0).buffer;
+            return addHeapObject(ret);
+        },
+        __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).call(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_4708e0c13bdc8e95: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_812d25f1510c13c8: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_client_new: function(arg0) {
+            const ret = Client.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_debug_46a93995fc6f8820: function(arg0, arg1, arg2, arg3) {
+            console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+        },
+        __wbg_debug_a4099fa12db6cd61: function(arg0) {
+            console.debug(getObject(arg0));
+        },
+        __wbg_done_57b39ecd9addfe81: function(arg0) {
+            const ret = getObject(arg0).done;
+            return ret;
+        },
+        __wbg_entries_58c7934c745daac7: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_error_794d0ffc9d00d5c3: function(arg0, arg1, arg2, arg3) {
+            console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+        },
+        __wbg_error_9a7fe3f932034cde: function(arg0) {
+            console.error(getObject(arg0));
+        },
+        __wbg_error_f852e41c69b0bd84: function(arg0, arg1) {
+            console.error(getObject(arg0), getObject(arg1));
+        },
+        __wbg_from_bddd64e7d5ff6941: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_getEntriesByName_02488cff0bc7581c: function(arg0, arg1, arg2, arg3, arg4) {
+            var v0 = getCachedStringFromWasm0(arg1, arg2);
+            var v1 = getCachedStringFromWasm0(arg3, arg4);
+            const ret = getObject(arg0).getEntriesByName(v0, v1);
+            return addHeapObject(ret);
+        },
+        __wbg_getRandomValues_1c61fac11405ffdc: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getTime_1e3cd1391c5c3995: function(arg0) {
+            const ret = getObject(arg0).getTime();
+            return ret;
+        },
+        __wbg_get_76e04509d1922a04: function(arg0, arg1, arg2) {
+            var v0 = getCachedStringFromWasm0(arg1, arg2);
+            const ret = getObject(arg0)[v0];
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_b3ed3ad4be2bc8ac: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_with_ref_key_1dc361bd10053bfe: function(arg0, arg1) {
+            const ret = getObject(arg0)[getObject(arg1)];
+            return addHeapObject(ret);
+        },
+        __wbg_has_d4e53238966c12b6: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.has(getObject(arg0), getObject(arg1));
+            return ret;
+        }, arguments); },
+        __wbg_info_148d043840582012: function(arg0) {
+            console.info(getObject(arg0));
+        },
+        __wbg_info_9e602cf10c5c690b: function(arg0, arg1, arg2, arg3) {
+            console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+        },
+        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Array_d9eac779cd191cbc: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Date_1b9f15b87f10aa4c: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Date;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Error_8573fe0b0b480f46: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_53af74335dec57f4: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Object_1c6af87502b733ed: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Object;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Promise_0094681e3519d6ec: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Window_ed49b2db8df90359: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Window;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_d314bb98fcf08331: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+            const ret = Number.isSafeInteger(getObject(arg0));
+            return ret;
+        },
+        __wbg_iterator_6ff6560ca1568e55: function() {
+            const ret = Symbol.iterator;
+            return addHeapObject(ret);
+        },
+        __wbg_keys_b50a709a76add04e: function(arg0) {
+            const ret = Object.keys(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_length_32ed9a279acd054c: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_35a7bace40f36eac: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_mark_3b530a64b09ba08a: function() { return handleError(function (arg0, arg1, arg2) {
+            var v0 = getCachedStringFromWasm0(arg1, arg2);
+            getObject(arg0).mark(v0);
+        }, arguments); },
+        __wbg_measure_288b48c082eae0fe: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            var v0 = getCachedStringFromWasm0(arg1, arg2);
+            var v1 = getCachedStringFromWasm0(arg3, arg4);
+            getObject(arg0).measure(v0, v1);
+        }, arguments); },
+        __wbg_message_9ddc4b9a62a7c379: function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        },
+        __wbg_new_361308b2356cecd0: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_3eb36ae241fe6f44: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_72b49615380db768: function(arg0, arg1) {
+            var v0 = getCachedStringFromWasm0(arg0, arg1);
+            const ret = new Error(v0);
+            return addHeapObject(ret);
+        },
+        __wbg_new_b5d9e2fb389fef91: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_5384(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = state0.b = 0;
+            }
+        },
+        __wbg_new_dca287b076112a51: function() {
+            const ret = new Map();
+            return addHeapObject(ret);
+        },
+        __wbg_new_dd2b680c8bf6ae29: function(arg0) {
+            const ret = new Uint8Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_a3d2629dc1826784: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+            var v0 = getCachedStringFromWasm0(arg0, arg1);
+            const ret = new Function(v0);
+            return addHeapObject(ret);
+        },
+        __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_next_418f80d8f5303233: function(arg0) {
+            const ret = getObject(arg0).next;
+            return addHeapObject(ret);
+        },
+        __wbg_now_ebffdf7e580f210d: function(arg0) {
+            const ret = getObject(arg0).now();
+            return ret;
+        },
+        __wbg_parse_708461a1feddfb38: function() { return handleError(function (arg0, arg1) {
+            var v0 = getCachedStringFromWasm0(arg0, arg1);
+            const ret = JSON.parse(v0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_performance_06f12ba62483475d: function(arg0) {
+            const ret = getObject(arg0).performance;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_push_8ffdcb2063340ba5: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
+        __wbg_queueMicrotask_0aa0a927f78f5d98: function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        },
+        __wbg_queueMicrotask_5bb536982f78a56f: function(arg0) {
+            queueMicrotask(getObject(arg0));
+        },
+        __wbg_reject_a2176de7f1212be5: function(arg0) {
+            const ret = Promise.reject(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_resolve_002c4b7d9d8f6b64: function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_set_1eb0999cf5d27fc8: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+        },
+        __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+        },
+        __wbg_startTime_248495bfbcb427d3: function(arg0) {
+            const ret = getObject(arg0).startTime;
+            return ret;
+        },
+        __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_stringify_8d1cc6ff383e8bae: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_table_new: function(arg0) {
+            const ret = Table.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_then_0d9fe2c7b1857d32: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_then_b9e7b3b5f1a9e1b5: function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_toString_964ff7fe6eca8362: function(arg0) {
+            const ret = getObject(arg0).toString();
+            return addHeapObject(ret);
+        },
+        __wbg_trace_9007714a6fbee374: function(arg0) {
+            console.trace(getObject(arg0));
+        },
+        __wbg_trace_bd16b570941b54fb: function(arg0, arg1, arg2, arg3) {
+            console.trace(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+        },
+        __wbg_value_0546255b415e96c1: function(arg0) {
+            const ret = getObject(arg0).value;
+            return addHeapObject(ret);
+        },
+        __wbg_values_5da93bc719d272cf: function(arg0) {
+            const ret = Object.values(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_view_new: function(arg0) {
+            const ret = View.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_view_unwrap: function(arg0) {
+            const ret = View.__unwrap(getObject(arg0));
+            return ret;
+        },
+        __wbg_virtualdataslice_new: function(arg0) {
+            const ret = VirtualDataSlice.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_warn_a40b971467b219c7: function(arg0, arg1, arg2, arg3) {
+            console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+        },
+        __wbg_warn_f7ae1b2e66ccb930: function(arg0) {
+            console.warn(getObject(arg0));
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 13, function: Function { arguments: [], shim_idx: 30, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1421, __wasm_bindgen_func_elem_1668);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 551, function: Function { arguments: [Externref], shim_idx: 552, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3793, __wasm_bindgen_func_elem_3795);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            var v0 = getCachedStringFromWasm0(arg0, arg1);
+            // Cast intrinsic for `Ref(CachedString) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000007: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+            var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
+            // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+            var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
+            // Cast intrinsic for `Vector(U8) -> Externref`.
+            const ret = v0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./perspective-js.wasm_bg.js": import0,
+    };
+}
+
+function __wasm_bindgen_func_elem_1668(arg0, arg1) {
+    const ret = wasm.__wasm_bindgen_func_elem_1668(arg0, arg1);
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_3795(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_3795(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_5384(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_5384(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const ClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_client_free(ptr >>> 0, 1));
+const GenericSQLVirtualServerModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_genericsqlvirtualservermodel_free(ptr >>> 0, 1));
+const ProxySessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_proxysession_free(ptr >>> 0, 1));
+const TableFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_table_free(ptr >>> 0, 1));
+const ViewFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_view_free(ptr >>> 0, 1));
+const VirtualDataSliceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_virtualdataslice_free(ptr >>> 0, 1));
+const VirtualServerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_virtualserver_free(ptr >>> 0, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
     }
-    /**
-     * Serializes this [`View`] to JavaScript objects in a column-oriented
-     * format.
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<object>}
-     */
-    to_columns(window) {
-        const ret = wasm.view_to_columns(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+}
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
     }
-    /**
-     * Render this `View` as a JSON string.
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<string>}
-     */
-    to_json_string(window) {
-        const ret = wasm.view_to_json_string(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
     }
-    /**
-     * Serializes this [`View`] to JavaScript objects in a row-oriented
-     * format.
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<Array<any>>}
-     */
-    to_json(window) {
-        const ret = wasm.view_to_json(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
     }
-    /**
-     * Renders this [`View`] as an [NDJSON](https://github.com/ndjson/ndjson-spec)
-     * formatted [`String`].
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<string>}
-     */
-    to_ndjson(window) {
-        const ret = wasm.view_to_ndjson(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
     }
-    /**
-     * Serializes this [`View`] to CSV data in a standard format.
-     * @param {ViewWindow | null} [window]
-     * @returns {Promise<string>}
-     */
-    to_csv(window) {
-        const ret = wasm.view_to_csv(this.__wbg_ptr, isLikeNone(window) ? 0 : addHeapObject(window));
-        return takeObject(ret);
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
     }
-    /**
-     * Register a callback with this [`View`]. Whenever the view's underlying
-     * table emits an update, this callback will be invoked with an object
-     * containing `port_id`, indicating which port the update fired on, and
-     * optionally `delta`, which is the new data that was updated for each
-     * cell or each row.
-     *
-     * # Arguments
-     *
-     * - `on_update` - A callback function invoked on update, which receives an
-     *   object with two keys: `port_id`, indicating which port the update was
-     *   triggered on, and `delta`, whose value is dependent on the mode
-     *   parameter.
-     * - `options` - If this is provided as `OnUpdateOptions { mode:
-     *   Some(OnUpdateMode::Row) }`, then `delta` is an Arrow of the updated
-     *   rows. Otherwise `delta` will be [`Option::None`].
-     *
-     * # JavaScript Examples
-     *
-     * ```javascript
-     * // Attach an `on_update` callback
-     * view.on_update((updated) => console.log(updated.port_id));
-     * ```
-     *
-     * ```javascript
-     * // `on_update` with row deltas
-     * view.on_update((updated) => console.log(updated.delta), { mode: "row" });
-     * ```
-     * @param {Function} on_update_js
-     * @param {OnUpdateOptions | null} [options]
-     * @returns {Promise<any>}
-     */
-    on_update(on_update_js, options) {
-        const ret = wasm.view_on_update(this.__wbg_ptr, addHeapObject(on_update_js), isLikeNone(options) ? 0 : addHeapObject(options));
-        return takeObject(ret);
+    return result;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getCachedStringFromWasm0(ptr, len) {
+    if (ptr === 0) {
+        return getObject(len);
+    } else {
+        return getStringFromWasm0(ptr, len);
     }
-    /**
-     * Unregister a previously registered update callback with this [`View`].
-     *
-     * # Arguments
-     *
-     * - `id` - A callback `id` as returned by a recipricol call to
-     *   [`View::on_update`].
-     * @param {number} callback_id
-     * @returns {Promise<void>}
-     */
-    remove_update(callback_id) {
-        const ret = wasm.view_remove_update(this.__wbg_ptr, callback_id);
-        return takeObject(ret);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
     }
-    /**
-     * Register a callback with this [`View`]. Whenever the [`View`] is
-     * deleted, this callback will be invoked.
-     * @param {Function} on_delete
-     * @returns {Promise<any>}
-     */
-    on_delete(on_delete) {
-        const ret = wasm.view_on_delete(this.__wbg_ptr, addHeapObject(on_delete));
-        return takeObject(ret);
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
-    /**
-     * The number of aggregated columns in this [`View`]. This is affected by
-     * the "split_by" configuration parameter supplied to this view's
-     * contructor.
-     *
-     * # Returns
-     *
-     * The number of aggregated columns.
-     * @returns {Promise<number>}
-     */
-    num_columns() {
-        const ret = wasm.view_num_columns(this.__wbg_ptr);
-        return takeObject(ret);
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
     }
-    /**
-     * Unregister a previously registered [`View::on_delete`] callback.
-     * @param {number} callback_id
-     * @returns {Promise<any>}
-     */
-    remove_delete(callback_id) {
-        const ret = wasm.view_remove_delete(this.__wbg_ptr, callback_id);
-        return takeObject(ret);
+}
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        try {
+            return f(state.a, state.b, ...args);
+        } finally {
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
     }
-    /**
-     * Collapses the `group_by` row at `row_index`.
-     * @param {number} row_index
-     * @returns {Promise<number>}
-     */
-    collapse(row_index) {
-        const ret = wasm.view_collapse(this.__wbg_ptr, row_index);
-        return takeObject(ret);
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
     }
-    /**
-     * Expand the `group_by` row at `row_index`.
-     * @param {number} row_index
-     * @returns {Promise<number>}
-     */
-    expand(row_index) {
-        const ret = wasm.view_expand(this.__wbg_ptr, row_index);
-        return takeObject(ret);
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
-    /**
-     * Set expansion `depth` of the `group_by` tree.
-     * @param {number} depth
-     * @returns {Promise<void>}
-     */
-    set_depth(depth) {
-        const ret = wasm.view_set_depth(this.__wbg_ptr, depth);
-        return takeObject(ret);
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let stack_pointer = 128;
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
     }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
-if (Symbol.dispose) View.prototype[Symbol.dispose] = View.prototype.free;
 
-const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+const cachedTextEncoder = new TextEncoder();
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
-
             } catch (e) {
-                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+                const validResponse = module.ok && expectedResponseType(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
 
-                } else {
-                    throw e;
-                }
+                } else { throw e; }
             }
         }
 
         const bytes = await module.arrayBuffer();
         return await WebAssembly.instantiate(bytes, imports);
-
     } else {
         const instance = await WebAssembly.instantiate(module, imports);
 
         if (instance instanceof WebAssembly.Instance) {
             return { instance, module };
-
         } else {
             return instance;
         }
     }
-}
 
-function __wbg_get_imports() {
-    const imports = {};
-    imports.wbg = {};
-    imports.wbg.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
-        var v0 = getCachedStringFromWasm0(arg0, arg1);
-        const ret = Error(v0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_Number_bb48ca12f395cd08 = function(arg0) {
-        const ret = Number(getObject(arg0));
-        return ret;
-    };
-    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
-        const ret = String(getObject(arg1));
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    imports.wbg.__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd = function(arg0, arg1) {
-        const v = getObject(arg1);
-        const ret = typeof(v) === 'bigint' ? v : undefined;
-        getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-    };
-    imports.wbg.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {
-        const v = getObject(arg0);
-        const ret = typeof(v) === 'boolean' ? v : undefined;
-        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
-    };
-    imports.wbg.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
-        const ret = debugString(getObject(arg1));
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    imports.wbg.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {
-        const ret = getObject(arg0) in getObject(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_bigint_cb320707dcd35f0b = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'bigint';
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'function';
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_null_5e69f72e906cc57c = function(arg0) {
-        const ret = getObject(arg0) === null;
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {
-        const val = getObject(arg0);
-        const ret = typeof(val) === 'object' && val !== null;
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'string';
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
-        const ret = getObject(arg0) === undefined;
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_jsval_eq_6b13ab83478b1c50 = function(arg0, arg1) {
-        const ret = getObject(arg0) === getObject(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147 = function(arg0, arg1) {
-        const ret = getObject(arg0) == getObject(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
-        const obj = getObject(arg1);
-        const ret = typeof(obj) === 'number' ? obj : undefined;
-        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-    };
-    imports.wbg.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {
-        const obj = getObject(arg1);
-        const ret = typeof(obj) === 'string' ? obj : undefined;
-        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        var len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    imports.wbg.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
-        var v0 = getCachedStringFromWasm0(arg0, arg1);
-        throw new Error(v0);
-    };
-    imports.wbg.__wbg__wbg_cb_unref_2454a539ea5790d9 = function(arg0) {
-        getObject(arg0)._wbg_cb_unref();
-    };
-    imports.wbg.__wbg_apply_04097a755e1e4a1e = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_at_a848c0ce365c6832 = function(arg0, arg1) {
-        const ret = getObject(arg0).at(arg1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_buffer_ccc4520b36d3ccf4 = function(arg0) {
-        const ret = getObject(arg0).buffer;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_call_e45d2cf9fc925fcf = function() { return handleError(function (arg0, arg1, arg2, arg3) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).call(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_client_new = function(arg0) {
-        const ret = Client.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_debug_e55e1461940eb14d = function(arg0, arg1, arg2, arg3) {
-        console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
-    imports.wbg.__wbg_debug_f4b0c59db649db48 = function(arg0) {
-        console.debug(getObject(arg0));
-    };
-    imports.wbg.__wbg_done_2042aa2670fb1db1 = function(arg0) {
-        const ret = getObject(arg0).done;
-        return ret;
-    };
-    imports.wbg.__wbg_entries_e171b586f8f6bdbf = function(arg0) {
-        const ret = Object.entries(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_error_6f1d0762f6c8ae2f = function(arg0, arg1) {
-        console.error(getObject(arg0), getObject(arg1));
-    };
-    imports.wbg.__wbg_error_a7f8fbb0523dae15 = function(arg0) {
-        console.error(getObject(arg0));
-    };
-    imports.wbg.__wbg_error_d8b22cf4e59a6791 = function(arg0, arg1, arg2, arg3) {
-        console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
-    imports.wbg.__wbg_from_a4ad7cbddd0d7135 = function(arg0) {
-        const ret = Array.from(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getEntriesByName_b49d266abfb2e9af = function(arg0, arg1, arg2, arg3, arg4) {
-        var v0 = getCachedStringFromWasm0(arg1, arg2);
-        var v1 = getCachedStringFromWasm0(arg3, arg4);
-        const ret = getObject(arg0).getEntriesByName(v0, v1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
-        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
-    }, arguments) };
-    imports.wbg.__wbg_getTime_14776bfb48a1bff9 = function(arg0) {
-        const ret = getObject(arg0).getTime();
-        return ret;
-    };
-    imports.wbg.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
-        const ret = getObject(arg0)[arg1 >>> 0];
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_get_a499fc4db8c05b3b = function(arg0, arg1, arg2) {
-        var v0 = getCachedStringFromWasm0(arg1, arg2);
-        const ret = getObject(arg0)[v0];
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_get_efcb449f58ec27c2 = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.get(getObject(arg0), getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
-        const ret = getObject(arg0)[getObject(arg1)];
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_has_787fafc980c3ccdb = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.has(getObject(arg0), getObject(arg1));
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_info_68cd5b51ef7e5137 = function(arg0, arg1, arg2, arg3) {
-        console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
-    imports.wbg.__wbg_info_e674a11f4f50cc0c = function(arg0) {
-        console.info(getObject(arg0));
-    };
-    imports.wbg.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof ArrayBuffer;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Array_fca44e0f4a7f6240 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Array;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Date_79a0f671f36947f2 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Date;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Error_a944ec10920129e2 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Error;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Map;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Object_10bb762262230c68 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Object;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Promise_001fdd42afa1b7ef = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Promise;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Uint8Array;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Window_4846dbb3de56c84c = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Window;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_isArray_96e0af9891d0945d = function(arg0) {
-        const ret = Array.isArray(getObject(arg0));
-        return ret;
-    };
-    imports.wbg.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {
-        const ret = Number.isSafeInteger(getObject(arg0));
-        return ret;
-    };
-    imports.wbg.__wbg_iterator_e5822695327a3c39 = function() {
-        const ret = Symbol.iterator;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_jsvirtualdataslice_new = function(arg0) {
-        const ret = JsVirtualDataSlice.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_keys_b4d27b02ad14f4be = function(arg0) {
-        const ret = Object.keys(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_length_69bca3cb64fc8748 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_length_cdd215e10d9dd507 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_mark_4411b340bdf62a5f = function() { return handleError(function (arg0, arg1, arg2) {
-        var v0 = getCachedStringFromWasm0(arg1, arg2);
-        getObject(arg0).mark(v0);
-    }, arguments) };
-    imports.wbg.__wbg_measure_ef89c90a92de6f43 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-        var v0 = getCachedStringFromWasm0(arg1, arg2);
-        var v1 = getCachedStringFromWasm0(arg3, arg4);
-        getObject(arg0).measure(v0, v1);
-    }, arguments) };
-    imports.wbg.__wbg_message_1ee258909d7264fd = function(arg0) {
-        const ret = getObject(arg0).message;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
-        const ret = new Object();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_3c3d849046688a66 = function(arg0, arg1) {
-        try {
-            var state0 = {a: arg0, b: arg1};
-            var cb0 = (arg0, arg1) => {
-                const a = state0.a;
-                state0.a = 0;
-                try {
-                    return __wasm_bindgen_func_elem_5070(a, state0.b, arg0, arg1);
-                } finally {
-                    state0.a = a;
-                }
-            };
-            const ret = new Promise(cb0);
-            return addHeapObject(ret);
-        } finally {
-            state0.a = state0.b = 0;
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
         }
-    };
-    imports.wbg.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
-        const ret = new Uint8Array(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_68651c719dcda04e = function() {
-        const ret = new Map();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_a7442b4b19c1a356 = function(arg0, arg1) {
-        var v0 = getCachedStringFromWasm0(arg0, arg1);
-        const ret = new Error(v0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_e17d9f43105b08be = function() {
-        const ret = new Array();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {
-        const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
-        var v0 = getCachedStringFromWasm0(arg0, arg1);
-        const ret = new Function(v0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_next_020810e0ae8ebcb0 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).next();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_next_2c826fe5dfec6b6a = function(arg0) {
-        const ret = getObject(arg0).next;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_now_f5ba683d8ce2c571 = function(arg0) {
-        const ret = getObject(arg0).now();
-        return ret;
-    };
-    imports.wbg.__wbg_parse_2a704d6b78abb2b8 = function() { return handleError(function (arg0, arg1) {
-        var v0 = getCachedStringFromWasm0(arg0, arg1);
-        const ret = JSON.parse(v0);
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_performance_e8315b5ae987e93f = function(arg0) {
-        const ret = getObject(arg0).performance;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
-        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
-    };
-    imports.wbg.__wbg_push_df81a39d04db858c = function(arg0, arg1) {
-        const ret = getObject(arg0).push(getObject(arg1));
-        return ret;
-    };
-    imports.wbg.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {
-        const ret = getObject(arg0).queueMicrotask;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {
-        queueMicrotask(getObject(arg0));
-    };
-    imports.wbg.__wbg_reject_9d4761245c015a33 = function(arg0) {
-        const ret = Promise.reject(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_resolve_caf97c30b83f7053 = function(arg0) {
-        const ret = Promise.resolve(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
-        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-    };
-    imports.wbg.__wbg_set_907fb406c34a251d = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_c213c871859d6500 = function(arg0, arg1, arg2) {
-        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-    };
-    imports.wbg.__wbg_startTime_539df5e9647037f7 = function(arg0) {
-        const ret = getObject(arg0).startTime;
-        return ret;
-    };
-    imports.wbg.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
-        const ret = typeof global === 'undefined' ? null : global;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
-        const ret = typeof globalThis === 'undefined' ? null : globalThis;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
-        const ret = typeof self === 'undefined' ? null : self;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
-        const ret = typeof window === 'undefined' ? null : window;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    };
-    imports.wbg.__wbg_stringify_b5fb28f6465d9c3e = function() { return handleError(function (arg0) {
-        const ret = JSON.stringify(getObject(arg0));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_table_new = function(arg0) {
-        const ret = Table.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {
-        const ret = getObject(arg0).then(getObject(arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_then_70d05cf780a18d77 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_toString_7da7c8dbec78fcb8 = function(arg0) {
-        const ret = getObject(arg0).toString();
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_trace_8e50cd754f118df3 = function(arg0) {
-        console.trace(getObject(arg0));
-    };
-    imports.wbg.__wbg_trace_cf9f10b8c61bd472 = function(arg0, arg1, arg2, arg3) {
-        console.trace(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
-    imports.wbg.__wbg_value_692627309814bb8c = function(arg0) {
-        const ret = getObject(arg0).value;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_values_6f4c6a6a11564d83 = function(arg0) {
-        const ret = Object.values(getObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_view_new = function(arg0) {
-        const ret = View.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_view_unwrap = function(arg0) {
-        const ret = View.__unwrap(takeObject(arg0));
-        return ret;
-    };
-    imports.wbg.__wbg_warn_1d74dddbe2fd1dbb = function(arg0) {
-        console.warn(getObject(arg0));
-    };
-    imports.wbg.__wbg_warn_8f5b5437666d0885 = function(arg0, arg1, arg2, arg3) {
-        console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
-    imports.wbg.__wbindgen_cast_25a0a844437d0e92 = function(arg0, arg1) {
-        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
-        wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
-        // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
-        const ret = v0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
-        // Cast intrinsic for `U64 -> Externref`.
-        const ret = BigInt.asUintN(64, arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_58f1ec65de0445ab = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 534, function: Function { arguments: [Externref], shim_idx: 535, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3500, __wasm_bindgen_func_elem_3515);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_77bc3e92745e9a35 = function(arg0, arg1) {
-        var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
-        wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
-        // Cast intrinsic for `Vector(U8) -> Externref`.
-        const ret = v0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_7e9c58eeb11b0a6f = function(arg0, arg1) {
-        var v0 = getCachedStringFromWasm0(arg0, arg1);
-        // Cast intrinsic for `Ref(CachedString) -> Externref`.
-        const ret = v0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
-        // Cast intrinsic for `I64 -> Externref`.
-        const ret = arg0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_b4f8efd6e03d7eb3 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 2, function: Function { arguments: [], shim_idx: 3, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: false }) -> Externref`.
-        const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_123, __wasm_bindgen_func_elem_553);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
-        // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-        const ret = getArrayU8FromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
-        // Cast intrinsic for `F64 -> Externref`.
-        const ret = arg0;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
-    };
-
-    return imports;
-}
-
-function __wbg_finalize_init(instance, module) {
-    wasm = instance.exports;
-    __wbg_init.__wbindgen_wasm_module = module;
-    cachedDataViewMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-
-
-
-    return wasm;
+        return false;
+    }
 }
 
 function initSync(module) {
     if (wasm !== undefined) return wasm;
 
 
-    if (typeof module !== 'undefined') {
+    if (module !== undefined) {
         if (Object.getPrototypeOf(module) === Object.prototype) {
             ({module} = module)
         } else {
@@ -2177,13 +2455,10 @@ function initSync(module) {
     }
 
     const imports = __wbg_get_imports();
-
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
-
     const instance = new WebAssembly.Instance(module, imports);
-
     return __wbg_finalize_init(instance, module);
 }
 
@@ -2191,7 +2466,7 @@ async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
 
-    if (typeof module_or_path !== 'undefined') {
+    if (module_or_path !== undefined) {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
             ({module_or_path} = module_or_path)
         } else {
@@ -2211,5 +2486,4 @@ async function __wbg_init(module_or_path) {
     return __wbg_finalize_init(instance, module);
 }
 
-export { initSync };
-export default __wbg_init;
+export { initSync, __wbg_init as default };