@docukit/docsync 0.0.1-alpha.1 → 0.2.0-alpha.1

package/dist/src/client/index.js

@@ -1,5 +1,17 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 import { io } from "socket.io-client";
+import { createClientEventEmitter } from "./utils/events.js";
+import { handleConnect } from "./handlers/connection/connect.js";
+import { handleDeleteDoc } from "./handlers/clientInitiated/deleteDoc.js";
+import { handleDisconnect } from "./handlers/connection/disconnect.js";
+import { handleDirty } from "./handlers/serverInitiated/dirty.js";
+import { handlePresence } from "./handlers/clientInitiated/presence.js";
+import { handlePresence as handleServerPresence } from "./handlers/serverInitiated/presence.js";
+import { handleSync } from "./handlers/clientInitiated/sync.js";
+import { handleUnsubscribe } from "./handlers/clientInitiated/unsubscribe.js";
+import { BCHelper } from "./utils/BCHelper.js";
+import { getDeviceId } from "./utils/getDeviceId.js";
+import { getOwnPresencePatch } from "./utils/getOwnPresencePatch.js";
 export class DocSyncClient {
     _docBinding;
     _docsCache = new Map();
@@ -8,7 +20,7 @@ export class DocSyncClient {
     /** Client-generated id for presence (works offline; sent in auth so server uses same key) */
     _clientId;
     _shouldBroadcast = true;
-    _broadcastChannel;
+    _bcHelper;
     _socket;
     // Flow control state (batching, debouncing, push queueing)
     _localOpsBatchState = new Map();
@@ -16,13 +28,8 @@ export class DocSyncClient {
     _presenceDebounceState = new Map();
     _presenceDebounce = 200;
     _pushStatusByDocId = new Map();
-    // Event handlers - ChangeHandler and SyncHandler use default (unknown) to allow covariance
-    _connectHandlers = new Set();
-    _disconnectHandlers = new Set();
-    _changeHandlers = new Set();
-    _syncHandlers = new Set();
-    _docLoadHandlers = new Set();
-    _docUnloadHandlers = new Set();
+    /** Typed as unknown so DocSyncClient remains covariant in O, S (assignable to DocSyncClient base). */
+    _events = createClientEventEmitter();
     constructor(config) {
         if (typeof window === "undefined")
             throw new Error("DocSyncClient can only be used in the browser");
@@ -33,88 +40,23 @@ export class DocSyncClient {
         this._localPromise = (async () => {
             const identity = await local.getIdentity();
             const provider = new local.provider(identity);
-            // Initialize BroadcastChannel with user-specific channel name
-            // This ensures only tabs of the same user share operations
-            this._broadcastChannel = new BroadcastChannel(`docsync:${identity.userId}`);
-            this._broadcastChannel.onmessage = async (ev) => {
-                // RECEIVED MESSAGES
-                if (ev.data.type === "OPERATIONS") {
-                    // Another tab is pushing operations - they are responsible for pushing to server
-                    // We just need to coordinate push status to avoid conflicts
-                    const currentStatus = this._pushStatusByDocId.get(ev.data.docId) ?? "idle";
-                    if (currentStatus === "pushing") {
-                        // Mark as busy to avoid concurrent pushes
-                        this._pushStatusByDocId.set(ev.data.docId, "pushing-with-pending");
-                    }
-                    // Note: We don't call saveRemote here - the sender is responsible for pushing
-                    // If the sender is offline, the push will happen when they reconnect
-                    void this._applyOperations(ev.data.operations, ev.data.docId);
-                    // Apply presence after ops so the doc is updated first (avoids cursor lag)
-                    if (ev.data.presence) {
-                        const cacheEntry = this._docsCache.get(ev.data.docId);
-                        if (cacheEntry)
-                            this._applyPresencePatch(cacheEntry, ev.data.presence);
-                    }
-                    return;
-                }
-                if (ev.data.type === "PRESENCE") {
-                    const { docId, presence } = ev.data;
-                    const cacheEntry = this._docsCache.get(docId);
-                    if (!cacheEntry)
-                        return;
-                    this._applyPresencePatch(cacheEntry, presence);
-                }
-            };
+            this._bcHelper = new BCHelper(this, identity.userId);
             return { provider, identity };
         })();
         this._deviceId = getDeviceId();
         this._socket = io(config.server.url, {
             auth: (cb) => {
-                void config.server.auth.getToken().then((token) => {
+                void Promise.resolve(config.server.auth.getToken()).then((token) => {
                     cb({ token, deviceId: this._deviceId, clientId: this._clientId });
                 });
             },
             // Performance optimizations for testing
             transports: ["websocket"], // Skip polling, go straight to WebSocket
         });
-        this._socket.on("connect", () => {
-            // Emit connect event
-            this._emit(this._connectHandlers);
-            // Push pending operations for all loaded docs
-            for (const docId of this._docsCache.keys()) {
-                this.saveRemote({ docId });
-            }
-        });
-        this._socket.on("disconnect", (reason) => {
-            this._pushStatusByDocId.clear();
-            // Clear pending presence debounce timers so their callbacks never run after disconnect
-            for (const state of this._presenceDebounceState.values()) {
-                clearTimeout(state.timeout);
-            }
-            this._presenceDebounceState.clear();
-            // Tell other tabs to remove this client's presence (clientId works offline)
-            for (const docId of this._docsCache.keys()) {
-                this._sendMessage({
-                    type: "PRESENCE",
-                    docId,
-                    presence: { [this._clientId]: null },
-                });
-            }
-            this._emit(this._disconnectHandlers, { reason });
-        });
-        this._socket.on("connect_error", (err) => {
-            this._emit(this._disconnectHandlers, { reason: err.message });
-        });
-        // Listen for dirty notifications from server
-        this._socket.on("dirty", (payload) => {
-            this.saveRemote({ docId: payload.docId });
-        });
-        this._socket.on("presence", (payload) => {
-            const cacheEntry = this._docsCache.get(payload.docId);
-            if (!cacheEntry)
-                return;
-            this._applyPresencePatch(cacheEntry, payload.presence);
-        });
+        handleConnect({ client: this });
+        handleDisconnect({ client: this });
+        handleDirty({ client: this });
+        handleServerPresence({ client: this });
     }
     connect() {
         this._socket.connect();
@@ -122,88 +64,6 @@ export class DocSyncClient {
     disconnect() {
         this._socket.disconnect();
     }
-    async _applyOperations(operations, docId) {
-        const docFromCache = this._docsCache.get(docId);
-        if (!docFromCache)
-            return;
-        const doc = await docFromCache.promisedDoc;
-        if (!doc)
-            return;
-        this._shouldBroadcast = false;
-        this._docBinding.applyOperations(doc, operations);
-        this._shouldBroadcast = true;
-        // Emit change event for broadcast operations
-        this._emit(this._changeHandlers, {
-            docId,
-            origin: "broadcast",
-            operations: [operations],
-        });
-    }
-    _applyPresencePatch(cacheEntry, patch) {
-        const newPresence = { ...cacheEntry.presence };
-        for (const [key, value] of Object.entries(patch)) {
-            if (key === this._clientId)
-                continue; // never store own presence in cache; local tab must not render self as remote
-            if (value === undefined || value === null) {
-                delete newPresence[key];
-            }
-            else {
-                newPresence[key] = value;
-            }
-        }
-        cacheEntry.presence = newPresence;
-        cacheEntry.presenceHandlers.forEach((handler) => handler(cacheEntry.presence));
-    }
-    /** Current presence for this client (debounce state or cache); does not clear the timer */
-    _getOwnPresencePatch(docId) {
-        const debounced = this._presenceDebounceState.get(docId);
-        if (debounced)
-            return { [this._clientId]: debounced.data };
-        const cacheEntry = this._docsCache.get(docId);
-        if (cacheEntry?.presence[this._clientId] !== undefined)
-            return { [this._clientId]: cacheEntry.presence[this._clientId] };
-        return undefined;
-    }
-    // TODO: used when server responds with a new doc (squashing)
-    async _replaceDocInCache({ docId, doc, serializedDoc, }) {
-        const cacheEntry = this._docsCache.get(docId);
-        if (!cacheEntry)
-            return;
-        // Deserialize if needed
-        const newDoc = doc ?? this._docBinding.deserialize(serializedDoc);
-        // Replace the cached document with the new one
-        // Keep the same refCount
-        // Note: We don't setup a new change listener here because:
-        // 1. The doc already has all operations applied from the sync
-        // 2. A listener will be setup when the doc is loaded via getDoc
-        // 3. Multiple listeners would cause operations to be applied multiple times
-        this._docsCache.set(docId, {
-            promisedDoc: Promise.resolve(newDoc),
-            refCount: cacheEntry.refCount,
-            presence: cacheEntry.presence,
-            presenceHandlers: cacheEntry.presenceHandlers,
-        });
-    }
-    async _applyServerOperations({ docId, operations, }) {
-        const cacheEntry = this._docsCache.get(docId);
-        if (!cacheEntry)
-            return;
-        // Get the cached document and apply server operations to it
-        const doc = await cacheEntry.promisedDoc;
-        if (!doc)
-            return;
-        this._shouldBroadcast = false;
-        for (const op of operations) {
-            this._docBinding.applyOperations(doc, op);
-        }
-        this._shouldBroadcast = true;
-        // Emit change event for remote operations
-        this._emit(this._changeHandlers, {
-            docId,
-            origin: "remote",
-            operations,
-        });
-    }
     /**
      * Subscribe to a document with reactive state updates.
      *
@@ -248,13 +108,13 @@ export class DocSyncClient {
             this._docsCache.set(createdDocId, {
                 promisedDoc: Promise.resolve(doc),
                 refCount: 1,
+                type,
                 presence: {},
-                presenceHandlers: new Set(),
+                presenceListeners: new Set(),
             });
             this._setupChangeListener(doc, createdDocId);
             emit({ status: "success", data: { doc, docId: createdDocId } });
-            // Emit doc load event
-            this._emit(this._docLoadHandlers, {
+            this._events.emit("docLoad", {
                 docId: createdDocId,
                 source: "created",
                 refCount: 1,
@@ -269,7 +129,7 @@ export class DocSyncClient {
                     clock: 0,
                 }));
             })();
-            // We don't trigger a initial saveRemote here because argId is undefined,
+            // We don't trigger an initial sync here because argId is undefined;
             // so this is truly a new doc. Initial operations will be pushed to server
             return () => void this._unloadDoc(createdDocId);
         }
@@ -289,8 +149,9 @@ export class DocSyncClient {
                 this._docsCache.set(docId, {
                     promisedDoc,
                     refCount: 1,
+                    type,
                     presence: {},
-                    presenceHandlers: new Set(),
+                    presenceListeners: new Set(),
                 });
             }
             void (async () => {
@@ -310,22 +171,14 @@ export class DocSyncClient {
                             source = createIfMissing ? "created" : "local";
                         }
                     }
-                    // Emit doc load event
                     if (doc) {
                         const refCount = this._docsCache.get(docId)?.refCount ?? 1;
-                        this._emit(this._docLoadHandlers, {
-                            docId,
-                            source,
-                            refCount,
-                        });
+                        this._events.emit("docLoad", { docId, source, refCount });
                     }
-                    emit({
-                        status: "success",
-                        data: doc ? { doc, docId } : undefined,
-                    });
+                    emit({ status: "success", data: doc ? { doc, docId } : undefined });
                     // Fetch from server to check if document exists there
                     if (doc) {
-                        void this.saveRemote({ docId });
+                        void handleSync(this, docId);
                     }
                 }
                 catch (e) {
@@ -341,7 +194,7 @@ export class DocSyncClient {
     }
     /**
      * Subscribe to presence updates for a document.
-     * Multiple handlers can be registered for the same document.
+     * Multiple listeners can be registered for the same document.
      * @param args - The arguments for the getPresence request.
      * @param onChange - The callback to invoke when the presence changes.
      * @returns A function to unsubscribe from presence updates.
@@ -354,64 +207,28 @@ export class DocSyncClient {
         if (!cacheEntry) {
             throw new Error(`Cannot subscribe to presence for document "${docId}" - document not loaded.`);
         }
-        // Add handler to the set
-        cacheEntry.presenceHandlers.add(onChange);
+        // Add listener to the set
+        cacheEntry.presenceListeners.add(onChange);
         // Immediately call with current presence if available
         if (Object.keys(cacheEntry.presence).length > 0) {
             onChange(cacheEntry.presence);
         }
-        // Return unsubscribe function that removes only this handler
+        // Return unsubscribe function that removes only this listener
         return () => {
             const entry = this._docsCache.get(docId);
             if (entry) {
-                entry.presenceHandlers.delete(onChange);
+                entry.presenceListeners.delete(onChange);
             }
         };
     }
-    async setPresence({ docId, presence }) {
-        const cacheEntry = this._docsCache.get(docId);
-        if (!cacheEntry)
-            throw new Error(`Doc ${docId} is not loaded, cannot set presence`);
-        // Clear existing timeout if any
-        const existingState = this._presenceDebounceState.get(docId);
-        clearTimeout(existingState?.timeout);
-        // Debounce the presence update
-        const timeout = setTimeout(() => {
-            const state = this._presenceDebounceState.get(docId);
-            if (!state)
-                return;
-            this._presenceDebounceState.delete(docId);
-            const patch = { [this._clientId]: state.data };
-            // Update local cache and notify handlers (so own cursor shows and UI stays in sync)
-            this._applyPresencePatch(cacheEntry, patch);
-            // Same device: broadcast to other tabs (works offline)
-            this._sendMessage({
-                type: "PRESENCE",
-                docId,
-                presence: patch,
-            });
-            // Other devices: send via WebSocket only when connected
-            if (this._socket.connected) {
-                void (async () => {
-                    if (!this._socket.connected)
-                        return;
-                    const { error } = await this._request("presence", {
-                        docId,
-                        presence: state.data,
-                    });
-                    if (error) {
-                        console.error(`Error setting presence for doc ${docId}:`, error);
-                    }
-                })();
-            }
-        }, this._presenceDebounce);
-        this._presenceDebounceState.set(docId, { timeout, data: presence });
+    setPresence({ docId, presence }) {
+        void handlePresence(this, { docId, presence });
     }
     _setupChangeListener(doc, docId) {
         this._docBinding.onChange(doc, ({ operations }) => {
             if (this._shouldBroadcast) {
                 void this.onLocalOperations({ docId, operations: [operations] });
-                this._emit(this._changeHandlers, {
+                this._events.emit("change", {
                     docId,
                     origin: "local",
                     operations: [operations],
@@ -420,8 +237,8 @@ export class DocSyncClient {
                 // include is the new cursor. Two frames so setPresence (from selection change) has run.
                 requestAnimationFrame(() => {
                     requestAnimationFrame(() => {
-                        const presencePatch = this._getOwnPresencePatch(docId);
-                        this._sendMessage({
+                        const presencePatch = getOwnPresencePatch(this, docId);
+                        this._bcHelper?.broadcast({
                             type: "OPERATIONS",
                             operations,
                             docId,
@@ -480,34 +297,23 @@ export class DocSyncClient {
             return;
         if (cacheEntry.refCount > 1) {
             cacheEntry.refCount -= 1;
-            this._emit(this._docUnloadHandlers, {
-                docId,
-                refCount: cacheEntry.refCount,
-            });
+            this._events.emit("docUnload", { docId, refCount: cacheEntry.refCount });
         }
         else {
-            // Mark refCount as 0 but keep in cache until promise resolves
             cacheEntry.refCount = 0;
-            // Emit immediately
-            this._emit(this._docUnloadHandlers, {
-                docId,
-                refCount: 0,
-            });
+            this._events.emit("docUnload", { docId, refCount: 0 });
             // Dispose when promise resolves
             const doc = await cacheEntry.promisedDoc;
             const currentEntry = this._docsCache.get(docId);
             if (currentEntry?.refCount === 0) {
                 this._docsCache.delete(docId);
                 if (doc) {
-                    await this.unsubscribeDoc(docId);
+                    await handleUnsubscribe(this._socket, { docId });
                     this._docBinding.dispose(doc);
                 }
             }
         }
     }
-    _sendMessage(message) {
-        this._broadcastChannel?.postMessage(message);
-    }
     onLocalOperations({ docId, operations }) {
         // Get or create the batch state for this document
         let state = this._localOpsBatchState.get(docId);
@@ -535,298 +341,24 @@ export class DocSyncClient {
                 if (opsToSave && opsToSave.length > 0) {
                     const local = await this._localPromise;
                     await local?.provider.transaction("readwrite", (ctx) => ctx.saveOperations({ docId, operations: opsToSave }));
-                    this.saveRemote({ docId });
+                    void handleSync(this, docId);
                 }
             })();
         }, this._batchDelay);
     }
-    /**
-     * Push local operations to the server for a specific document.
-     * Uses a per-docId queue to prevent concurrent pushes for the same doc.
-     */
-    saveRemote({ docId }) {
-        const status = this._pushStatusByDocId.get(docId) ?? "idle";
-        if (status !== "idle") {
-            this._pushStatusByDocId.set(docId, "pushing-with-pending");
-            return;
-        }
-        void this._doPush({ docId });
+    async _deleteDoc(docId) {
+        return handleDeleteDoc(this._socket, { docId });
     }
     /**
-     * Unsubscribe from real-time updates for a document.
-     * Should be called when a document is unloaded (refCount 1 → 0).
-     */
-    async unsubscribeDoc(docId) {
-        // Skip if socket is not connected (e.g., in local-only mode or during tests)
-        if (!this._socket.connected)
-            return;
-        try {
-            await this._request("unsubscribe-doc", { docId });
-        }
-        catch {
-            // Silently ignore errors during cleanup (e.g., socket
-            // disconnected during request, timeout, or server error)
-        }
-    }
-    async _doPush({ docId }) {
-        this._pushStatusByDocId.set(docId, "pushing");
-        const provider = (await this._localPromise).provider;
-        // Get the current clock value and operations from provider
-        const [operationsBatches, stored] = await provider.transaction("readonly", async (ctx) => {
-            return Promise.all([
-                ctx.getOperations({ docId }),
-                ctx.getSerializedDoc(docId),
-            ]);
-        });
-        const operations = operationsBatches.flat();
-        const clientClock = stored?.clock ?? 0;
-        let response;
-        try {
-            const presenceState = this._presenceDebounceState.get(docId);
-            if (presenceState) {
-                clearTimeout(presenceState.timeout);
-                this._presenceDebounceState.delete(docId);
-                this._sendMessage({
-                    type: "PRESENCE",
-                    docId,
-                    presence: { [this._clientId]: presenceState.data },
-                });
-            }
-            response = await this._request("sync-operations", {
-                clock: clientClock,
-                docId,
-                operations,
-                ...(presenceState ? { presence: presenceState.data } : {}),
-            });
-        }
-        catch (error) {
-            // Emit sync event (network error)
-            this._emit(this._syncHandlers, {
-                req: {
-                    docId,
-                    operations,
-                    clock: clientClock,
-                },
-                error: {
-                    type: "NetworkError",
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            });
-            // Retry on failure
-            this._pushStatusByDocId.set(docId, "idle");
-            void this._doPush({ docId });
-            return;
-        }
-        // Check if server returned an error
-        if ("error" in response && response.error) {
-            // Emit sync event with server error
-            this._emit(this._syncHandlers, {
-                req: {
-                    docId,
-                    operations,
-                    clock: clientClock,
-                },
-                error: response.error,
-            });
-            // Retry on error
-            this._pushStatusByDocId.set(docId, "idle");
-            void this._doPush({ docId });
-            return;
-        }
-        // At this point, response must have data
-        const { data } = response;
-        // Emit sync event (success)
-        this._emit(this._syncHandlers, {
-            req: {
-                docId,
-                operations,
-                clock: clientClock,
-            },
-            data: {
-                ...(data.operations ? { operations: data.operations } : {}),
-                ...(data.serializedDoc ? { serializedDoc: data.serializedDoc } : {}),
-                clock: data.clock,
-            },
-        });
-        // Atomically: delete synced operations + consolidate into serialized doc
-        let didConsolidate = false; // Track if we actually saved new operations to IDB
-        await provider.transaction("readwrite", async (ctx) => {
-            // Delete client operations that were synced (delete batches, not individual ops)
-            if (operationsBatches.length > 0) {
-                await ctx.deleteOperations({
-                    docId,
-                    count: operationsBatches.length,
-                });
-            }
-            // Consolidate operations into serialized doc
-            const stored = await ctx.getSerializedDoc(docId);
-            if (!stored)
-                return;
-            // Skip consolidation if another client (same IDB) already updated to this clock
-            // This handles the case where another tab/client already wrote this update
-            if (stored.clock >= data.clock) {
-                didConsolidate = false;
-                return;
-            }
-            // Collect all operations to apply: server ops first, then client ops
-            const serverOps = data.operations ?? [];
-            const allOps = [...serverOps, ...operations];
-            // Only proceed if there are operations to apply
-            if (allOps.length > 0) {
-                const doc = this._docBinding.deserialize(stored.serializedDoc);
-                // Apply all operations in order (server ops first, then client ops)
-                for (const op of allOps) {
-                    this._docBinding.applyOperations(doc, op);
-                }
-                const serializedDoc = this._docBinding.serialize(doc);
-                // Before saving, verify clock hasn't changed (another concurrent write)
-                // This prevents race conditions when multiple tabs/clients share the same IDB
-                const recheckStored = await ctx.getSerializedDoc(docId);
-                if (!recheckStored || recheckStored?.clock !== stored.clock) {
-                    // Clock changed during our transaction - another client beat us
-                    // Silently skip to avoid duplicate operations
-                    return;
-                }
-                await ctx.saveSerializedDoc({
-                    serializedDoc,
-                    docId,
-                    clock: data.clock, // Use clock from server
-                });
-                didConsolidate = true; // Mark that we successfully saved
-            }
-        });
-        // CRITICAL: Only apply serverOps to memory if we actually saved to IDB
-        // If we skipped (clock already up-to-date), operations are already in memory via BC
-        if (didConsolidate && data.operations && data.operations.length > 0) {
-            // Apply to our own memory
-            void this._applyServerOperations({
-                docId,
-                operations: data.operations,
-            });
-            // Broadcast server operations to other tabs so they can apply them too
-            const presencePatch = this._getOwnPresencePatch(docId);
-            for (const op of data.operations) {
-                this._sendMessage({
-                    type: "OPERATIONS",
-                    operations: op,
-                    docId,
-                    ...(presencePatch && { presence: presencePatch }),
-                });
-            }
-        }
-        // Status may have changed to "pushing-with-pending" during async ops
-        const currentStatus = this._pushStatusByDocId.get(docId);
-        const shouldRetry = currentStatus === "pushing-with-pending";
-        if (shouldRetry) {
-            // Keep status as "pushing" and retry immediately to avoid race window
-            // where a dirty event could trigger another concurrent _doPush
-            void this._doPush({ docId });
-        }
-        else {
-            this._pushStatusByDocId.set(docId, "idle");
-        }
-    }
-    async _request(event, payload) {
-        // TO-DO: should I reject on disconnect?
-        return new Promise((resolve, reject) => {
-            // Add a timeout to prevent hanging forever if socket disconnects during request
-            const timeout = setTimeout(() => {
-                reject(new Error(`Request timeout: ${event}`));
-            }, 5000); // 5 second timeout
-            this._socket.emit(event, payload, (response) => {
-                clearTimeout(timeout);
-                resolve(response);
-            });
-        });
-    }
-    // ============================================================================
-    // Event Registration Methods
-    // ============================================================================
-    /**
-     * Register a handler for connection events.
-     * @returns Unsubscribe function
-     */
-    onConnect(handler) {
-        this._connectHandlers.add(handler);
-        return () => {
-            this._connectHandlers.delete(handler);
-        };
-    }
-    /**
-     * Register a handler for disconnection events.
-     * @returns Unsubscribe function
-     */
-    onDisconnect(handler) {
-        this._disconnectHandlers.add(handler);
-        return () => {
-            this._disconnectHandlers.delete(handler);
-        };
-    }
-    /**
-     * Register a handler for document change events.
-     * @returns Unsubscribe function
-     */
-    onChange(handler) {
-        const h = handler;
-        this._changeHandlers.add(h);
-        return () => {
-            this._changeHandlers.delete(h);
-        };
-    }
-    /**
-     * Register a handler for sync events.
-     * @returns Unsubscribe function
-     */
-    onSync(handler) {
-        const h = handler;
-        this._syncHandlers.add(h);
-        return () => {
-            this._syncHandlers.delete(h);
-        };
-    }
-    /**
-     * Register a handler for document load events.
-     * @returns Unsubscribe function
-     */
-    onDocLoad(handler) {
-        this._docLoadHandlers.add(handler);
-        return () => {
-            this._docLoadHandlers.delete(handler);
-        };
-    }
-    /**
-     * Register a handler for document unload events.
-     * @returns Unsubscribe function
+     * Register a listener for an event. Returns an unsubscribe function.
+     * Event payload type is inferred from the event name (first argument).
+     * @example
+     * const off = client.on("connect", () => { ... });
+     * client.on("docUnload", (ev) => { ... }); // ev is DocUnloadEvent
+     * off(); // unsubscribe
      */
-    onDocUnload(handler) {
-        this._docUnloadHandlers.add(handler);
-        return () => {
-            this._docUnloadHandlers.delete(handler);
-        };
-    }
-    _emit(handlers, event) {
-        for (const handler of handlers) {
-            if (event !== undefined) {
-                handler(event);
-            }
-            else {
-                handler();
-            }
-        }
-    }
-}
-/**
- * Get or create a unique device ID stored in localStorage.
- * This ID is shared across all tabs/windows on the same device.
- */
-function getDeviceId() {
-    const key = "docsync:deviceId";
-    let deviceId = localStorage.getItem(key);
-    if (!deviceId) {
-        // Generate a new device ID using crypto.randomUUID()
-        deviceId = crypto.randomUUID();
-        localStorage.setItem(key, deviceId);
+    on(event, listener) {
+        return this._events.on(event, listener);
     }
-    return deviceId;
 }
 //# sourceMappingURL=index.js.map