@diaryx/wasm-node 0.11.0 → 0.11.1-dev.0fde73f

package/diaryx_wasm.d.ts

@@ -140,42 +140,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();
-     *
-     * // 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);
-     * };
-     * // Similar for body WebSocket...
+     * // Get the WebSocket URL
+     * const wsUrl = client.getWsUrl();
+     * const ws = new WebSocket(wsUrl);
+     * ws.binaryType = 'arraybuffer';
      *
-     * // Poll for outgoing messages
-     * setInterval(() => {
+     * ws.onopen = async () => {
+     *   await client.onConnected();
+     *   // Drain outgoing messages
      *   let msg;
-     *   while ((msg = client.pollMetadataOutgoing())) metaWs.send(msg);
-     *   while ((msg = client.pollBodyOutgoing())) bodyWs.send(msg);
-     * }, 50);
+     *   while ((msg = client.pollOutgoingBinary())) ws.send(msg);
+     *   while ((msg = client.pollOutgoingText())) ws.send(msg);
+     * };
      *
-     * // Start sync
-     * await client.start();
+     * 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.pollOutgoingBinary())) ws.send(msg);
+     *   while ((msg = client.pollOutgoingText())) ws.send(msg);
+     * };
      * ```
      */
     createSyncClient(server_url: string, workspace_id: string, auth_token?: string | null): WasmSyncClient;
@@ -221,37 +222,11 @@ export class DiaryxBackend {
      * This avoids JSON serialization overhead for better performance.
      */
     executeJs(command: any): Promise<any>;
-    /**
-     * 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
-     * ```
-     */
-    getBodySyncStep1(doc_name: string): Uint8Array;
     /**
      * Get the current configuration from root index frontmatter.
      * Config keys are stored as `diaryx_*` properties.
      */
     getConfig(): Promise<any>;
-    /**
-     * 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);
-     * ```
-     */
-    getWorkspaceSyncStep1(): Uint8Array;
     /**
      * Check if this backend has native sync support.
      *
@@ -259,42 +234,6 @@ export class DiaryxBackend {
      * provides a unified approach that works across all platforms.
      */
     hasNativeSync(): boolean;
-    /**
-     * Check if there are pending outgoing sync messages.
-     */
-    hasOutgoingSyncMessages(): boolean;
-    /**
-     * 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));
-     * ```
-     */
-    injectBodySyncMessage(doc_name: string, message: Uint8Array, write_to_disk: boolean): Promise<any>;
-    /**
-     * 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);
-     * };
-     * ```
-     */
-    injectWorkspaceSyncMessage(message: Uint8Array, write_to_disk: boolean): Promise<any>;
     /**
      * Unsubscribe from filesystem events.
      *
@@ -331,35 +270,6 @@ export class DiaryxBackend {
      * ```
      */
     onFileSystemEvent(callback: Function): bigint;
-    /**
-     * Get count of pending outgoing sync messages.
-     */
-    outgoingSyncMessageCount(): number;
-    /**
-     * 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);
-     * ```
-     */
-    pollOutgoingSyncMessage(): any;
     /**
      * Read binary file.
      *
@@ -371,26 +281,6 @@ export class DiaryxBackend {
      * Config keys are stored as `diaryx_*` properties.
      */
     saveConfig(config_js: any): Promise<any>;
-    /**
-     * 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(): void;
-    /**
-     * Stop sync session.
-     *
-     * Clears the outgoing message queue. Call after disconnecting WebSocket.
-     */
-    stopSync(): void;
     /**
      * Write binary file.
      *
@@ -434,57 +324,22 @@ export class JsAsyncFileSystem {
 }
 
 /**
- * WASM sync client wrapper for JavaScript integration.
- *
- * 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:
+ * WASM sync client backed by the shared SyncSession protocol handler.
  *
- * - 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 {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Focus on specific files for sync.
+     * Send a focus message for specific files.
      *
-     * 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.
-     *
-     * 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.
      */
     focusFiles(files: string[]): void;
-    /**
-     * Get the initial SyncStep1 message for a body document.
-     *
-     * Returns a Uint8Array containing the framed message to send via WebSocket.
-     */
-    getBodySyncStep1(doc_name: string): Uint8Array;
-    /**
-     * Get the WebSocket URL for the body connection.
-     *
-     * Returns null if sync hasn't been configured.
-     */
-    getBodyUrl(): string | undefined;
-    /**
-     * Get the WebSocket URL for the metadata connection.
-     *
-     * Returns null if sync hasn't been configured.
-     */
-    getMetadataUrl(): string | undefined;
     /**
      * Get the server URL.
      */
@@ -494,166 +349,81 @@ export class WasmSyncClient {
      */
     getWorkspaceId(): string;
     /**
-     * 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.
-     */
-    getWorkspaceSyncStep1(): Uint8Array;
-    /**
-     * Check if there are pending body outgoing messages.
+     * Returns a URL like `wss://sync.example.com/sync2?token=...&session=...`
      */
-    hasBodyOutgoing(): boolean;
+    getWsUrl(): string;
     /**
-     * Check if there are pending body outgoing text messages.
+     * Check if there are pending events.
      */
-    hasBodyOutgoingText(): boolean;
+    hasEvents(): boolean;
     /**
-     * Check if there are pending metadata outgoing messages.
+     * Check if there are pending outgoing messages or events.
      */
-    hasMetadataOutgoing(): boolean;
+    hasOutgoing(): boolean;
     /**
-     * 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).
+     * Returns a Promise that resolves when processing is complete.
+     * After this, poll outgoing queues.
      */
-    injectBodyMessage(doc_name: string, message: Uint8Array): Promise<any>;
+    onBinaryMessage(data: Uint8Array): Promise<any>;
     /**
-     * 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.
-     */
-    injectMetadataMessage(message: Uint8Array): Promise<any>;
-    /**
-     * Check if the body connection is established.
-     */
-    isBodyConnected(): boolean;
-    /**
-     * Check if both connections are established.
-     */
-    isConnected(): boolean;
-    /**
-     * Check if the metadata connection is established.
+     * Triggers workspace SyncStep1 and handshake. After calling this,
+     * poll `pollOutgoingBinary()` / `pollOutgoingText()` to get messages to send.
      */
-    isMetadataConnected(): boolean;
+    onConnected(): Promise<any>;
     /**
-     * Check if the sync client is running.
+     * Notify that the WebSocket disconnected.
      */
-    isRunning(): boolean;
+    onDisconnected(): Promise<any>;
     /**
-     * Mark the body connection as connected.
+     * Notify that a snapshot was downloaded and imported.
      *
-     * Call this when the body WebSocket opens.
+     * Call this after handling a `downloadSnapshot` event.
      */
-    markBodyConnected(): void;
+    onSnapshotImported(): Promise<any>;
     /**
-     * Mark the body connection as disconnected.
+     * Inject an incoming text WebSocket message (JSON control message).
      *
-     * Call this when the body WebSocket closes.
+     * Returns a Promise that resolves when processing is complete.
      */
-    markBodyDisconnected(): void;
+    onTextMessage(text: string): Promise<any>;
     /**
-     * Mark the metadata connection as connected.
+     * Poll for a JSON-serialized event.
      *
-     * Call this when the metadata WebSocket opens.
+     * Returns a JSON string representing a SyncEvent, or null.
      */
-    markMetadataConnected(): void;
+    pollEvent(): string | undefined;
     /**
-     * Mark the metadata connection as disconnected.
-     *
-     * Call this when the metadata WebSocket closes.
-     */
-    markMetadataDisconnected(): void;
-    /**
-     * Poll for an outgoing body message.
+     * Poll for an outgoing binary message.
      *
      * Returns a Uint8Array if there's a message to send, null otherwise.
-     * The message is already framed with the document name.
      */
-    pollBodyOutgoing(): Uint8Array | undefined;
+    pollOutgoingBinary(): Uint8Array | undefined;
     /**
-     * Poll for an outgoing body text message (for focus/unfocus).
+     * Poll for an outgoing text message.
      *
-     * 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 string if there's a message to send, null otherwise.
      */
-    pollBodyOutgoingText(): string | undefined;
+    pollOutgoingText(): string | undefined;
     /**
-     * Poll for an outgoing metadata message.
+     * Queue a local CRDT update for sending to the server.
      *
-     * 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.
+     * Call this when local CRDT changes need to be synced.
      */
-    pollMetadataOutgoing(): Uint8Array | undefined;
+    queueLocalUpdate(doc_id: string, data: Uint8Array): Promise<any>;
     /**
-     * Queue a body update message for sending.
+     * Set a share session code.
      *
-     * This creates a Y-sync Update message for the given document
-     * and queues it for sending via the body WebSocket.
+     * Call this before connecting to join a share session.
      */
-    queueBodyUpdate(doc_name: string, content: string): void;
+    setSessionCode(code: string): void;
     /**
-     * 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.
-     */
-    queueWorkspaceUpdate(): void;
-    /**
-     * Start the sync session.
-     *
-     * 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.
-     */
-    start(): Promise<any>;
-    /**
-     * Stop the sync session.
-     *
-     * Clears all pending messages and resets state.
-     */
-    stop(): void;
-    /**
-     * 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);
-     * ```
-     */
-    subscribeBodies(files: string[]): void;
-    /**
-     * Subscribe to body sync for a specific document.
-     *
-     * This queues a SyncStep1 message for the given document.
-     * Call this when a new file is created or when opening a file for editing.
-     */
-    subscribeBody(doc_name: string): void;
-    /**
-     * 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.
      */
     unfocusFiles(files: string[]): void;
 }
@@ -677,7 +447,8 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly init: () => void;
+    readonly now_timestamp: () => [number, number];
+    readonly today_formatted: (a: number, b: number) => [number, number];
     readonly __wbg_jsasyncfilesystem_free: (a: number, b: number) => void;
     readonly jsasyncfilesystem_has_callback: (a: number, b: number, c: number) => number;
     readonly jsasyncfilesystem_new: (a: any) => number;
@@ -690,57 +461,34 @@ export interface InitOutput {
     readonly diaryxbackend_eventSubscriberCount: (a: number) => number;
     readonly diaryxbackend_execute: (a: number, b: number, c: number) => any;
     readonly diaryxbackend_executeJs: (a: number, b: any) => any;
-    readonly diaryxbackend_getBodySyncStep1: (a: number, b: number, c: number) => any;
     readonly diaryxbackend_getConfig: (a: number) => any;
-    readonly diaryxbackend_getWorkspaceSyncStep1: (a: number) => any;
     readonly diaryxbackend_hasNativeSync: (a: number) => number;
-    readonly diaryxbackend_hasOutgoingSyncMessages: (a: number) => number;
-    readonly diaryxbackend_injectBodySyncMessage: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
-    readonly diaryxbackend_injectWorkspaceSyncMessage: (a: number, b: number, c: number, d: number) => any;
     readonly diaryxbackend_offFileSystemEvent: (a: number, b: bigint) => number;
     readonly diaryxbackend_onFileSystemEvent: (a: number, b: any) => bigint;
-    readonly diaryxbackend_outgoingSyncMessageCount: (a: number) => number;
-    readonly diaryxbackend_pollOutgoingSyncMessage: (a: number) => any;
     readonly diaryxbackend_readBinary: (a: number, b: number, c: number) => any;
     readonly diaryxbackend_saveConfig: (a: number, b: any) => any;
-    readonly diaryxbackend_startSync: (a: number) => void;
-    readonly diaryxbackend_stopSync: (a: number) => void;
     readonly diaryxbackend_writeBinary: (a: number, b: number, c: number, d: any) => any;
-    readonly now_timestamp: () => [number, number];
-    readonly today_formatted: (a: number, b: number) => [number, number];
     readonly wasmsyncclient_focusFiles: (a: number, b: number, c: number) => void;
-    readonly wasmsyncclient_getBodySyncStep1: (a: number, b: number, c: number) => any;
-    readonly wasmsyncclient_getBodyUrl: (a: number) => [number, number];
-    readonly wasmsyncclient_getMetadataUrl: (a: number) => [number, number];
     readonly wasmsyncclient_getServerUrl: (a: number) => [number, number];
     readonly wasmsyncclient_getWorkspaceId: (a: number) => [number, number];
-    readonly wasmsyncclient_getWorkspaceSyncStep1: (a: number) => any;
-    readonly wasmsyncclient_hasBodyOutgoing: (a: number) => number;
-    readonly wasmsyncclient_hasBodyOutgoingText: (a: number) => number;
-    readonly wasmsyncclient_hasMetadataOutgoing: (a: number) => number;
-    readonly wasmsyncclient_injectBodyMessage: (a: number, b: number, c: number, d: number, e: number) => any;
-    readonly wasmsyncclient_injectMetadataMessage: (a: number, b: number, c: number) => any;
-    readonly wasmsyncclient_isBodyConnected: (a: number) => number;
-    readonly wasmsyncclient_isConnected: (a: number) => number;
-    readonly wasmsyncclient_isMetadataConnected: (a: number) => number;
-    readonly wasmsyncclient_isRunning: (a: number) => number;
-    readonly wasmsyncclient_markBodyConnected: (a: number) => void;
-    readonly wasmsyncclient_markBodyDisconnected: (a: number) => void;
-    readonly wasmsyncclient_markMetadataConnected: (a: number) => void;
-    readonly wasmsyncclient_markMetadataDisconnected: (a: number) => void;
-    readonly wasmsyncclient_pollBodyOutgoing: (a: number) => any;
-    readonly wasmsyncclient_pollBodyOutgoingText: (a: number) => [number, number];
-    readonly wasmsyncclient_pollMetadataOutgoing: (a: number) => any;
-    readonly wasmsyncclient_queueBodyUpdate: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-    readonly wasmsyncclient_queueWorkspaceUpdate: (a: number) => [number, number];
-    readonly wasmsyncclient_start: (a: number) => any;
-    readonly wasmsyncclient_stop: (a: number) => void;
-    readonly wasmsyncclient_subscribeBodies: (a: number, b: number, c: number) => void;
-    readonly wasmsyncclient_subscribeBody: (a: number, b: number, c: number) => void;
+    readonly wasmsyncclient_getWsUrl: (a: number) => [number, number];
+    readonly wasmsyncclient_hasEvents: (a: number) => number;
+    readonly wasmsyncclient_hasOutgoing: (a: number) => number;
+    readonly wasmsyncclient_onBinaryMessage: (a: number, b: number, c: number) => any;
+    readonly wasmsyncclient_onConnected: (a: number) => any;
+    readonly wasmsyncclient_onDisconnected: (a: number) => any;
+    readonly wasmsyncclient_onSnapshotImported: (a: number) => any;
+    readonly wasmsyncclient_onTextMessage: (a: number, b: number, c: number) => any;
+    readonly wasmsyncclient_pollEvent: (a: number) => [number, number];
+    readonly wasmsyncclient_pollOutgoingBinary: (a: number) => any;
+    readonly wasmsyncclient_pollOutgoingText: (a: number) => [number, number];
+    readonly wasmsyncclient_queueLocalUpdate: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasmsyncclient_setSessionCode: (a: number, b: number, c: number) => void;
     readonly wasmsyncclient_unfocusFiles: (a: number, b: number, c: number) => void;
-    readonly wasm_bindgen__closure__destroy__hcf0c613855ef990f: (a: number, b: number) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__h4ffe3e306d53c3fd: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen__convert__closures_____invoke__hf4ed7050e4f49b30: (a: number, b: number, c: any) => void;
+    readonly init: () => void;
+    readonly wasm_bindgen__closure__destroy__h1a6596f161fce41d: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hcef8d709b492a91f: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hf6386362379cecd0: (a: number, b: number, c: any) => 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;