@rindle/room 0.5.0

package/pkg/rindle_room.js

@@ -0,0 +1,924 @@
+/* @ts-self-types="./rindle_room.d.ts" */
+
+/**
+ * One room instance: the upstream-fed base store plus its downstream serving state
+ * (materialized queries deduped by `QueryKey`, subscribers addressed by the host's
+ * opaque keys) and — once [`enableWrites`](Self::enable_writes) runs — the §5.1
+ * write plane, with **at most one mutation transaction open at a time** (the room is
+ * an actor; the host serializes mutations onto it).
+ */
+export class WasmRoom {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmRoom.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRoomFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRoomFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmroom_free(ptr, 0);
+    }
+    /**
+     * Advance the ledger rows for journal-committed mutations — **the ack** (§5.1
+     * step 4; call once the journal append resolves). `entries_json` is a JSON array
+     * of `{clientID, mid}`. Returns `{"headCv": n}` — drain
+     * [`commitAll`](Self::commit_all) to ship the lmid frames — or `{"headCv": null}`
+     * when everything was already covered.
+     * @param {string} entries_json
+     * @returns {string}
+     */
+    ack(entries_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(entries_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_ack(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * The ledger row's current value for `clientID` (0 if none) — what the wire has
+     * confirmed.
+     * @param {string} client_id
+     * @returns {number}
+     */
+    ackedLmid(client_id) {
+        const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_ackedLmid(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * The highest mid applied to the head for `clientID` (0 if none) — the dedup
+     * watermark; diagnostics and the crash-replay tests read it.
+     * @param {string} client_id
+     * @returns {number}
+     */
+    appliedMid(client_id) {
+        const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_appliedMid(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Apply one upstream `nbatch` frame's `batch` object (JSON text). Returns a status
+     * object (JSON text): `{applied: "snapshot", rows}` | `{applied: "live", ops}` |
+     * `{applied: "duplicate"}` | `{applied: "staleEpoch", expected, got}`. Throws when
+     * the frame is garbage or the apply poisons the store — in both cases the host
+     * tears down and re-subscribes under a new epoch (§3.4); there is no repair call.
+     *
+     * After a `live`/`snapshot` apply, drain the fan-out with
+     * [`commitAll`](Self::commit_all).
+     * @param {string} batch_json
+     * @returns {string}
+     */
+    apply(batch_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(batch_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_apply(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Build the §5.3 net-effect batch from the dirty entries + ledger co-edits.
+     * Returns `undefined` when there is nothing to flush, else JSON text
+     * `{changes, batchHash, lmids}`: `changes` is the `/apply-row-change-txn`
+     * `changes[]` array (ingest shape, old-images = the CAS base chain), `batchHash`
+     * the batch identity computed over its canonical bytes, `lmids` the
+     * `{clientID, mid}` advances the batch covers. At most one flush may be in
+     * flight — resolve with [`flushOk`](Self::flush_ok) or
+     * [`flushConflict`](Self::flush_conflict); retries resubmit the SAME journaled
+     * body, never a rebuilt one.
+     * @returns {string | undefined}
+     */
+    beginFlush() {
+        const ret = wasm.wasmroom_beginFlush(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Open the transaction for `(clientID, mid)`. Returns `{"begin": "tx"}` (run the
+     * mutator, then [`commitMutation`](Self::commit_mutation) or
+     * [`rejectMutation`](Self::reject_mutation)) or `{"begin": "dedup"}` (an absorbed
+     * redelivery — send nothing). Throws on a mid gap with the exact
+     * `mutation gap for …` message the client's recovery keys on — forward it on an
+     * `error` frame. At most one transaction may be open.
+     *
+     * `name`/`args_json` (optional, Slice I-ii) are the wire envelope's mutator name
+     * and JSON-text args: should this mid end non-applied, its durable outcome row
+     * echoes them on a DEOPT (self-contained re-invoke, mirroring the H-iv-b frame).
+     * Omitting them degrades deopt rows to NULL name/args, nothing else.
+     * @param {string} client_id
+     * @param {number} mid
+     * @param {string | null} [name]
+     * @param {string | null} [args_json]
+     * @returns {string}
+     */
+    beginMutation(client_id, mid, name, args_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(args_json) ? 0 : passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len2 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_beginMutation(this.__wbg_ptr, ptr0, len0, mid, ptr1, len1, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * Drain every materialized query once and return the fan-out as JSON text:
+     * `[{sub, batch}, …]` — one entry per attached subscriber per query with a
+     * non-empty net delta, each `batch` stamped with that subscriber's own epoch/seq.
+     * Empty array when nothing changed (or the store is no longer live — a dead
+     * incarnation must not ship a torn frame).
+     * @returns {string}
+     */
+    commitAll() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmroom_commitAll(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Apply the open transaction to the head as one local commit: dirty entries are
+     * captured, the applied watermark advances, and every attached query sees the ops.
+     * Returns `{"headCv": n}` — drain [`commitAll`](Self::commit_all) and fan out NOW
+     * (§5.1 step 2: data fanout is never gated on durability), then journal the
+     * envelope and [`ack`](Self::ack) once the append commits. Throws only when the
+     * commit tears the head (store poisoned — tear down).
+     *
+     * Under [`enableWritesV2`](Self::enable_writes_v2) the §3.3 commit gate runs
+     * first; a containment violation returns `{"deopt": {reason, table, pk, …}}`
+     * instead (`reason`: `"writeOutOfScope"` (+ `op`) | `"joinKeyChanged"`
+     * (+ `column`) | `"absentReadUnproven"`): **nothing was applied**, the tx is
+     * consumed and the mid burnt exactly like [`rejectMutation`](Self::reject_mutation)
+     * (do NOT call it too) — journal the envelope as rejected and [`ack`](Self::ack)
+     * as usual, answering the client with a deopt. Under the v1 enable the return is
+     * always `{"headCv": n}`, byte-identical to before.
+     * @returns {string}
+     */
+    commitMutation() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmroom_commitMutation(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * The last-applied upstream commit version (`undefined` before the seq-0 snapshot).
+     * This is the journal cursor's `cv` half — persist `(epoch, cv)` to resume (§3.3).
+     * @returns {number | undefined}
+     */
+    cv() {
+        const ret = wasm.wasmroom_cv(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * How many `(table, pk)` keys are dirty (§5.3 — P3's flush input).
+     * @returns {number}
+     */
+    dirtyLen() {
+        const ret = wasm.wasmroom_dirtyLen(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The highest mid the write authority has committed for `clientID` (0 if none) —
+     * §8.1's `durable` level.
+     * @param {string} client_id
+     * @returns {number}
+     */
+    durableLmid(client_id) {
+        const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_durableLmid(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Enable the §5.1 write plane over a live store: `owned_json` is a JSON array of
+     * the tables mutators may write (§3.2's owned set — must all be in the upstream
+     * hello). Registers the `_rindle_client_mutations` ledger; call once, right after
+     * the seq-0 snapshot applies and before serving. Idempotence is deliberate-ly NOT
+     * provided: enabling twice is a shell bug and throws.
+     * @param {string} owned_json
+     */
+    enableWrites(owned_json) {
+        const ptr0 = passStringToWasm0(owned_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_enableWrites(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Enable the write plane with per-table **scope specs** — the §3.3 room commit
+     * gate (H-iv-a). `specs_json` is a JSON array of
+     * `{ table, footprintWhere?, writable }` where `writable` is the lease block's
+     * `RoomTableSpec.writable` shape (`{kind:"none"}` for a context table,
+     * `{kind:"predicate", where?, joinKeyCols}` for a writable one) and
+     * `footprintWhere` is the footprint's row-local wire `Condition` for the table
+     * (drives the absent-read proof). Predicates compile NOW, loudly — a malformed or
+     * non-row-local spec (e.g. a `correlatedSubquery`) throws and nothing is enabled.
+     * With the gate armed, [`commitMutation`](Self::commit_mutation) can return a
+     * `{"deopt": …}` verdict. Same once-only/live-store rules as
+     * [`enableWrites`](Self::enable_writes), which remains the legacy table-granular
+     * entry (its gate proves nothing and never deopts).
+     * @param {string} specs_json
+     */
+    enableWritesV2(specs_json) {
+        const ptr0 = passStringToWasm0(specs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_enableWritesV2(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The upstream subscription epoch this store was opened under.
+     * @returns {number}
+     */
+    epoch() {
+        const ret = wasm.wasmroom_epoch(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The authority rejected the in-flight batch on CAS (§5.4 `flush_conflict`):
+     * `conflicts_json` is its `409` body's `conflicts` array —
+     * `[{table, pk, current}]`, `current: null` for an absent row. Each conflicted
+     * key converges to the authority's image (the local net effect is dropped);
+     * everything else stays dirty and retries next flush. Returns
+     * `{"headCv": n | null}` — drain [`commitAll`](Self::commit_all) after a
+     * non-null cv to ship the corrective frames.
+     * @param {string} conflicts_json
+     * @returns {string}
+     */
+    flushConflict(conflicts_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(conflicts_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_flushConflict(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Whether a §5.3 flush is in flight (diagnostics; the shell also guards).
+     * @returns {boolean}
+     */
+    flushInFlight() {
+        const ret = wasm.wasmroom_flushInFlight(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The authority committed the in-flight batch (§5.3 step 6): consumed entries
+     * retire (or re-base onto the image just written, if re-dirtied mid-flight),
+     * durable watermarks advance, `pending ≤` them retires. Returns
+     * `{"retired": n, "dirty": n}` — a non-zero `dirty` means writes landed during
+     * the flight; schedule the next flush.
+     * @returns {string}
+     */
+    flushOk() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmroom_flushOk(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * The room's own commit order — what downstream frames are stamped with and what
+     * the shell's `progress {cvMin}` release points are computed from. Advances on
+     * every upstream apply and every local commit (see `RoomStore::head_cv`).
+     * @returns {number}
+     */
+    headCv() {
+        const ret = wasm.wasmroom_headCv(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Baseline present and not poisoned — the store is serving.
+     * @returns {boolean}
+     */
+    isLive() {
+        const ret = wasm.wasmroom_isLive(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * A failed apply left this incarnation dead (§3.4): tear down, re-subscribe.
+     * @returns {boolean}
+     */
+    isPoisoned() {
+        const ret = wasm.wasmroom_isPoisoned(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Subscribe `sub` to the reserved per-client lmid query (`_rindle/clientLmid`):
+     * the room composes the `_rindle_client_mutations WHERE client_id = <clientID>`
+     * AST itself — identity comes from the connection's `init`, never client args.
+     * Same return shape and envelope rules as [`subscribe`](Self::subscribe).
+     * @param {string} sub
+     * @param {number} epoch
+     * @param {string} client_id
+     * @param {number} now_ms
+     * @returns {string}
+     */
+    lmidSubscribe(sub, epoch, client_id, now_ms) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(sub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_lmidSubscribe(this.__wbg_ptr, ptr0, len0, epoch, ptr1, len1, now_ms);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * How many downstream queries are currently materialized (post-dedup).
+     * @returns {number}
+     */
+    materializationCount() {
+        const ret = wasm.wasmroom_materializationCount(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Open the room's base store from the upstream `nhello` frame's `hello` object
+     * (JSON text). `idle_ttl_ms` is the downstream retention grace: a materialized
+     * query with no subscribers for that long is reclaimed by [`sweep`](Self::sweep).
+     * Rejects malformed hellos loudly — nothing is constructed.
+     * @param {string} hello_json
+     * @param {number} idle_ttl_ms
+     * @returns {WasmRoom}
+     */
+    static open(hello_json, idle_ttl_ms) {
+        const ptr0 = passStringToWasm0(hello_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_open(ptr0, len0, idle_ttl_ms);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmRoom.__wrap(ret[0]);
+    }
+    /**
+     * Applied-but-not-retired mutations (everything, until P3's write-behind).
+     * @returns {number}
+     */
+    pendingLen() {
+        const ret = wasm.wasmroom_pendingLen(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Drop the open transaction's staged ops and consume its mid anyway — the reject
+     * path (unknown mutator, mutator threw, staging refusal, a replayed non-applied
+     * journal entry). The stream stays contiguous; the eventual [`ack`](Self::ack)
+     * advances the ledger with no effects, snapping the author's prediction back.
+     *
+     * `kind` (`"rejected"` (default) | `"deopt"`) + `reason` are the shell's H-iv-b
+     * classification of the verdict: the outcome is RECORDED (Slice I-ii) and its
+     * durable row rides the next flush beside the covering lmid co-edit — one
+     * authority transaction, so a post-downgrade client resolving through the daemon
+     * never reads a burnt non-applied mid as applied. A deopt row echoes the
+     * [`beginMutation`](Self::begin_mutation) envelope's `name`/`args`.
+     * @param {string | null} [kind]
+     * @param {string | null} [reason]
+     */
+    rejectMutation(kind, reason) {
+        var ptr0 = isLikeNone(kind) ? 0 : passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_rejectMutation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Seed the durable watermarks from the write authority's ledger — the boot probe
+     * (§3.3; T2's committed-before-crash row). Call after [`enableWrites`] and
+     * **before** the journal replay: seeded mids replay as dedup instead of
+     * re-invoking. `seeds_json` is a JSON array of `{clientID, lmid}`. Returns
+     * `{"headCv": n | null}` — the ledger rows ride a local commit so the client's
+     * lmid slice confirms them.
+     *
+     * [`enableWrites`]: Self::enable_writes
+     * @param {string} seeds_json
+     * @returns {string}
+     */
+    seedDurable(seeds_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_seedDurable(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Materialize-on-presentation (§10.1): attach subscriber `sub` (the host's opaque
+     * routing key) at `epoch` to the query for this approved wire `Ast` (JSON text) —
+     * reusing the pipeline on a `QueryKey` hit. Returns
+     * `{queryKey, reused, hello, snapshot}` (JSON text): send `nhello(hello)` then
+     * `nbatch(snapshot)` (its `seq` is 0), then this subscriber's entries from each
+     * [`commitAll`](Self::commit_all). Re-subscribing an existing `sub` replaces its
+     * envelope — pass the bumped `epoch`, exactly as before.
+     * @param {string} sub
+     * @param {number} epoch
+     * @param {string} ast_json
+     * @param {number} now_ms
+     * @returns {string}
+     */
+    subscribe(sub, epoch, ast_json, now_ms) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(sub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(ast_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmroom_subscribe(this.__wbg_ptr, ptr0, len0, epoch, ptr1, len1, now_ms);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * How many downstream subscribers are currently attached.
+     * @returns {number}
+     */
+    subscriberCount() {
+        const ret = wasm.wasmroom_subscriberCount(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Reclaim downstream queries idle past their grace window, on the host's clock.
+     * Returns how many were destroyed.
+     * @param {number} now_ms
+     * @returns {number}
+     */
+    sweep(now_ms) {
+        const ret = wasm.wasmroom_sweep(this.__wbg_ptr, now_ms);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Stage an add of a full-width row (JSON-array text). Clean refusal (throw, head
+     * untouched) when the key exists, the table is not owned, or the width is wrong —
+     * catch it and reject the mutation.
+     * @param {string} table
+     * @param {string} row_json
+     */
+    txAdd(table, row_json) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(row_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_txAdd(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Stage an edit to a full-width row (JSON-array text) keyed by its pk cells. The
+     * shell resolves partial updates against [`txGet`](Self::tx_get) first — only
+     * concrete cells cross this boundary (JSON has no `undefined`). The pk must not
+     * change; the row must exist.
+     * @param {string} table
+     * @param {string} row_json
+     */
+    txEdit(table, row_json) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(row_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_txEdit(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The effective row for `pk_json` (a JSON array of pk cells, `primaryKey` order):
+     * the live head under this transaction's own staged writes — read-your-writes for
+     * read-dependent mutators, and what the keyed `update`/`delete`/`upsert` layers
+     * probe before composing their writes. Returns the row as JSON-array text, or
+     * `undefined` when absent.
+     * @param {string} table
+     * @param {string} pk_json
+     * @returns {string | undefined}
+     */
+    txGet(table, pk_json) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pk_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_txGet(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v3;
+        if (ret[0] !== 0) {
+            v3 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v3;
+    }
+    /**
+     * Stage a remove of the row keyed `pk_json` (JSON array of pk cells). The change
+     * is composed from the effective row; a missing key is a clean refusal (the keyed
+     * `delete` layer no-ops before calling this).
+     * @param {string} table
+     * @param {string} pk_json
+     */
+    txRemove(table, pk_json) {
+        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pk_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_txRemove(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Detach subscriber `sub` (unsubscribe, socket close, lease expiry, revocation —
+     * the host decides why). Idempotent: returns whether it was attached. Its query
+     * stays materialized for `idle_ttl_ms` (a quick re-subscribe is cheap), then
+     * [`sweep`](Self::sweep) reclaims it.
+     * @param {string} sub
+     * @param {number} now_ms
+     * @returns {boolean}
+     */
+    unsubscribe(sub, now_ms) {
+        const ptr0 = passStringToWasm0(sub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmroom_unsubscribe(this.__wbg_ptr, ptr0, len0, now_ms);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+}
+if (Symbol.dispose) WasmRoom.prototype[Symbol.dispose] = WasmRoom.prototype.free;
+
+export function __rindle_room_wasm_start() {
+    wasm.__rindle_room_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___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __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_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __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);
+        },
+        __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_room_bg.js": import0,
+    };
+}
+
+const WasmRoomFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmroom_free(ptr, 1));
+
+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 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_room_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 };