@rindle/wasm 0.1.0-rc.5

package/pkg/rindle.js

@@ -0,0 +1,953 @@
+/* @ts-self-types="./rindle.d.ts" */
+
+/**
+ * The in-memory live-query engine, callable from JavaScript. See the module docs.
+ */
+export class Db {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DbFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_db_free(ptr, 0);
+    }
+    /**
+     * Tear down a registered query: drop its sink + reclaim its pipeline (disconnect from
+     * the shared sources, free its slots — [`Graph::destroy_pipeline`]). Other queries
+     * and the shared sources are untouched. A no-op for an unknown id.
+     * @param {number} query_id
+     */
+    destroyQuery(query_id) {
+        wasm.db_destroyQuery(this.__wbg_ptr, query_id);
+    }
+    constructor() {
+        const ret = wasm.db_new();
+        this.__wbg_ptr = ret;
+        DbFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Register a live query from a Zero-wire AST under the caller's opaque `query_id`.
+     * Lowers it into the shared graph, sinks it in a change-sink, and hydrates. Returns
+     * `{ queryId, comparatorVersion, schema, snapshot }` — the `hello` + hydrate
+     * snapshot for the JS `ArrayView` (snapshot cells **bare**). A malformed AST /
+     * unknown table / unknown column throws a JS `Error` carrying a `.kind`.
+     * @param {number} query_id
+     * @param {any} ast_json
+     * @returns {any}
+     */
+    query(query_id, ast_json) {
+        const ret = wasm.db_query(this.__wbg_ptr, query_id, ast_json);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Register a base table from a `SchemaSpec` (`{ columns, primaryKey, sort? }` —
+     * [`marshal::schema_from_js`]; any `relationships` in the spec are ignored — nesting
+     * is query-local via `sub`). Seeds an empty shared source. Idempotent per name.
+     * @param {string} table
+     * @param {any} schema
+     */
+    registerTable(table, schema) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.db_registerTable(this.__wbg_ptr, ptr0, len0, schema);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Open a §1.3 reconcile cycle against the coherent server delta `deltas` —
+     * an array of base-table row ops `{ table, type: "add"|"remove"|"edit", row,
+     * old? }` (the cv-released normalized batch, bare cells). Runs the rewind
+     * (steps 1–4): the engine's input becomes the authoritative state `S'`, with
+     * every optimistic write un-applied and the server delta folded in; `sync`
+     * re-forks. Nothing is delivered yet — the JS side now **re-invokes each
+     * still-pending client mutator** (ordinary `write()`/`commit()` calls, whose
+     * events buffer into the cycle), then calls
+     * [`server_batch_end`](Db::server_batch_end) for the one coalesced delivery.
+     *
+     * Errors if a cycle is already open, on an unknown table, or on a push failure
+     * — after which the optimistic state is poisoned (a partial rewind may have
+     * applied): the only safe recovery is to discard this `Db` and re-hydrate.
+     * @param {any} deltas
+     */
+    serverBatchBegin(deltas) {
+        const ret = wasm.db_serverBatchBegin(this.__wbg_ptr, deltas);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Close the open cycle: deliver the whole buffered event stream (rewind +
+     * re-invocations) per query, **in order**, as `[{ queryId, events: FlatChange[] }]`
+     * — one batch per affected query. The stream is forwarded RAW: the IVM sink emits
+     * changes in a valid incremental order (`FLAT-CHANGES-DESIGN.md` §5.4), so the
+     * receiver folds them in order to reach `view(head_new)`. The §3 "notify once"
+     * boundary is the view's own — one `applyChanges` per batch, settling before it
+     * notifies. Queries the cycle never touched are omitted.
+     *
+     * Note: a still-pending write whose re-invocation reproduced its prediction emits a
+     * balanced `remove`+`add` here. That nets to no observable change once the view
+     * settles, but it is no longer suppressed *at this boundary* (the netting/reordering
+     * that did so was the source of the coalescer correctness bugs). Restoring
+     * no-op-cycle ⇒ no-notify is a view-level optimization (Step 2 of the removal).
+     * @returns {any}
+     */
+    serverBatchEnd() {
+        const ret = wasm.db_serverBatchEnd(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Remove a base table previously added by [`register_table`](Self::register_table): free
+     * its source node, drop its optimistic baseline, and forget it from the source map — the
+     * inverse of `register_table`. For a SYNTHETIC aggregate table (`__agg_*`) whose last
+     * reading query has been destroyed (`AGGREGATE-SYNC-DESIGN.md` §4): aggregate state is
+     * reclaimed, not permanent. Idempotent for an unknown/already-removed table. Throws a JS
+     * `Error` if the table still has a live query connected to it — the caller must
+     * `destroy_query` every reader first (the optimistic/normalized backend refcounts so this
+     * holds).
+     * @param {string} table
+     */
+    unregisterTable(table) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.db_unregisterTable(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Open a write transaction. Stage row ops with [`WriteTxn::add`]/`remove`/`edit`,
+     * then [`WriteTxn::commit`] to apply them as one batch and get the per-query flat
+     * changes back. Dropping (or `rollback`) without committing applies nothing.
+     * @returns {WriteTxn}
+     */
+    write() {
+        const ret = wasm.db_write(this.__wbg_ptr);
+        return WriteTxn.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Db.prototype[Symbol.dispose] = Db.prototype.free;
+
+/**
+ * A built, hydrated query view, callable from JavaScript.
+ */
+export class RindleView {
+    static __wrap(ptr) {
+        const obj = Object.create(RindleView.prototype);
+        obj.__wbg_ptr = ptr;
+        RindleViewFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RindleViewFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rindleview_free(ptr, 0);
+    }
+    /**
+     * Build + hydrate a view from an AST (JS JSON) and a table→schema map.
+     *
+     * - `ast_json`: the query AST — Zero's wire shape (see `src/ast.rs`).
+     * - `schemas`: `{ tableName: <SchemaSpec> }` (see [`marshal::schema_from_js`]).
+     * - `data`: optional `{ tableName: row[][] }` initial rows (each row a cell
+     *   array, positional with the schema's `columns`); a table absent here seeds
+     *   empty.
+     *
+     * A `BuildError`/`RindleError` is thrown as a JS `Error` with a `.kind` tag.
+     * @param {any} ast_json
+     * @param {any} schemas
+     * @param {any} data
+     * @returns {RindleView}
+     */
+    static build(ast_json, schemas, data) {
+        const ret = wasm.rindleview_build(ast_json, schemas, data);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RindleView.__wrap(ret[0]);
+    }
+    /**
+     * The current materialized view tree as a JS value (array / object / `null`).
+     * @returns {any}
+     */
+    data() {
+        const ret = wasm.rindleview_data(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Close the current transaction: fire listeners with the new snapshot.
+     */
+    flush() {
+        wasm.rindleview_flush(this.__wbg_ptr);
+    }
+    /**
+     * Push one source change `{ type: 'add'|'remove'|'edit', row, old? }` to `table`.
+     * Does **not** flush — call [`RindleView::flush`] to close the transaction (so a JS
+     * client can batch several pushes into one notification).
+     * @param {string} table
+     * @param {any} change
+     */
+    push(table, change) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rindleview_push(this.__wbg_ptr, ptr0, len0, change);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The view's current result type (`"unknown" | "complete" | "error"`).
+     * @returns {any}
+     */
+    resultType() {
+        const ret = wasm.rindleview_resultType(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Resolve the async result type (the `queryComplete` transition); fires
+     * listeners out of band. Accepts `"complete" | "error" | "unknown"`.
+     * @param {string} rt
+     */
+    setResultType(rt) {
+        const ptr0 = passStringToWasm0(rt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.rindleview_setResultType(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Subscribe a JS callback `(data, resultType) => void`, fired **once
+     * immediately** and on every subsequent [`RindleView::flush`]. Returns the
+     * listener index.
+     * @param {Function} cb
+     * @returns {number}
+     */
+    subscribe(cb) {
+        const ret = wasm.rindleview_subscribe(this.__wbg_ptr, cb);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RindleView.prototype[Symbol.dispose] = RindleView.prototype.free;
+
+/**
+ * An open write transaction: a staging buffer of row ops applied atomically at
+ * [`commit`](WriteTxn::commit). Nothing touches the engine until commit, so a dropped or
+ * rolled-back txn is a clean no-op (no `Drop` undo needed).
+ */
+export class WriteTxn {
+    static __wrap(ptr) {
+        const obj = Object.create(WriteTxn.prototype);
+        obj.__wbg_ptr = ptr;
+        WriteTxnFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WriteTxnFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_writetxn_free(ptr, 0);
+    }
+    /**
+     * Stage an add of `row` (a positional cell array, width-checked against the table's
+     * schema) to `table`.
+     * @param {string} table
+     * @param {any} row
+     */
+    add(table, row) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writetxn_add(this.__wbg_ptr, ptr0, len0, row);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Apply the staged ops (push through the shared sources, fanning to every dependent
+     * query), drain each affected query's sink, and return `[{ queryId, events:
+     * FlatChange[] }]` for the queries that changed (empties omitted, like
+     * `Publisher::commit`). Consumes the transaction.
+     *
+     * **Inside a server-batch cycle** (a pending mutator re-invocation between
+     * [`Db::server_batch_begin`] and [`Db::server_batch_end`]) the drained events
+     * buffer into the cycle instead and an **empty** array returns — the §3
+     * notify-once boundary: the whole cycle delivers exactly once, coalesced, at
+     * `serverBatchEnd`.
+     * @returns {any}
+     */
+    commit() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.writetxn_commit(ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Stage an edit of `old` → `new_row` in `table` (both width-checked).
+     *
+     * **Partial (optimistic) edit (`PROJECTION-SUPPORT-DESIGN.md` §8 / OQ-3).** An
+     * [`OwnedValue::Absent`] cell in `new_row` means *"not touching this column — leave it
+     * unchanged"*: it falls through to the current **effective** row (the live engine under
+     * this txn's staged overlay, i.e. what [`WriteTxn::get`] would return). The merge is
+     * resolved **here, at the staging boundary**, into a concrete full-width
+     * [`SourceChange::Edit`] whose `old` is that effective row — so operators, indexes, and
+     * the overlay never learn about merge semantics (they keep seeing whole rows), and a
+     * re-invocation after a server rebase re-reads the *new* effective row and re-merges.
+     * Presence is **monotonic**: a partial edit only *sets* columns (or leaves them), never
+     * narrows — narrowing is sync-only (§4.2). A full `new_row` (no `Absent`) stages verbatim,
+     * byte-identical to before (§7).
+     * @param {string} table
+     * @param {any} old
+     * @param {any} new_row
+     */
+    edit(table, old, new_row) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writetxn_edit(this.__wbg_ptr, ptr0, len0, old, new_row);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The current row of `table` whose primary key equals `pk` (an array of the PK
+     * column cells, in `primaryKey` order), or `undefined`. Reads the live engine
+     * state **plus this transaction's own staged ops** (later staged ops win), so a
+     * read-dependent client mutator sees its prior writes — the §4.1 contract. During
+     * a server-batch cycle the live state is the rebased base (`S'` + the pending
+     * mutations re-invoked so far), which is exactly what re-invocation must read.
+     * @param {string} table
+     * @param {any} pk
+     * @returns {any}
+     */
+    get(table, pk) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writetxn_get(this.__wbg_ptr, ptr0, len0, pk);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Stage a remove of `row` from `table`.
+     * @param {string} table
+     * @param {any} row
+     */
+    remove(table, row) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writetxn_remove(this.__wbg_ptr, ptr0, len0, row);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Discard the staged ops without applying anything. (Nothing was applied, so this
+     * just consumes the handle; it exists for a symmetric, explicit API.)
+     */
+    rollback() {
+        const ptr = this.__destroy_into_raw();
+        wasm.writetxn_rollback(ptr);
+    }
+}
+if (Symbol.dispose) WriteTxn.prototype[Symbol.dispose] = WriteTxn.prototype.free;
+
+/**
+ * Install the panic hook so a residual wasm panic surfaces a legible JS `Error`
+ * (with a Rust message) instead of an opaque `RuntimeError: unreachable` (WS09.6).
+ * Runs once on module load.
+ */
+export function __rindle_wasm_start() {
+    wasm.__rindle_wasm_start();
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_ef53bc310eb298a0: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_Number_6b506e6536831eaa: function(arg0) {
+            const ret = Number(arg0);
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_bigint_get_as_i64_38130e98eecd467d: function(arg0, arg1) {
+            const v = 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_1a45e2c38d4d41b9: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_0accd80f45e5faa2: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_in_70a403a56e771704: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_6ffd6468a9bc44b9: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_754e9f305ff6029e: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_87c3bfe968c6a5ad: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_56732c2bc353f41d: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_c236cabd84a4d769: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_67b456be8673d3d7: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_1068e624fa87f6ab: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_2c56564c75129511: function(arg0, arg1) {
+            const ret = arg0 == arg1;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_9bb1761122181af2: function(arg0, arg1) {
+            const obj = 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_72bdf95d3ae505b1: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_40e4174f169eaca7: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbg_call_8a89609d89f6608a: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_done_60cf307fcc680536: function(arg0) {
+            const ret = arg0.done;
+            return ret;
+        },
+        __wbg_entries_04b37a02507f1713: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_from_d300fe49deab18f5: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
+        __wbg_get_1f8f054ddbaa7db2: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_2b48c7d0d006a781: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_de6a0f7d4d18a304: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_unchecked_33f6e5c9e2f2d6b2: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
+            const ret = arg0[arg1];
+            return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_8f49811467741499: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_9fc06d9a951bcee6: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Object_873c13f9f41aec78: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Object;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_86f30649f63ef9c2: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_67c2c9c4313f4448: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_isSafeInteger_66acec27e09e99a7: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
+        __wbg_iterator_8732428d309e270e: function() {
+            const ret = Symbol.iterator;
+            return ret;
+        },
+        __wbg_length_4a591ecaa01354d9: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_66f1a4b2e9026940: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_new_50bb5ebeecef71a8: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_578aeef4b6b94378: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_ce1ab61c1c2b300d: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_d90091b82fdf5b91: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_next_9e03acdf51c4960d: function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        },
+        __wbg_next_eb8ca7351fa27906: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_prototypesetcall_3249fc62a0fafa30: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_a6822215aa43e71c: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_set_6e30c9374c26414c: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_stringify_8286df6dcc591521: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
+        __wbg_value_f3625092ee4b37f4: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./rindle_bg.js": import0,
+    };
+}
+
+const DbFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_db_free(ptr, 1));
+const RindleViewFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rindleview_free(ptr, 1));
+const WriteTxnFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_writetxn_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+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;
+    }
+    // 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);
+    }
+    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';
+        }
+    }
+    // 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 getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+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);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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;
+    }
+
+    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;
+    }
+    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;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+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));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    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 && 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; }
+            }
+        }
+
+        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 expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    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);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('rindle_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };