jazz-wasm 2.0.0-alpha.46 → 2.0.0-alpha.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jazz-wasm",
-  "version": "2.0.0-alpha.46",
+  "version": "2.0.0-alpha.48",
   "description": "WebAssembly bindings for the Jazz database engine",
   "keywords": [
     "crdt",
@@ -26,6 +26,7 @@
     "tag": "alpha"
   },
   "scripts": {
-    "build": "wasm-pack build --target web --profiling"
+    "build": "wasm-pack build --target web --release",
+    "build:profiling": "wasm-pack build --target web --profiling"
   }
 }

package/pkg/jazz_wasm.d.ts

@@ -124,6 +124,10 @@ export class WasmRuntime {
      * before the call returns, rather than being deferred to a microtask.
      */
     addServer(server_catalogue_state_hash?: string | null, next_sync_seq?: number | null): void;
+    /**
+     * Drive the runtime's batched receive/apply/send loop immediately.
+     */
+    batchedTick(): void;
     /**
      * Connect to a Jazz server over WebSocket.
      *
@@ -137,30 +141,29 @@ export class WasmRuntime {
      */
     createSubscription(query_json: string, session_json?: string | null, settled_tier?: string | null, options_json?: string | null): number;
     /**
-     * Delete a row by ObjectId.
-     */
-    delete(object_id: string): any;
-    /**
-     * Delete a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write.
+     * Attach a `WasmWorkerBridge` to this runtime. Convenience helper so the
+     * TS-side `WorkerBridge` adapter can construct the Rust bridge without
+     * importing `WasmWorkerBridge` directly — it gets it back from the
+     * runtime instance.
+     *
+     * `options` is the `WorkerBridgeOptions` JS object (parsed at attach
+     * time per spec; `init` no longer takes options).
      */
-    deletePersisted(object_id: string, tier: string): any;
+    createWorkerBridge(worker: Worker, options: any): WasmWorkerBridge;
     /**
-     * Delete a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write, scoped to an explicit session
-     * principal or transactional write context.
+     * Delete a row by ObjectId.
      */
-    deletePersistedWithSession(object_id: string, write_context_json: string | null | undefined, tier: string): any;
+    delete(object_id: string): any;
     /**
      * Delete a row by ObjectId as an explicit session principal.
      */
     deleteWithSession(object_id: string, write_context_json?: string | null): any;
     static deriveUserId(seed_b64: string): string;
+    discardLocalBatch(batch_id: string): boolean;
     /**
      * Disconnect from the Jazz server and drop the transport handle.
      */
     disconnect(): void;
-    drainRejectedBatchIds(): any;
     /**
      * Phase 2 of 2-phase subscribe: compile graph, register subscription,
      * sync to servers, attach callback, and deliver the first delta.
@@ -185,6 +188,7 @@ export class WasmRuntime {
      * Get the canonical schema hash (64-char hex).
      */
     getSchemaHash(): string;
+    hydrateLocalBatchRecordStorageRow(bytes: Uint8Array): void;
     /**
      * Insert a row into a table.
      *
@@ -192,22 +196,13 @@ export class WasmRuntime {
      * The inserted row as `{ id, values, batchId }`.
      */
     insert(table: string, values: any, object_id?: string | null): any;
-    /**
-     * Insert a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write.
-     */
-    insertPersisted(table: string, values: any, tier: string): any;
-    /**
-     * Insert a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write, scoped to an explicit session
-     * principal or transactional write context.
-     */
-    insertPersistedWithSession(table: string, values: any, write_context_json: string | null | undefined, tier: string): any;
     /**
      * Insert a row into a table as an explicit session principal.
      */
     insertWithSession(table: string, values: any, write_context_json?: string | null, object_id?: string | null): any;
+    loadBatchFate(batch_id: string): any;
     loadLocalBatchRecord(batch_id: string): any;
+    loadLocalBatchRecordStorageRow(batch_id: string): any;
     loadLocalBatchRecords(): any;
     static mintJazzSelfSignedToken(seed_b64: string, issuer: string, audience: string, ttl_seconds: bigint, now_seconds: bigint): string;
     /**
@@ -233,6 +228,10 @@ export class WasmRuntime {
      * The callback receives a single string argument: a human-readable reason.
      */
     onAuthFailure(callback: Function): void;
+    /**
+     * Register a callback for unhandled mutation errors.
+     */
+    onMutationError(callback: Function): void;
     /**
      * Called by JS when a sync message arrives from the server.
      *
@@ -249,10 +248,6 @@ export class WasmRuntime {
      * * `payload` - Postcard-encoded SyncPayload bytes
      */
     onSyncMessageReceivedFromClient(client_id: string, payload: any): void;
-    /**
-     * Register a callback for outgoing sync messages.
-     */
-    onSyncMessageToSend(callback: Function): void;
     /**
      * Create an ephemeral WasmRuntime backed by in-memory storage.
      *
@@ -273,10 +268,14 @@ export class WasmRuntime {
      * Optional durability tier controls remote settlement behavior.
      */
     query(query_json: string, session_json?: string | null, settled_tier?: string | null, options_json?: string | null): Promise<any>;
+    reconcileLocalBatchWithServer(batch_id: string): void;
     /**
      * Remove the current upstream server connection.
      */
     removeServer(): void;
+    replayBatchRejection(batch_id: string, code: string, reason: string): void;
+    replayLocalBatchPayloads(batch_id: string): Array<any>;
+    retransmitLocalBatch(batch_id: string): void;
     sealBatch(batch_id: string): void;
     /**
      * Set a client's role.
@@ -311,17 +310,6 @@ export class WasmRuntime {
      * Push updated auth credentials into the live transport.
      */
     updateAuth(auth_json: string): void;
-    /**
-     * Update a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write.
-     */
-    updatePersisted(object_id: string, values: any, tier: string): any;
-    /**
-     * Update a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write, scoped to an explicit session
-     * principal or transactional write context.
-     */
-    updatePersistedWithSession(object_id: string, values: any, write_context_json: string | null | undefined, tier: string): any;
     /**
      * Update a row by ObjectId as an explicit session principal.
      *
@@ -331,6 +319,72 @@ export class WasmRuntime {
      * * `session_json` - Optional JSON-encoded Session used for policy checks
      */
     updateWithSession(object_id: string, values: any, write_context_json?: string | null): any;
+    /**
+     * Wait for a batch to settle at the requested durability tier.
+     */
+    waitForBatch(batch_id: string, tier: string): Promise<any>;
+}
+
+export class WasmWorkerBridge {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    acknowledgeRejectedBatch(batch_id: string): void;
+    applyIncomingServerPayload(payload: Uint8Array): void;
+    /**
+     * Attach a Rust bridge to an externally-constructed Worker.
+     *
+     * Options are parsed at attach time; `init()` is parameter-less.
+     */
+    static attach(worker: Worker, runtime: WasmRuntime, options: any): WasmWorkerBridge;
+    closePeer(peer_id: string): void;
+    disconnectUpstream(): void;
+    /**
+     * Get the worker-assigned client id (post-init), or `null`.
+     */
+    getWorkerClientId(): any;
+    /**
+     * Send the init message and resolve when the worker reports `init-ok`.
+     * Memoized — repeated calls return the same in-flight `Promise`.
+     *
+     * State setup + the init `postMessage` happen *synchronously* before
+     * this returns. Only the `init-ok | error | timeout` race awaits inside
+     * the returned `Promise`. Callers that emit a synthetic `init-ok`
+     * straight after this call (tests) don't need a microtask yield to see
+     * the resolver installed.
+     */
+    init(): Promise<any>;
+    openPeer(peer_id: string): void;
+    reconnectUpstream(): void;
+    replayServerConnection(): void;
+    sendLifecycleHint(event: string): void;
+    sendPeerSync(peer_id: string, term: number, payload: Array<any>): void;
+    setListeners(listeners: any): void;
+    setServerPayloadForwarder(callback?: Function | null): void;
+    /**
+     * Tear the bridge down. Synchronous side-effects (final outbox flush,
+     * noop sender install, edge removal, `Shutdown` posted) happen before
+     * this returns. The returned `Promise` resolves on `shutdown-ok` or
+     * after `SHUTDOWN_ACK_TIMEOUT_MS`.
+     */
+    shutdown(): Promise<any>;
+    /**
+     * Test-only: post `MainToWorkerWire::SimulateCrash` to the worker. The
+     * worker host releases OPFS handles without flushing a snapshot and
+     * posts `ShutdownOk`. Returns a Promise that resolves when the ack
+     * arrives (or after `SHUTDOWN_ACK_TIMEOUT_MS` regardless). Used by
+     * browser tests to validate WAL replay.
+     */
+    simulateCrash(): Promise<any>;
+    updateAuth(jwt_token?: string | null): void;
+    /**
+     * Mirror of the TS-side `waitForLocalSyncFlush(batchId?)` from main: drive
+     * the main runtime's outbox to the worker, await a `SyncAck`, optionally
+     * retry while the batch is still reconciling. Returns once the worker
+     * confirms reconciliation, the 2s budget expires, or any ack times out.
+     */
+    waitForLocalSyncFlush(batch_id?: string | null): Promise<any>;
+    waitForUpstreamServerConnection(): Promise<void>;
 }
 
 export function bench_get_cache_bytes(): number;
@@ -384,6 +438,19 @@ export function bench_set_read_coalesce_pages(read_coalesce_pages: number): void
  */
 export function currentTimestamp(): bigint;
 
+export function decodeMainToWorkerJs(bytes: Uint8Array): any;
+
+export function decodeWorkerToMainJs(bytes: Uint8Array): any;
+
+/**
+ * Drain buffered tracing entries collected by the wasm tracing layer.
+ */
+export function drainTraceEntries(): any;
+
+export function encodeMainToWorkerJs(value: any): Uint8Array;
+
+export function encodeWorkerToMainJs(value: any): Uint8Array;
+
 /**
  * Generate a new UUID v7 (time-ordered).
  *
@@ -405,60 +472,104 @@ export function init(): void;
  */
 export function parseSchema(json: string): any;
 
+export function runAsWorker(init_message: any, pending_messages: Array<any>): void;
+
+/**
+ * Enable or disable collection of buffered tracing entries for JavaScript drains.
+ */
+export function setTraceEntryCollectionEnabled(enabled: boolean): void;
+
+/**
+ * Subscribe to notifications that buffered tracing entries are ready to drain.
+ */
+export function subscribeTraceEntries(callback: Function): Function;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly __wbg_wasmruntime_free: (a: number, b: number) => void;
     readonly currentTimestamp: () => bigint;
     readonly generateId: () => [number, number];
     readonly parseSchema: (a: number, b: number) => [number, number, number];
+    readonly runAsWorker: (a: any, b: any) => [number, number];
+    readonly init: () => void;
+    readonly decodeMainToWorkerJs: (a: any) => [number, number, number];
+    readonly decodeWorkerToMainJs: (a: any) => [number, number, number];
+    readonly encodeMainToWorkerJs: (a: any) => [number, number, number];
+    readonly encodeWorkerToMainJs: (a: any) => [number, number, number];
+    readonly __wbg_wasmruntime_free: (a: number, b: number) => void;
+    readonly __wbg_wasmworkerbridge_free: (a: number, b: number) => void;
+    readonly setTraceEntryCollectionEnabled: (a: number) => void;
     readonly wasmruntime___debugSchemaState: (a: number) => [number, number, number];
     readonly wasmruntime___debugSeedLiveSchema: (a: number, b: number, c: number) => [number, number];
     readonly wasmruntime_acknowledgeRejectedBatch: (a: number, b: number, c: number) => [number, number, number];
     readonly wasmruntime_addClient: (a: number) => [number, number];
     readonly wasmruntime_addServer: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly wasmruntime_batchedTick: (a: number) => void;
     readonly wasmruntime_connect: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly wasmruntime_createSubscription: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly wasmruntime_createWorkerBridge: (a: number, b: any, c: any) => [number, number, number];
     readonly wasmruntime_delete: (a: number, b: number, c: number) => [number, number, number];
-    readonly wasmruntime_deletePersisted: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-    readonly wasmruntime_deletePersistedWithSession: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
     readonly wasmruntime_deleteWithSession: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly wasmruntime_deriveUserId: (a: number, b: number) => [number, number, number, number];
+    readonly wasmruntime_discardLocalBatch: (a: number, b: number, c: number) => [number, number, number];
     readonly wasmruntime_disconnect: (a: number) => void;
-    readonly wasmruntime_drainRejectedBatchIds: (a: number) => [number, number, number];
     readonly wasmruntime_executeSubscription: (a: number, b: number, c: any) => [number, number];
     readonly wasmruntime_flush: (a: number) => void;
     readonly wasmruntime_flushWal: (a: number) => void;
     readonly wasmruntime_getPublicKeyBase64url: (a: number, b: number) => [number, number, number, number];
     readonly wasmruntime_getSchema: (a: number) => [number, number, number];
     readonly wasmruntime_getSchemaHash: (a: number) => [number, number];
+    readonly wasmruntime_hydrateLocalBatchRecordStorageRow: (a: number, b: any) => [number, number];
     readonly wasmruntime_insert: (a: number, b: number, c: number, d: any, e: number, f: number) => [number, number, number];
-    readonly wasmruntime_insertPersisted: (a: number, b: number, c: number, d: any, e: number, f: number) => [number, number, number];
-    readonly wasmruntime_insertPersistedWithSession: (a: number, b: number, c: number, d: any, e: number, f: number, g: number, h: number) => [number, number, number];
     readonly wasmruntime_insertWithSession: (a: number, b: number, c: number, d: any, e: number, f: number, g: number, h: number) => [number, number, number];
+    readonly wasmruntime_loadBatchFate: (a: number, b: number, c: number) => [number, number, number];
     readonly wasmruntime_loadLocalBatchRecord: (a: number, b: number, c: number) => [number, number, number];
+    readonly wasmruntime_loadLocalBatchRecordStorageRow: (a: number, b: number, c: number) => [number, number, number];
     readonly wasmruntime_loadLocalBatchRecords: (a: number) => [number, number, number];
     readonly wasmruntime_mintJazzSelfSignedToken: (a: number, b: number, c: number, d: number, e: number, f: number, g: bigint, h: bigint) => [number, number, number, number];
     readonly wasmruntime_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number, number];
     readonly wasmruntime_onAuthFailure: (a: number, b: any) => void;
+    readonly wasmruntime_onMutationError: (a: number, b: any) => void;
     readonly wasmruntime_onSyncMessageReceived: (a: number, b: any, c: number, d: number) => [number, number];
     readonly wasmruntime_onSyncMessageReceivedFromClient: (a: number, b: number, c: number, d: any) => [number, number];
-    readonly wasmruntime_onSyncMessageToSend: (a: number, b: any) => void;
     readonly wasmruntime_openEphemeral: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => [number, number, number];
     readonly wasmruntime_openPersistent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => any;
     readonly wasmruntime_query: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly wasmruntime_reconcileLocalBatchWithServer: (a: number, b: number, c: number) => [number, number];
     readonly wasmruntime_removeServer: (a: number) => void;
+    readonly wasmruntime_replayBatchRejection: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
+    readonly wasmruntime_replayLocalBatchPayloads: (a: number, b: number, c: number) => [number, number, number];
+    readonly wasmruntime_retransmitLocalBatch: (a: number, b: number, c: number) => [number, number];
     readonly wasmruntime_sealBatch: (a: number, b: number, c: number) => [number, number];
     readonly wasmruntime_setClientRole: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly wasmruntime_subscribe: (a: number, b: number, c: number, d: any, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
     readonly wasmruntime_unsubscribe: (a: number, b: number) => void;
     readonly wasmruntime_update: (a: number, b: number, c: number, d: any) => [number, number, number];
     readonly wasmruntime_updateAuth: (a: number, b: number, c: number) => [number, number];
-    readonly wasmruntime_updatePersisted: (a: number, b: number, c: number, d: any, e: number, f: number) => [number, number, number];
-    readonly wasmruntime_updatePersistedWithSession: (a: number, b: number, c: number, d: any, e: number, f: number, g: number, h: number) => [number, number, number];
     readonly wasmruntime_updateWithSession: (a: number, b: number, c: number, d: any, e: number, f: number) => [number, number, number];
-    readonly init: () => void;
+    readonly wasmruntime_waitForBatch: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+    readonly wasmworkerbridge_acknowledgeRejectedBatch: (a: number, b: number, c: number) => void;
+    readonly wasmworkerbridge_applyIncomingServerPayload: (a: number, b: any) => [number, number];
+    readonly wasmworkerbridge_attach: (a: any, b: number, c: any) => [number, number, number];
+    readonly wasmworkerbridge_closePeer: (a: number, b: number, c: number) => void;
+    readonly wasmworkerbridge_disconnectUpstream: (a: number) => void;
+    readonly wasmworkerbridge_getWorkerClientId: (a: number) => any;
+    readonly wasmworkerbridge_init: (a: number) => any;
+    readonly wasmworkerbridge_openPeer: (a: number, b: number, c: number) => void;
+    readonly wasmworkerbridge_reconnectUpstream: (a: number) => void;
+    readonly wasmworkerbridge_replayServerConnection: (a: number) => void;
+    readonly wasmworkerbridge_sendLifecycleHint: (a: number, b: number, c: number) => void;
+    readonly wasmworkerbridge_sendPeerSync: (a: number, b: number, c: number, d: number, e: any) => void;
+    readonly wasmworkerbridge_setListeners: (a: number, b: any) => void;
+    readonly wasmworkerbridge_setServerPayloadForwarder: (a: number, b: number) => void;
+    readonly wasmworkerbridge_shutdown: (a: number) => any;
+    readonly wasmworkerbridge_simulateCrash: (a: number) => any;
+    readonly wasmworkerbridge_updateAuth: (a: number, b: number, c: number) => void;
+    readonly wasmworkerbridge_waitForLocalSyncFlush: (a: number, b: number, c: number) => any;
+    readonly wasmworkerbridge_waitForUpstreamServerConnection: (a: number) => any;
+    readonly drainTraceEntries: () => any;
+    readonly subscribeTraceEntries: (a: any) => any;
     readonly __wbg_wasmquerybuilder_free: (a: number, b: number) => void;
     readonly wasmquerybuilder_alias: (a: number, b: number, c: number) => number;
     readonly wasmquerybuilder_branch: (a: number, b: number, c: number) => number;
@@ -506,9 +617,12 @@ export interface InitOutput {
     readonly bench_reset_read_coalesce_pages: () => void;
     readonly wasm_bindgen__convert__closures_____invoke__h656199c36535c3e6: (a: number, b: number, c: any) => [number, number];
     readonly wasm_bindgen__convert__closures_____invoke__h250bbd6a67e0e1e6: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__hf7ddf3622752ec36: (a: number, b: number, c: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__hc18e08680cddc2e5: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h74026c82fbbbb92b: (a: number, b: number, c: any) => any;
+    readonly wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d_3: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hbc8b7acec5ff03a6: (a: number, b: number, c: any) => void;
     readonly wasm_bindgen__convert__closures_____invoke__h03757a48b3eba690: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hcc3019a61bf91992: (a: number, b: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/pkg/jazz_wasm.js

@@ -398,6 +398,12 @@ export class WasmRuntime {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Drive the runtime's batched receive/apply/send loop immediately.
+     */
+    batchedTick() {
+        wasm.wasmruntime_batchedTick(this.__wbg_ptr);
+    }
     /**
      * Connect to a Jazz server over WebSocket.
      *
@@ -441,54 +447,33 @@ export class WasmRuntime {
         return ret[0];
     }
     /**
-     * Delete a row by ObjectId.
-     * @param {string} object_id
-     * @returns {any}
-     */
-    delete(object_id) {
-        const ptr0 = passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_delete(this.__wbg_ptr, ptr0, len0);
+     * Attach a `WasmWorkerBridge` to this runtime. Convenience helper so the
+     * TS-side `WorkerBridge` adapter can construct the Rust bridge without
+     * importing `WasmWorkerBridge` directly — it gets it back from the
+     * runtime instance.
+     *
+     * `options` is the `WorkerBridgeOptions` JS object (parsed at attach
+     * time per spec; `init` no longer takes options).
+     * @param {Worker} worker
+     * @param {any} options
+     * @returns {WasmWorkerBridge}
+     */
+    createWorkerBridge(worker, options) {
+        const ret = wasm.wasmruntime_createWorkerBridge(this.__wbg_ptr, worker, options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return WasmWorkerBridge.__wrap(ret[0]);
     }
     /**
-     * Delete a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write.
-     * @param {string} object_id
-     * @param {string} tier
-     * @returns {any}
-     */
-    deletePersisted(object_id, tier) {
-        const ptr0 = passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_deletePersisted(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Delete a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write, scoped to an explicit session
-     * principal or transactional write context.
+     * Delete a row by ObjectId.
      * @param {string} object_id
-     * @param {string | null | undefined} write_context_json
-     * @param {string} tier
      * @returns {any}
      */
-    deletePersistedWithSession(object_id, write_context_json, tier) {
+    delete(object_id) {
         const ptr0 = passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_deletePersistedWithSession(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        const ret = wasm.wasmruntime_delete(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -536,20 +521,23 @@ export class WasmRuntime {
         }
     }
     /**
-     * Disconnect from the Jazz server and drop the transport handle.
-     */
-    disconnect() {
-        wasm.wasmruntime_disconnect(this.__wbg_ptr);
-    }
-    /**
-     * @returns {any}
+     * @param {string} batch_id
+     * @returns {boolean}
      */
-    drainRejectedBatchIds() {
-        const ret = wasm.wasmruntime_drainRejectedBatchIds(this.__wbg_ptr);
+    discardLocalBatch(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_discardLocalBatch(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return ret[0] !== 0;
+    }
+    /**
+     * Disconnect from the Jazz server and drop the transport handle.
+     */
+    disconnect() {
+        wasm.wasmruntime_disconnect(this.__wbg_ptr);
     }
     /**
      * Phase 2 of 2-phase subscribe: compile graph, register subscription,
@@ -628,6 +616,15 @@ export class WasmRuntime {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    hydrateLocalBatchRecordStorageRow(bytes) {
+        const ret = wasm.wasmruntime_hydrateLocalBatchRecordStorageRow(this.__wbg_ptr, bytes);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Insert a row into a table.
      *
@@ -650,63 +647,47 @@ export class WasmRuntime {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Insert a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write.
+     * Insert a row into a table as an explicit session principal.
      * @param {string} table
      * @param {any} values
-     * @param {string} tier
+     * @param {string | null} [write_context_json]
+     * @param {string | null} [object_id]
      * @returns {any}
      */
-    insertPersisted(table, values, tier) {
+    insertWithSession(table, values, write_context_json, object_id) {
         const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_insertPersisted(this.__wbg_ptr, ptr0, len0, values, ptr1, len1);
+        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(object_id) ? 0 : passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_insertWithSession(this.__wbg_ptr, ptr0, len0, values, ptr1, len1, ptr2, len2);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Insert a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write, scoped to an explicit session
-     * principal or transactional write context.
-     * @param {string} table
-     * @param {any} values
-     * @param {string | null | undefined} write_context_json
-     * @param {string} tier
+     * @param {string} batch_id
      * @returns {any}
      */
-    insertPersistedWithSession(table, values, write_context_json, tier) {
-        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    loadBatchFate(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_insertPersistedWithSession(this.__wbg_ptr, ptr0, len0, values, ptr1, len1, ptr2, len2);
+        const ret = wasm.wasmruntime_loadBatchFate(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Insert a row into a table as an explicit session principal.
-     * @param {string} table
-     * @param {any} values
-     * @param {string | null} [write_context_json]
-     * @param {string | null} [object_id]
+     * @param {string} batch_id
      * @returns {any}
      */
-    insertWithSession(table, values, write_context_json, object_id) {
-        const ptr0 = passStringToWasm0(table, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    loadLocalBatchRecord(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(object_id) ? 0 : passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_insertWithSession(this.__wbg_ptr, ptr0, len0, values, ptr1, len1, ptr2, len2);
+        const ret = wasm.wasmruntime_loadLocalBatchRecord(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -716,10 +697,10 @@ export class WasmRuntime {
      * @param {string} batch_id
      * @returns {any}
      */
-    loadLocalBatchRecord(batch_id) {
+    loadLocalBatchRecordStorageRow(batch_id) {
         const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_loadLocalBatchRecord(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.wasmruntime_loadLocalBatchRecordStorageRow(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -817,6 +798,13 @@ export class WasmRuntime {
     onAuthFailure(callback) {
         wasm.wasmruntime_onAuthFailure(this.__wbg_ptr, callback);
     }
+    /**
+     * Register a callback for unhandled mutation errors.
+     * @param {Function} callback
+     */
+    onMutationError(callback) {
+        wasm.wasmruntime_onMutationError(this.__wbg_ptr, callback);
+    }
     /**
      * Called by JS when a sync message arrives from the server.
      *
@@ -849,13 +837,6 @@ export class WasmRuntime {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
-    /**
-     * Register a callback for outgoing sync messages.
-     * @param {Function} callback
-     */
-    onSyncMessageToSend(callback) {
-        wasm.wasmruntime_onSyncMessageToSend(this.__wbg_ptr, callback);
-    }
     /**
      * Create an ephemeral WasmRuntime backed by in-memory storage.
      *
@@ -944,12 +925,64 @@ export class WasmRuntime {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {string} batch_id
+     */
+    reconcileLocalBatchWithServer(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_reconcileLocalBatchWithServer(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Remove the current upstream server connection.
      */
     removeServer() {
         wasm.wasmruntime_removeServer(this.__wbg_ptr);
     }
+    /**
+     * @param {string} batch_id
+     * @param {string} code
+     * @param {string} reason
+     */
+    replayBatchRejection(batch_id, code, reason) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(reason, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_replayBatchRejection(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} batch_id
+     * @returns {Array<any>}
+     */
+    replayLocalBatchPayloads(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_replayLocalBatchPayloads(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} batch_id
+     */
+    retransmitLocalBatch(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_retransmitLocalBatch(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {string} batch_id
      */
@@ -1048,72 +1081,232 @@ export class WasmRuntime {
         }
     }
     /**
-     * Update a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write.
+     * Update a row by ObjectId as an explicit session principal.
+     *
+     * # Arguments
+     * * `object_id` - UUID string of target object
+     * * `values` - Partial update map (`{ columnName: Value }`)
+     * * `session_json` - Optional JSON-encoded Session used for policy checks
      * @param {string} object_id
      * @param {any} values
-     * @param {string} tier
+     * @param {string | null} [write_context_json]
      * @returns {any}
      */
-    updatePersisted(object_id, values, tier) {
+    updateWithSession(object_id, values, write_context_json) {
         const ptr0 = passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_updatePersisted(this.__wbg_ptr, ptr0, len0, values, ptr1, len1);
+        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_updateWithSession(this.__wbg_ptr, ptr0, len0, values, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Update a row immediately, returning the logical batch id that tracks
-     * replayable persisted fate for this write, scoped to an explicit session
-     * principal or transactional write context.
-     * @param {string} object_id
-     * @param {any} values
-     * @param {string | null | undefined} write_context_json
+     * Wait for a batch to settle at the requested durability tier.
+     * @param {string} batch_id
      * @param {string} tier
-     * @returns {any}
+     * @returns {Promise<any>}
      */
-    updatePersistedWithSession(object_id, values, write_context_json, tier) {
-        const ptr0 = passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    waitForBatch(batch_id, tier) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_updatePersistedWithSession(this.__wbg_ptr, ptr0, len0, values, ptr1, len1, ptr2, len2);
+        const ptr1 = passStringToWasm0(tier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmruntime_waitForBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
+}
+if (Symbol.dispose) WasmRuntime.prototype[Symbol.dispose] = WasmRuntime.prototype.free;
+
+export class WasmWorkerBridge {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmWorkerBridge.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmWorkerBridgeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWorkerBridgeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmworkerbridge_free(ptr, 0);
+    }
     /**
-     * Update a row by ObjectId as an explicit session principal.
-     *
-     * # Arguments
-     * * `object_id` - UUID string of target object
-     * * `values` - Partial update map (`{ columnName: Value }`)
-     * * `session_json` - Optional JSON-encoded Session used for policy checks
-     * @param {string} object_id
-     * @param {any} values
-     * @param {string | null} [write_context_json]
-     * @returns {any}
+     * @param {string} batch_id
      */
-    updateWithSession(object_id, values, write_context_json) {
-        const ptr0 = passStringToWasm0(object_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    acknowledgeRejectedBatch(batch_id) {
+        const ptr0 = passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(write_context_json) ? 0 : passStringToWasm0(write_context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmruntime_updateWithSession(this.__wbg_ptr, ptr0, len0, values, ptr1, len1);
+        wasm.wasmworkerbridge_acknowledgeRejectedBatch(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {Uint8Array} payload
+     */
+    applyIncomingServerPayload(payload) {
+        const ret = wasm.wasmworkerbridge_applyIncomingServerPayload(this.__wbg_ptr, payload);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Attach a Rust bridge to an externally-constructed Worker.
+     *
+     * Options are parsed at attach time; `init()` is parameter-less.
+     * @param {Worker} worker
+     * @param {WasmRuntime} runtime
+     * @param {any} options
+     * @returns {WasmWorkerBridge}
+     */
+    static attach(worker, runtime, options) {
+        _assertClass(runtime, WasmRuntime);
+        const ret = wasm.wasmworkerbridge_attach(worker, runtime.__wbg_ptr, options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return WasmWorkerBridge.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} peer_id
+     */
+    closePeer(peer_id) {
+        const ptr0 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkerbridge_closePeer(this.__wbg_ptr, ptr0, len0);
+    }
+    disconnectUpstream() {
+        wasm.wasmworkerbridge_disconnectUpstream(this.__wbg_ptr);
+    }
+    /**
+     * Get the worker-assigned client id (post-init), or `null`.
+     * @returns {any}
+     */
+    getWorkerClientId() {
+        const ret = wasm.wasmworkerbridge_getWorkerClientId(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Send the init message and resolve when the worker reports `init-ok`.
+     * Memoized — repeated calls return the same in-flight `Promise`.
+     *
+     * State setup + the init `postMessage` happen *synchronously* before
+     * this returns. Only the `init-ok | error | timeout` race awaits inside
+     * the returned `Promise`. Callers that emit a synthetic `init-ok`
+     * straight after this call (tests) don't need a microtask yield to see
+     * the resolver installed.
+     * @returns {Promise<any>}
+     */
+    init() {
+        const ret = wasm.wasmworkerbridge_init(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} peer_id
+     */
+    openPeer(peer_id) {
+        const ptr0 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkerbridge_openPeer(this.__wbg_ptr, ptr0, len0);
+    }
+    reconnectUpstream() {
+        wasm.wasmworkerbridge_reconnectUpstream(this.__wbg_ptr);
+    }
+    replayServerConnection() {
+        wasm.wasmworkerbridge_replayServerConnection(this.__wbg_ptr);
+    }
+    /**
+     * @param {string} event
+     */
+    sendLifecycleHint(event) {
+        const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkerbridge_sendLifecycleHint(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} peer_id
+     * @param {number} term
+     * @param {Array<any>} payload
+     */
+    sendPeerSync(peer_id, term, payload) {
+        const ptr0 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkerbridge_sendPeerSync(this.__wbg_ptr, ptr0, len0, term, payload);
+    }
+    /**
+     * @param {any} listeners
+     */
+    setListeners(listeners) {
+        wasm.wasmworkerbridge_setListeners(this.__wbg_ptr, listeners);
+    }
+    /**
+     * @param {Function | null} [callback]
+     */
+    setServerPayloadForwarder(callback) {
+        wasm.wasmworkerbridge_setServerPayloadForwarder(this.__wbg_ptr, isLikeNone(callback) ? 0 : addToExternrefTable0(callback));
+    }
+    /**
+     * Tear the bridge down. Synchronous side-effects (final outbox flush,
+     * noop sender install, edge removal, `Shutdown` posted) happen before
+     * this returns. The returned `Promise` resolves on `shutdown-ok` or
+     * after `SHUTDOWN_ACK_TIMEOUT_MS`.
+     * @returns {Promise<any>}
+     */
+    shutdown() {
+        const ret = wasm.wasmworkerbridge_shutdown(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Test-only: post `MainToWorkerWire::SimulateCrash` to the worker. The
+     * worker host releases OPFS handles without flushing a snapshot and
+     * posts `ShutdownOk`. Returns a Promise that resolves when the ack
+     * arrives (or after `SHUTDOWN_ACK_TIMEOUT_MS` regardless). Used by
+     * browser tests to validate WAL replay.
+     * @returns {Promise<any>}
+     */
+    simulateCrash() {
+        const ret = wasm.wasmworkerbridge_simulateCrash(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string | null} [jwt_token]
+     */
+    updateAuth(jwt_token) {
+        var ptr0 = isLikeNone(jwt_token) ? 0 : passStringToWasm0(jwt_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkerbridge_updateAuth(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Mirror of the TS-side `waitForLocalSyncFlush(batchId?)` from main: drive
+     * the main runtime's outbox to the worker, await a `SyncAck`, optionally
+     * retry while the batch is still reconciling. Returns once the worker
+     * confirms reconciliation, the 2s budget expires, or any ack times out.
+     * @param {string | null} [batch_id]
+     * @returns {Promise<any>}
+     */
+    waitForLocalSyncFlush(batch_id) {
+        var ptr0 = isLikeNone(batch_id) ? 0 : passStringToWasm0(batch_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkerbridge_waitForLocalSyncFlush(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    waitForUpstreamServerConnection() {
+        const ret = wasm.wasmworkerbridge_waitForUpstreamServerConnection(this.__wbg_ptr);
+        return ret;
     }
 }
-if (Symbol.dispose) WasmRuntime.prototype[Symbol.dispose] = WasmRuntime.prototype.free;
+if (Symbol.dispose) WasmWorkerBridge.prototype[Symbol.dispose] = WasmWorkerBridge.prototype.free;
 
 /**
  * @returns {number}
@@ -1321,6 +1514,63 @@ export function currentTimestamp() {
     return BigInt.asUintN(64, ret);
 }
 
+/**
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function decodeMainToWorkerJs(bytes) {
+    const ret = wasm.decodeMainToWorkerJs(bytes);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function decodeWorkerToMainJs(bytes) {
+    const ret = wasm.decodeWorkerToMainJs(bytes);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Drain buffered tracing entries collected by the wasm tracing layer.
+ * @returns {any}
+ */
+export function drainTraceEntries() {
+    const ret = wasm.drainTraceEntries();
+    return ret;
+}
+
+/**
+ * @param {any} value
+ * @returns {Uint8Array}
+ */
+export function encodeMainToWorkerJs(value) {
+    const ret = wasm.encodeMainToWorkerJs(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} value
+ * @returns {Uint8Array}
+ */
+export function encodeWorkerToMainJs(value) {
+    const ret = wasm.encodeWorkerToMainJs(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Generate a new UUID v7 (time-ordered).
  *
@@ -1366,6 +1616,35 @@ export function parseSchema(json) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {any} init_message
+ * @param {Array<any>} pending_messages
+ */
+export function runAsWorker(init_message, pending_messages) {
+    const ret = wasm.runAsWorker(init_message, pending_messages);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+/**
+ * Enable or disable collection of buffered tracing entries for JavaScript drains.
+ * @param {boolean} enabled
+ */
+export function setTraceEntryCollectionEnabled(enabled) {
+    wasm.setTraceEntryCollectionEnabled(enabled);
+}
+
+/**
+ * Subscribe to notifications that buffered tracing entries are ready to drain.
+ * @param {Function} callback
+ * @returns {Function}
+ */
+export function subscribeTraceEntries(callback) {
+    const ret = wasm.subscribeTraceEntries(callback);
+    return ret;
+}
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -1459,6 +1738,10 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_3c3b4f651835fbcb: function(arg0) {
             arg0._wbg_cb_unref();
         },
+        __wbg_buffer_a77cc90da4bdb503: function(arg0) {
+            const ret = arg0.buffer;
+            return ret;
+        },
         __wbg_call_368fa9c372d473ba: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = arg0.call(arg1, arg2, arg3);
             return ret;
@@ -1471,14 +1754,13 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_call_e0f65243b4670302: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
-            const ret = arg0.call(arg1, arg2, arg3, arg4, arg5, arg6);
-            return ret;
-        }, arguments); },
         __wbg_clearTimeout_113b1cde814ec762: function(arg0) {
             const ret = clearTimeout(arg0);
             return ret;
         },
+        __wbg_close_3f24d94e71812912: function(arg0) {
+            arg0.close();
+        },
         __wbg_close_e526ab9e090e8cc1: function(arg0) {
             arg0.close();
         },
@@ -1632,6 +1914,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_DedicatedWorkerGlobalScope_507cf7649cc12be1: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof DedicatedWorkerGlobalScope;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_DomException_37f96d3fb69189bd: function(arg0) {
             let result;
             try {
@@ -1895,10 +2187,23 @@ function __wbg_get_imports() {
             const ret = arg0.now();
             return ret;
         },
+        __wbg_parse_545d11396395fbbd: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
         __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
             const ret = arg0.performance;
             return ret;
         },
+        __wbg_postMessage_8723ae329b15c28a: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.postMessage(arg1, arg2);
+        }, arguments); },
+        __wbg_postMessage_b2f3a9b43857bbfb: function() { return handleError(function (arg0, arg1) {
+            arg0.postMessage(arg1);
+        }, arguments); },
+        __wbg_postMessage_e8bbce1174c34f30: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.postMessage(arg1, arg2);
+        }, arguments); },
         __wbg_process_44c7a14e11e9f69e: function(arg0) {
             const ret = arg0.process;
             return ret;
@@ -1939,6 +2244,10 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg_reject_1340e1211c01825b: function(arg0) {
+            const ret = Promise.reject(arg0);
+            return ret;
+        },
         __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
             const ret = module.require;
             return ret;
@@ -1995,6 +2304,12 @@ function __wbg_get_imports() {
         __wbg_set_onmessage_45bd33b110c54f5b: function(arg0, arg1) {
             arg0.onmessage = arg1;
         },
+        __wbg_set_onmessage_63e13b226483da6a: function(arg0, arg1) {
+            arg0.onmessage = arg1;
+        },
+        __wbg_set_onmessage_ee8dfb13200d93b8: function(arg0, arg1) {
+            arg0.onmessage = arg1;
+        },
         __wbg_set_onopen_7ffeb01f8a628209: function(arg0, arg1) {
             arg0.onopen = arg1;
         },
@@ -2025,6 +2340,10 @@ function __wbg_get_imports() {
             const ret = arg0.storage;
             return ret;
         },
+        __wbg_stringify_a2c39d991e1bf91d: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
         __wbg_subarray_0f98d3fb634508ad: function(arg0, arg1, arg2) {
             const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
             return ret;
@@ -2087,46 +2406,61 @@ function __wbg_get_imports() {
             return ret;
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3171, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3293, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h656199c36535c3e6);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 753, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hf7ddf3622752ec36);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 620, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 882, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hc18e08680cddc2e5);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 622, ret: Externref, inner_ret: Some(Externref) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h74026c82fbbbb92b);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1270, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 620, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d_3);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 998, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hbc8b7acec5ff03a6);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 1393, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h03757a48b3eba690);
             return ret;
         },
-        __wbindgen_cast_0000000000000005: function(arg0) {
+        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 975, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hcc3019a61bf91992);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000008: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000006: function(arg0) {
+        __wbindgen_cast_0000000000000009: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000009: function(arg0) {
+        __wbindgen_cast_000000000000000c: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
@@ -2151,12 +2485,25 @@ function wasm_bindgen__convert__closures_____invoke__h03757a48b3eba690(arg0, arg
     wasm.wasm_bindgen__convert__closures_____invoke__h03757a48b3eba690(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hf7ddf3622752ec36(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hf7ddf3622752ec36(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__hcc3019a61bf91992(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hcc3019a61bf91992(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d_3(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__ha139c643be38e81d_3(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__hbc8b7acec5ff03a6(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hbc8b7acec5ff03a6(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hc18e08680cddc2e5(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hc18e08680cddc2e5(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h74026c82fbbbb92b(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h74026c82fbbbb92b(arg0, arg1, arg2);
+    return ret;
 }
 
 function wasm_bindgen__convert__closures_____invoke__h656199c36535c3e6(arg0, arg1, arg2) {
@@ -2178,6 +2525,9 @@ const WasmQueryBuilderFinalization = (typeof FinalizationRegistry === 'undefined
 const WasmRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmruntime_free(ptr >>> 0, 1));
+const WasmWorkerBridgeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmworkerbridge_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -2185,6 +2535,12 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
@@ -2293,6 +2649,31 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function makeClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    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) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function makeMutClosure(arg0, arg1, f) {
     const state = { a: arg0, b: arg1, cnt: 1 };
     const real = (...args) => {