@diaryx/wasm-node 0.11.0 → 0.11.1-dev.193efc4

package/diaryx_wasm.js

@@ -75,42 +75,43 @@ export class DiaryxBackend {
     /**
      * Create a new sync client for the given server and workspace.
      *
-     * This creates a `WasmSyncClient` that wraps `SyncClient<CallbackTransport>`.
-     * JavaScript manages WebSocket connections while Rust handles all sync logic.
+     * Creates a `WasmSyncClient` backed by the shared `SyncSession` protocol
+     * handler. JavaScript manages the WebSocket while Rust handles all sync
+     * protocol logic (handshake, message routing, framing).
      *
      * ## Example
      *
      * ```javascript
      * const client = backend.createSyncClient(
-     *   'wss://sync.example.com/sync',
+     *   'https://sync.example.com',
      *   'my-workspace-id',
      *   'auth-token-optional'
      * );
      *
-     * // Get URLs and create WebSocket connections
-     * const metaUrl = client.getMetadataUrl();
-     * const bodyUrl = client.getBodyUrl();
+     * // Get the WebSocket URL
+     * const wsUrl = client.getWsUrl();
+     * const ws = new WebSocket(wsUrl);
+     * ws.binaryType = 'arraybuffer';
      *
-     * // Create WebSockets and connect them to the client
-     * const metaWs = new WebSocket(metaUrl);
-     * metaWs.binaryType = 'arraybuffer';
-     * metaWs.onopen = () => client.markMetadataConnected();
-     * metaWs.onclose = () => client.markMetadataDisconnected();
-     * metaWs.onmessage = async (e) => {
-     *   const response = await client.injectMetadataMessage(new Uint8Array(e.data));
-     *   if (response) metaWs.send(response);
+     * ws.onopen = async () => {
+     *   await client.onConnected();
+     *   // Drain outgoing messages
+     *   let msg;
+     *   while ((msg = client.pollOutgoingBinary())) ws.send(msg);
+     *   while ((msg = client.pollOutgoingText())) ws.send(msg);
      * };
-     * // Similar for body WebSocket...
      *
-     * // Poll for outgoing messages
-     * setInterval(() => {
+     * ws.onmessage = async (e) => {
+     *   if (typeof e.data === 'string') {
+     *     await client.onTextMessage(e.data);
+     *   } else {
+     *     await client.onBinaryMessage(new Uint8Array(e.data));
+     *   }
+     *   // Drain outgoing messages and events
      *   let msg;
-     *   while ((msg = client.pollMetadataOutgoing())) metaWs.send(msg);
-     *   while ((msg = client.pollBodyOutgoing())) bodyWs.send(msg);
-     * }, 50);
-     *
-     * // Start sync
-     * await client.start();
+     *   while ((msg = client.pollOutgoingBinary())) ws.send(msg);
+     *   while ((msg = client.pollOutgoingText())) ws.send(msg);
+     * };
      * ```
      * @param {string} server_url
      * @param {string} workspace_id
@@ -193,26 +194,6 @@ export class DiaryxBackend {
         const ret = wasm.diaryxbackend_executeJs(this.__wbg_ptr, command);
         return ret;
     }
-    /**
-     * Get initial body sync step1 message for a document.
-     *
-     * Returns a Uint8Array containing the Y-sync step1 message for
-     * the specified document's body content.
-     *
-     * ## Example
-     * ```javascript
-     * const step1 = backend.getBodySyncStep1("notes/my-note.md");
-     * // Frame it for multiplexed connection and send
-     * ```
-     * @param {string} doc_name
-     * @returns {Uint8Array}
-     */
-    getBodySyncStep1(doc_name) {
-        const ptr0 = passStringToWasm0(doc_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.diaryxbackend_getBodySyncStep1(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
     /**
      * Get the current configuration from root index frontmatter.
      * Config keys are stored as `diaryx_*` properties.
@@ -222,23 +203,6 @@ export class DiaryxBackend {
         const ret = wasm.diaryxbackend_getConfig(this.__wbg_ptr);
         return ret;
     }
-    /**
-     * Get initial workspace sync step1 message.
-     *
-     * Returns a Uint8Array containing the Y-sync step1 message to send
-     * over the WebSocket to initiate workspace metadata sync.
-     *
-     * ## Example
-     * ```javascript
-     * const step1 = backend.getWorkspaceSyncStep1();
-     * ws.send(step1);
-     * ```
-     * @returns {Uint8Array}
-     */
-    getWorkspaceSyncStep1() {
-        const ret = wasm.diaryxbackend_getWorkspaceSyncStep1(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Check if this backend has native sync support.
      *
@@ -250,65 +214,6 @@ export class DiaryxBackend {
         const ret = wasm.diaryxbackend_hasNativeSync(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Check if there are pending outgoing sync messages.
-     * @returns {boolean}
-     */
-    hasOutgoingSyncMessages() {
-        const ret = wasm.diaryxbackend_hasOutgoingSyncMessages(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Inject an incoming body sync message.
-     *
-     * Call this when the WebSocket receives a message for a body document.
-     * The message should already be unframed (doc_name extracted separately).
-     * Returns a response message to send back, or null if no response is needed.
-     *
-     * ## Example
-     * ```javascript
-     * // After unframing the multiplexed message:
-     * const response = await backend.injectBodySyncMessage(docName, data, true);
-     * if (response) ws.send(frameBodyMessage(docName, response));
-     * ```
-     * @param {string} doc_name
-     * @param {Uint8Array} message
-     * @param {boolean} write_to_disk
-     * @returns {Promise<any>}
-     */
-    injectBodySyncMessage(doc_name, message, write_to_disk) {
-        const ptr0 = passStringToWasm0(doc_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.diaryxbackend_injectBodySyncMessage(this.__wbg_ptr, ptr0, len0, ptr1, len1, write_to_disk);
-        return ret;
-    }
-    /**
-     * Inject an incoming workspace sync message.
-     *
-     * Call this when the WebSocket receives a message for the workspace
-     * (metadata) connection. Returns a response message to send back,
-     * or null if no response is needed.
-     *
-     * ## Example
-     * ```javascript
-     * ws.onmessage = (event) => {
-     *   const data = new Uint8Array(event.data);
-     *   const response = backend.injectWorkspaceSyncMessage(data, true);
-     *   if (response) ws.send(response);
-     * };
-     * ```
-     * @param {Uint8Array} message
-     * @param {boolean} write_to_disk
-     * @returns {Promise<any>}
-     */
-    injectWorkspaceSyncMessage(message, write_to_disk) {
-        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.diaryxbackend_injectWorkspaceSyncMessage(this.__wbg_ptr, ptr0, len0, write_to_disk);
-        return ret;
-    }
     /**
      * Unsubscribe from filesystem events.
      *
@@ -355,43 +260,6 @@ export class DiaryxBackend {
         const ret = wasm.diaryxbackend_onFileSystemEvent(this.__wbg_ptr, callback);
         return BigInt.asUintN(64, ret);
     }
-    /**
-     * Get count of pending outgoing sync messages.
-     * @returns {number}
-     */
-    outgoingSyncMessageCount() {
-        const ret = wasm.diaryxbackend_outgoingSyncMessageCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Poll for an outgoing sync message.
-     *
-     * Returns the next outgoing message as a JavaScript object with:
-     * - `docName`: Document name ("workspace" or file path)
-     * - `message`: Uint8Array message data
-     * - `isBody`: Boolean indicating body (true) or workspace (false)
-     *
-     * Returns null if no messages are queued.
-     *
-     * ## Example
-     * ```javascript
-     * setInterval(() => {
-     *   let msg;
-     *   while ((msg = backend.pollOutgoingSyncMessage()) !== null) {
-     *     if (msg.isBody) {
-     *       bodyWs.send(frameBodyMessage(msg.docName, msg.message));
-     *     } else {
-     *       workspaceWs.send(msg.message);
-     *     }
-     *   }
-     * }, 50);
-     * ```
-     * @returns {any}
-     */
-    pollOutgoingSyncMessage() {
-        const ret = wasm.diaryxbackend_pollOutgoingSyncMessage(this.__wbg_ptr);
-        return ret;
-    }
     /**
      * Read binary file.
      *
@@ -415,30 +283,6 @@ export class DiaryxBackend {
         const ret = wasm.diaryxbackend_saveConfig(this.__wbg_ptr, config_js);
         return ret;
     }
-    /**
-     * Start sync session and set up event bridge.
-     *
-     * This wires up the sync manager's event callback to queue outgoing
-     * messages. Call this before connecting WebSocket.
-     *
-     * ## Example
-     * ```javascript
-     * backend.startSync();
-     * const ws = new WebSocket(url);
-     * // ... rest of setup
-     * ```
-     */
-    startSync() {
-        wasm.diaryxbackend_startSync(this.__wbg_ptr);
-    }
-    /**
-     * Stop sync session.
-     *
-     * Clears the outgoing message queue. Call after disconnecting WebSocket.
-     */
-    stopSync() {
-        wasm.diaryxbackend_stopSync(this.__wbg_ptr);
-    }
     /**
      * Write binary file.
      *
@@ -513,17 +357,11 @@ export class JsAsyncFileSystem {
 if (Symbol.dispose) JsAsyncFileSystem.prototype[Symbol.dispose] = JsAsyncFileSystem.prototype.free;
 
 /**
- * WASM sync client wrapper for JavaScript integration.
+ * WASM sync client backed by the shared SyncSession protocol handler.
  *
- * This struct wraps a `SyncClient<CallbackTransport>` and exposes its
- * functionality to JavaScript via wasm-bindgen. It manages two transports
- * (metadata and body) and provides methods for:
- *
- * - Getting WebSocket URLs for connection
- * - Notifying connection status changes
- * - Injecting incoming messages
- * - Polling for outgoing messages
- * - Starting and stopping sync
+ * JavaScript feeds WebSocket events in via `onConnected()`, `onBinaryMessage()`,
+ * etc. The client processes them through `SyncSession` and queues outgoing
+ * messages/events for JavaScript to poll.
  */
 export class WasmSyncClient {
     static __wrap(ptr) {
@@ -544,20 +382,9 @@ export class WasmSyncClient {
         wasm.__wbg_wasmsyncclient_free(ptr, 0);
     }
     /**
-     * Focus on specific files for sync.
-     *
-     * Sends a focus message to the server indicating which files the client
-     * is currently interested in syncing. Other clients will receive a
-     * `focus_list_changed` notification and can subscribe to sync updates
-     * for these files.
+     * Send a focus message for specific files.
      *
-     * Call this when a file is opened in the editor.
-     *
-     * ## Example
-     * ```javascript
-     * // User opens a file
-     * client.focusFiles(["workspace/notes.md"]);
-     * ```
+     * Other clients will be notified which files this client is interested in.
      * @param {string[]} files
      */
     focusFiles(files) {
@@ -565,49 +392,6 @@ export class WasmSyncClient {
         const len0 = WASM_VECTOR_LEN;
         wasm.wasmsyncclient_focusFiles(this.__wbg_ptr, ptr0, len0);
     }
-    /**
-     * Get the initial SyncStep1 message for a body document.
-     *
-     * Returns a Uint8Array containing the framed message to send via WebSocket.
-     * @param {string} doc_name
-     * @returns {Uint8Array}
-     */
-    getBodySyncStep1(doc_name) {
-        const ptr0 = passStringToWasm0(doc_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsyncclient_getBodySyncStep1(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Get the WebSocket URL for the body connection.
-     *
-     * Returns null if sync hasn't been configured.
-     * @returns {string | undefined}
-     */
-    getBodyUrl() {
-        const ret = wasm.wasmsyncclient_getBodyUrl(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        }
-        return v1;
-    }
-    /**
-     * Get the WebSocket URL for the metadata connection.
-     *
-     * Returns null if sync hasn't been configured.
-     * @returns {string | undefined}
-     */
-    getMetadataUrl() {
-        const ret = wasm.wasmsyncclient_getMetadataUrl(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        }
-        return v1;
-    }
     /**
      * Get the server URL.
      * @returns {string}
@@ -641,158 +425,103 @@ export class WasmSyncClient {
         }
     }
     /**
-     * Get the initial SyncStep1 message for workspace sync.
+     * Get the WebSocket URL for the v2 sync connection.
      *
-     * Returns a Uint8Array containing the message to send via WebSocket.
-     * @returns {Uint8Array}
-     */
-    getWorkspaceSyncStep1() {
-        const ret = wasm.wasmsyncclient_getWorkspaceSyncStep1(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Check if there are pending body outgoing messages.
-     * @returns {boolean}
+     * Returns a URL like `wss://sync.example.com/sync2?token=...&session=...`
+     * @returns {string}
      */
-    hasBodyOutgoing() {
-        const ret = wasm.wasmsyncclient_hasBodyOutgoing(this.__wbg_ptr);
-        return ret !== 0;
+    getWsUrl() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmsyncclient_getWsUrl(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);
+        }
     }
     /**
-     * Check if there are pending body outgoing text messages.
+     * Check if there are pending events.
      * @returns {boolean}
      */
-    hasBodyOutgoingText() {
-        const ret = wasm.wasmsyncclient_hasBodyOutgoingText(this.__wbg_ptr);
+    hasEvents() {
+        const ret = wasm.wasmsyncclient_hasEvents(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * Check if there are pending metadata outgoing messages.
+     * Check if there are pending outgoing messages or events.
      * @returns {boolean}
      */
-    hasMetadataOutgoing() {
-        const ret = wasm.wasmsyncclient_hasMetadataOutgoing(this.__wbg_ptr);
+    hasOutgoing() {
+        const ret = wasm.wasmsyncclient_hasOutgoing(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * Inject an incoming body message.
+     * Inject an incoming binary WebSocket message.
      *
-     * Call this when the body WebSocket receives a message.
-     * The message should already be unframed (doc_name extracted separately).
-     * Returns a Promise that resolves to a Uint8Array response (or null).
-     * @param {string} doc_name
-     * @param {Uint8Array} message
+     * Returns a Promise that resolves when processing is complete.
+     * After this, poll outgoing queues.
+     * @param {Uint8Array} data
      * @returns {Promise<any>}
      */
-    injectBodyMessage(doc_name, message) {
-        const ptr0 = passStringToWasm0(doc_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    onBinaryMessage(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsyncclient_injectBodyMessage(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.wasmsyncclient_onBinaryMessage(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * Inject an incoming metadata message.
-     *
-     * Call this when the metadata WebSocket receives a message.
-     * Returns a Promise that resolves to a Uint8Array response (or null).
+     * Notify that the WebSocket connected.
      *
-     * The response should be sent back via the WebSocket if not null.
-     * @param {Uint8Array} message
+     * Triggers workspace SyncStep1 and handshake. After calling this,
+     * poll `pollOutgoingBinary()` / `pollOutgoingText()` to get messages to send.
      * @returns {Promise<any>}
      */
-    injectMetadataMessage(message) {
-        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsyncclient_injectMetadataMessage(this.__wbg_ptr, ptr0, len0);
+    onConnected() {
+        const ret = wasm.wasmsyncclient_onConnected(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Check if the body connection is established.
-     * @returns {boolean}
-     */
-    isBodyConnected() {
-        const ret = wasm.wasmsyncclient_isBodyConnected(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if both connections are established.
-     * @returns {boolean}
-     */
-    isConnected() {
-        const ret = wasm.wasmsyncclient_isConnected(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if the metadata connection is established.
-     * @returns {boolean}
-     */
-    isMetadataConnected() {
-        const ret = wasm.wasmsyncclient_isMetadataConnected(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if the sync client is running.
-     * @returns {boolean}
-     */
-    isRunning() {
-        const ret = wasm.wasmsyncclient_isRunning(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Mark the body connection as connected.
-     *
-     * Call this when the body WebSocket opens.
-     */
-    markBodyConnected() {
-        wasm.wasmsyncclient_markBodyConnected(this.__wbg_ptr);
-    }
-    /**
-     * Mark the body connection as disconnected.
-     *
-     * Call this when the body WebSocket closes.
-     */
-    markBodyDisconnected() {
-        wasm.wasmsyncclient_markBodyDisconnected(this.__wbg_ptr);
-    }
-    /**
-     * Mark the metadata connection as connected.
-     *
-     * Call this when the metadata WebSocket opens.
+     * Notify that the WebSocket disconnected.
+     * @returns {Promise<any>}
      */
-    markMetadataConnected() {
-        wasm.wasmsyncclient_markMetadataConnected(this.__wbg_ptr);
+    onDisconnected() {
+        const ret = wasm.wasmsyncclient_onDisconnected(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Mark the metadata connection as disconnected.
+     * Notify that a snapshot was downloaded and imported.
      *
-     * Call this when the metadata WebSocket closes.
+     * Call this after handling a `downloadSnapshot` event.
+     * @returns {Promise<any>}
      */
-    markMetadataDisconnected() {
-        wasm.wasmsyncclient_markMetadataDisconnected(this.__wbg_ptr);
+    onSnapshotImported() {
+        const ret = wasm.wasmsyncclient_onSnapshotImported(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Poll for an outgoing body message.
+     * Inject an incoming text WebSocket message (JSON control message).
      *
-     * Returns a Uint8Array if there's a message to send, null otherwise.
-     * The message is already framed with the document name.
-     * @returns {Uint8Array | undefined}
+     * Returns a Promise that resolves when processing is complete.
+     * @param {string} text
+     * @returns {Promise<any>}
      */
-    pollBodyOutgoing() {
-        const ret = wasm.wasmsyncclient_pollBodyOutgoing(this.__wbg_ptr);
+    onTextMessage(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsyncclient_onTextMessage(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * Poll for an outgoing body text message (for focus/unfocus).
+     * Poll for a JSON-serialized event.
      *
-     * Returns a string if there's a text message to send, null otherwise.
-     * JavaScript should call this in a polling loop and send any messages
-     * via the body WebSocket as text frames.
+     * Returns a JSON string representing a SyncEvent, or null.
      * @returns {string | undefined}
      */
-    pollBodyOutgoingText() {
-        const ret = wasm.wasmsyncclient_pollBodyOutgoingText(this.__wbg_ptr);
+    pollEvent() {
+        const ret = wasm.wasmsyncclient_pollEvent(this.__wbg_ptr);
         let v1;
         if (ret[0] !== 0) {
             v1 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -801,112 +530,59 @@ export class WasmSyncClient {
         return v1;
     }
     /**
-     * Poll for an outgoing metadata message.
+     * Poll for an outgoing binary message.
      *
      * Returns a Uint8Array if there's a message to send, null otherwise.
-     * JavaScript should call this in a polling loop and send any messages
-     * via the metadata WebSocket.
      * @returns {Uint8Array | undefined}
      */
-    pollMetadataOutgoing() {
-        const ret = wasm.wasmsyncclient_pollMetadataOutgoing(this.__wbg_ptr);
+    pollOutgoingBinary() {
+        const ret = wasm.wasmsyncclient_pollOutgoingBinary(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Queue a body update message for sending.
+     * Poll for an outgoing text message.
      *
-     * This creates a Y-sync Update message for the given document
-     * and queues it for sending via the body WebSocket.
-     * @param {string} doc_name
-     * @param {string} content
-     */
-    queueBodyUpdate(doc_name, content) {
-        const ptr0 = passStringToWasm0(doc_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsyncclient_queueBodyUpdate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * Queue a workspace update message for sending.
-     *
-     * This creates a Y-sync Update message from the current workspace state
-     * and queues it for sending via the metadata WebSocket.
+     * Returns a string if there's a message to send, null otherwise.
+     * @returns {string | undefined}
      */
-    queueWorkspaceUpdate() {
-        const ret = wasm.wasmsyncclient_queueWorkspaceUpdate(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    pollOutgoingText() {
+        const ret = wasm.wasmsyncclient_pollOutgoingText(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
+        return v1;
     }
     /**
-     * Start the sync session.
+     * Queue a local CRDT update for sending to the server.
      *
-     * This should be called after both WebSocket connections are established.
-     * It sends the initial SyncStep1 messages and subscribes to all body docs.
-     *
-     * Returns a Promise that resolves when initial sync messages are sent.
+     * Call this when local CRDT changes need to be synced.
+     * @param {string} doc_id
+     * @param {Uint8Array} data
      * @returns {Promise<any>}
      */
-    start() {
-        const ret = wasm.wasmsyncclient_start(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Stop the sync session.
-     *
-     * Clears all pending messages and resets state.
-     */
-    stop() {
-        wasm.wasmsyncclient_stop(this.__wbg_ptr);
-    }
-    /**
-     * Subscribe to body sync for the currently focused files.
-     *
-     * This sends SyncStep1 messages for all files in the provided list.
-     * Call this after receiving a `focus_list_changed` message from the server.
-     *
-     * ## Example
-     * ```javascript
-     * // Received focus_list_changed event
-     * const files = event.files;
-     * client.subscribeBodies(files);
-     * ```
-     * @param {string[]} files
-     */
-    subscribeBodies(files) {
-        const ptr0 = passArrayJsValueToWasm0(files, wasm.__wbindgen_malloc);
+    queueLocalUpdate(doc_id, data) {
+        const ptr0 = passStringToWasm0(doc_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.wasmsyncclient_subscribeBodies(this.__wbg_ptr, ptr0, len0);
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsyncclient_queueLocalUpdate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
     }
     /**
-     * Subscribe to body sync for a specific document.
+     * Set a share session code.
      *
-     * This queues a SyncStep1 message for the given document.
-     * Call this when a new file is created or when opening a file for editing.
-     * @param {string} doc_name
+     * Call this before connecting to join a share session.
+     * @param {string} code
      */
-    subscribeBody(doc_name) {
-        const ptr0 = passStringToWasm0(doc_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    setSessionCode(code) {
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.wasmsyncclient_subscribeBody(this.__wbg_ptr, ptr0, len0);
+        wasm.wasmsyncclient_setSessionCode(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Unfocus specific files.
-     *
-     * Sends an unfocus message to the server indicating the client is no
-     * longer interested in syncing these files.
-     *
-     * Call this when a file is closed in the editor.
-     *
-     * ## Example
-     * ```javascript
-     * // User closes a file
-     * client.unfocusFiles(["workspace/notes.md"]);
-     * ```
+     * Send an unfocus message for specific files.
      * @param {string[]} files
      */
     unfocusFiles(files) {
@@ -1186,7 +862,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h4ffe3e306d53c3fd(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h4e796b59e8c15a06(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1265,10 +941,6 @@ function __wbg_get_imports() {
         __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = Reflect.set(arg0, arg1, arg2);
-            return ret;
-        }, arguments); },
         __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
@@ -1312,8 +984,8 @@ function __wbg_get_imports() {
             console.warn(arg0, arg1, arg2, arg3);
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 550, function: Function { arguments: [Externref], shim_idx: 551, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hcf0c613855ef990f, wasm_bindgen__convert__closures_____invoke__hf4ed7050e4f49b30);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 594, function: Function { arguments: [Externref], shim_idx: 595, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h676385b1ad3ac0e9, wasm_bindgen__convert__closures_____invoke__he720d3228b6c7e0b);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -1357,12 +1029,12 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__hf4ed7050e4f49b30(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hf4ed7050e4f49b30(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__he720d3228b6c7e0b(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__he720d3228b6c7e0b(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h4ffe3e306d53c3fd(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h4ffe3e306d53c3fd(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h4e796b59e8c15a06(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h4e796b59e8c15a06(arg0, arg1, arg2, arg3);
 }
 
 const DiaryxBackendFinalization = (typeof FinalizationRegistry === 'undefined')