@dabble/patches 0.7.24 → 0.8.0

package/dist/json-patch/utils/getType.d.ts

@@ -1,6 +1,6 @@
 import { State, JSONPatchOp, JSONPatchOpHandler } from '../types.js';
 
 declare function getType(state: State, patch: JSONPatchOp): JSONPatchOpHandler;
-declare function getTypeLike(state: State, patch: JSONPatchOp): "add" | "remove" | "replace" | "move" | "copy" | "test";
+declare function getTypeLike(state: State, patch: JSONPatchOp): "test" | "add" | "remove" | "replace" | "copy" | "move";
 
 export { getType, getTypeLike };

package/dist/net/PatchesConnection.d.ts

@@ -0,0 +1,27 @@
+import { Signal } from 'easy-signal';
+import { Change, CommitChangesOptions } from '../types.js';
+import { PatchesAPI, ConnectionState } from './protocol/types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
+/**
+ * Common interface for transport connections that PatchesSync can use.
+ * Implemented by PatchesWebSocket (WebSocket transport) and PatchesREST (SSE + fetch transport).
+ */
+interface PatchesConnection extends PatchesAPI {
+    /** The server URL. Readable and writable — setting while connected triggers reconnection. */
+    url: string;
+    /** Establish the connection to the server. */
+    connect(): Promise<void>;
+    /** Tear down the connection. */
+    disconnect(): void;
+    /** Signal emitted when the connection state changes. */
+    readonly onStateChange: Signal<(state: ConnectionState) => void>;
+    /** Signal emitted when the server pushes committed changes for a subscribed document. */
+    readonly onChangesCommitted: Signal<(docId: string, changes: Change[], options?: CommitChangesOptions) => void>;
+    /** Signal emitted when a subscribed document is deleted remotely. */
+    readonly onDocDeleted: Signal<(docId: string) => void>;
+}
+
+export type { PatchesConnection };

package/dist/net/PatchesSync.d.ts

@@ -1,20 +1,19 @@
 import * as easy_signal from 'easy-signal';
 import { ReadonlyStoreClass, Store } from 'easy-signal';
-import { ConnectionState } from './protocol/types.js';
-import { DocSyncStatus, DocSyncState, Change } from '../types.js';
-import { JSONRPCClient } from './protocol/JSONRPCClient.js';
-import { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
-import { WebSocketOptions } from './websocket/WebSocketTransport.js';
 import { SizeCalculator } from '../algorithms/ot/shared/changeBatching.js';
 import { ClientAlgorithm } from '../client/ClientAlgorithm.js';
 import { Patches } from '../client/Patches.js';
 import { AlgorithmName } from '../client/PatchesStore.js';
+import { DocSyncStatus, DocSyncState, Change } from '../types.js';
+import { PatchesConnection } from './PatchesConnection.js';
+import { JSONRPCClient } from './protocol/JSONRPCClient.js';
+import { ConnectionState } from './protocol/types.js';
+import { WebSocketOptions } from './websocket/WebSocketTransport.js';
+import '../json-patch/types.js';
+import '../BaseDoc-BT18xPxU.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
-import './PatchesClient.js';
 import '../utils/deferred.js';
-import '../BaseDoc-BT18xPxU.js';
 
 interface PatchesSyncState {
     online: boolean;
@@ -24,6 +23,7 @@ interface PatchesSyncState {
 }
 interface PatchesSyncOptions {
     subscribeFilter?: (docIds: string[]) => string[];
+    /** WebSocket options. Only used when a URL string is passed to the constructor. */
     websocket?: WebSocketOptions;
     /** Wire batch limit for network transmission. Defaults to 1MB. */
     maxPayloadBytes?: number;
@@ -33,9 +33,12 @@ interface PatchesSyncOptions {
     sizeCalculator?: SizeCalculator;
 }
 /**
- * Handles WebSocket connection, document subscriptions, and syncing logic between
+ * Handles server connection, document subscriptions, and syncing logic between
  * the Patches instance and the server.
  *
+ * Accepts either a URL string (creates a WebSocket connection) or a PatchesConnection
+ * instance (e.g. PatchesREST for SSE + fetch).
+ *
  * PatchesSync is algorithm-agnostic. It delegates to algorithm methods for:
  * - Getting pending changes to send
  * - Applying server changes
@@ -43,7 +46,7 @@ interface PatchesSyncOptions {
  */
 declare class PatchesSync extends ReadonlyStoreClass<PatchesSyncState> {
     protected options?: PatchesSyncOptions | undefined;
-    protected ws: PatchesWebSocket;
+    protected connection: PatchesConnection;
     protected patches: Patches;
     protected maxPayloadBytes?: number;
     protected maxStorageBytes?: number;
@@ -66,36 +69,38 @@ declare class PatchesSync extends ReadonlyStoreClass<PatchesSyncState> {
      * Provides the pending changes that were discarded so the application can handle them.
      */
     readonly onRemoteDocDeleted: easy_signal.Signal<(docId: string, pendingChanges: Change[]) => void>;
-    constructor(patches: Patches, url: string, options?: PatchesSyncOptions | undefined);
+    constructor(patches: Patches, url: string, options?: PatchesSyncOptions);
+    constructor(patches: Patches, connection: PatchesConnection, options?: PatchesSyncOptions);
     /**
      * Gets the algorithm for a document. Uses the open doc's algorithm if available,
      * otherwise falls back to the default algorithm.
      */
     protected _getAlgorithm(docId: string): ClientAlgorithm;
     /**
-     * Gets the URL of the WebSocket connection.
+     * Gets the server URL.
      */
     get url(): string;
     /**
-     * Sets the URL of the WebSocket connection.
+     * Sets the server URL. Reconnects if currently connected.
      */
     set url(url: string);
     /**
      * Gets the JSON-RPC client for making custom RPC calls.
-     * Useful for application-specific methods not part of the Patches protocol.
+     * Only available when using a WebSocket connection (PatchesWebSocket or PatchesClient).
+     * Returns undefined when using REST transport.
      */
-    get rpc(): JSONRPCClient;
+    get rpc(): JSONRPCClient | undefined;
     /**
      * Updates the sync state.
      * @param update - The partial state to update.
      */
     protected updateState(update: Partial<PatchesSyncState>): void;
     /**
-     * Connects to the WebSocket server and starts syncing if online. If not online, it will wait for online state.
+     * Connects to the server and starts syncing if online. If not online, it will wait for online state.
      */
     connect(): Promise<void>;
     /**
-     * Disconnects from the WebSocket server and stops syncing.
+     * Disconnects from the server and stops syncing.
      */
     disconnect(): void;
     /**
@@ -155,7 +160,7 @@ declare class PatchesSync extends ReadonlyStoreClass<PatchesSyncState> {
     protected _resetSyncingStatuses(): void;
     /**
      * Applies the subscribeFilter option to a list of doc IDs, returning the subset
-     * that should be sent to ws.subscribe/unsubscribe. Returns the full list if no filter is set.
+     * that should be sent to subscribe/unsubscribe. Returns the full list if no filter is set.
      */
     protected _filterSubscribeIds(docIds: string[]): string[];
     /**

package/dist/net/PatchesSync.js

@@ -13,6 +13,7 @@ import { BaseDoc } from "../client/BaseDoc.js";
 import { Patches } from "../client/Patches.js";
 import { isDocLoaded } from "../shared/utils.js";
 import { blockable } from "../utils/concurrency.js";
+import { ErrorCodes, StatusError } from "./error.js";
 import { PatchesWebSocket } from "./websocket/PatchesWebSocket.js";
 import { onlineState } from "./websocket/onlineState.js";
 const EMPTY_DOC_STATE = {
@@ -22,7 +23,7 @@ const EMPTY_DOC_STATE = {
   isLoaded: false
 };
 class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable], __receiveCommittedChanges_dec = [blockable], _a) {
-  constructor(patches, url, options) {
+  constructor(patches, urlOrConnection, options) {
     super({
       online: onlineState.isOnline,
       connected: false,
@@ -30,7 +31,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     });
     this.options = options;
     __runInitializers(_init, 5, this);
-    __publicField(this, "ws");
+    __publicField(this, "connection");
     __publicField(this, "patches");
     __publicField(this, "maxPayloadBytes");
     __publicField(this, "maxStorageBytes");
@@ -55,13 +56,17 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     this.maxPayloadBytes = options?.maxPayloadBytes;
     this.maxStorageBytes = options?.maxStorageBytes ?? patches.docOptions?.maxStorageBytes;
     this.sizeCalculator = options?.sizeCalculator ?? patches.docOptions?.sizeCalculator;
-    this.ws = new PatchesWebSocket(url, options?.websocket);
+    if (typeof urlOrConnection === "string") {
+      this.connection = new PatchesWebSocket(urlOrConnection, options?.websocket);
+    } else {
+      this.connection = urlOrConnection;
+    }
     this.docStates = store({});
     this.trackedDocs = new Set(patches.trackedDocs);
     onlineState.onOnlineChange((online) => this.updateState({ online }));
-    this.ws.onStateChange(this._handleConnectionChange.bind(this));
-    this.ws.onChangesCommitted(this._receiveCommittedChanges.bind(this));
-    this.ws.onDocDeleted((docId) => this._handleRemoteDocDeleted(docId));
+    this.connection.onStateChange(this._handleConnectionChange.bind(this));
+    this.connection.onChangesCommitted(this._receiveCommittedChanges.bind(this));
+    this.connection.onDocDeleted((docId) => this._handleRemoteDocDeleted(docId));
     patches.onTrackDocs(this._handleDocsTracked.bind(this));
     patches.onUntrackDocs(this._handleDocsUntracked.bind(this));
     patches.onDeleteDoc(this._handleDocDeleted.bind(this));
@@ -82,27 +87,31 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     return algorithm;
   }
   /**
-   * Gets the URL of the WebSocket connection.
+   * Gets the server URL.
    */
   get url() {
-    return this.ws.transport.url;
+    return this.connection.url;
   }
   /**
-   * Sets the URL of the WebSocket connection.
+   * Sets the server URL. Reconnects if currently connected.
    */
   set url(url) {
-    this.ws.transport.url = url;
+    this.connection.url = url;
     if (this.state.connected) {
-      this.ws.disconnect();
-      this.ws.connect();
+      this.connection.disconnect();
+      this.connection.connect();
     }
   }
   /**
    * Gets the JSON-RPC client for making custom RPC calls.
-   * Useful for application-specific methods not part of the Patches protocol.
+   * Only available when using a WebSocket connection (PatchesWebSocket or PatchesClient).
+   * Returns undefined when using REST transport.
    */
   get rpc() {
-    return this.ws.rpc;
+    if ("rpc" in this.connection) {
+      return this.connection.rpc;
+    }
+    return void 0;
   }
   /**
    * Updates the sync state.
@@ -118,11 +127,11 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     }
   }
   /**
-   * Connects to the WebSocket server and starts syncing if online. If not online, it will wait for online state.
+   * Connects to the server and starts syncing if online. If not online, it will wait for online state.
    */
   async connect() {
     try {
-      await this.ws.connect();
+      await this.connection.connect();
     } catch (err) {
       console.error("PatchesSync connection failed:", err);
       const error = err instanceof Error ? err : new Error(String(err));
@@ -132,10 +141,10 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     }
   }
   /**
-   * Disconnects from the WebSocket server and stops syncing.
+   * Disconnects from the server and stops syncing.
    */
   disconnect() {
-    this.ws.disconnect();
+    this.connection.disconnect();
     this.updateState({ connected: false, syncStatus: "unsynced" });
     this._resetSyncingStatuses();
   }
@@ -181,7 +190,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
         try {
           const subscribeIds = this._filterSubscribeIds(activeDocIds);
           if (subscribeIds.length) {
-            await this.ws.subscribe(subscribeIds);
+            await this.connection.subscribe(subscribeIds);
           }
         } catch (err) {
           console.warn("Error subscribing to active docs during sync:", err);
@@ -192,7 +201,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
       const deletePromises = deletedDocs.map(async ({ docId }) => {
         try {
           console.info(`Attempting server delete for tombstoned doc: ${docId}`);
-          await this.ws.deleteDoc(docId);
+          await this.connection.deleteDoc(docId);
           const algorithm = this._getAlgorithm(docId);
           await algorithm.confirmDeleteDoc(docId);
           console.info(`Successfully deleted and untracked doc: ${docId}`);
@@ -226,12 +235,12 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
       } else {
         const committedRev = await algorithm.getCommittedRev(docId);
         if (committedRev) {
-          const serverChanges = await this.ws.getChangesSince(docId, committedRev);
+          const serverChanges = await this.connection.getChangesSince(docId, committedRev);
           if (serverChanges.length > 0) {
             await this._applyServerChangesToDoc(docId, serverChanges);
           }
         } else {
-          const snapshot = await this.ws.getDoc(docId);
+          const snapshot = await this.connection.getDoc(docId);
           await algorithm.store.saveDoc(docId, snapshot);
           this._updateDocSyncState(docId, { committedRev: snapshot.rev });
           if (baseDoc) {
@@ -286,10 +295,10 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
         if (!this.state.connected) {
           throw new Error("Disconnected during flush");
         }
-        const { changes: committed, docReloadRequired } = await this.ws.commitChanges(docId, changeBatch);
+        const { changes: committed, docReloadRequired } = await this.connection.commitChanges(docId, changeBatch);
         if (docReloadRequired) {
           await algorithm.confirmSent(docId, changeBatch);
-          const snapshot = await this.ws.getDoc(docId);
+          const snapshot = await this.connection.getDoc(docId);
           await algorithm.store.saveDoc(docId, snapshot);
           this._updateDocSyncState(docId, { committedRev: snapshot.rev });
           const openDoc = this.patches.getOpenDoc(docId);
@@ -344,7 +353,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     if (this.state.connected) {
       try {
         const algorithm = this._getAlgorithm(docId);
-        await this.ws.deleteDoc(docId);
+        await this.connection.deleteDoc(docId);
         await algorithm.confirmDeleteDoc(docId);
       } catch (err) {
         console.error(`Server delete failed for doc ${docId}, will retry on reconnect/resync.`, err);
@@ -412,7 +421,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
       try {
         const subscribeIds = this._filterSubscribeIds(newIds).filter((id) => !alreadySubscribed.has(id));
         if (subscribeIds.length) {
-          await this.ws.subscribe(subscribeIds);
+          await this.connection.subscribe(subscribeIds);
         }
         await Promise.all(newIds.map((id) => this.syncDoc(id)));
       } catch (err) {
@@ -433,7 +442,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
     const unsubscribeIds = [...subscribedBefore].filter((id) => !subscribedAfter.has(id));
     if (this.state.connected && unsubscribeIds.length) {
       try {
-        await this.ws.unsubscribe(unsubscribeIds);
+        await this.connection.unsubscribe(unsubscribeIds);
       } catch (err) {
         console.warn(`Failed to unsubscribe docs: ${unsubscribeIds.join(", ")}`, err);
       }
@@ -504,7 +513,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
   }
   /**
    * Applies the subscribeFilter option to a list of doc IDs, returning the subset
-   * that should be sent to ws.subscribe/unsubscribe. Returns the full list if no filter is set.
+   * that should be sent to subscribe/unsubscribe. Returns the full list if no filter is set.
    */
   _filterSubscribeIds(docIds) {
     return this.options?.subscribeFilter?.(docIds) || docIds;
@@ -520,7 +529,7 @@ class PatchesSync extends (_a = ReadonlyStoreClass, _syncDoc_dec = [blockable],
    * Helper to detect DOC_DELETED (410) errors from the server.
    */
   _isDocDeletedError(err) {
-    return typeof err === "object" && err !== null && "code" in err && err.code === 410;
+    return err instanceof StatusError && err.code === ErrorCodes.DOC_DELETED;
   }
 }
 _init = __decoratorStart(_a);

package/dist/net/index.d.ts

@@ -1,6 +1,10 @@
 export { FetchTransport } from './http/FetchTransport.js';
 export { PatchesClient } from './PatchesClient.js';
+export { PatchesConnection } from './PatchesConnection.js';
 export { PatchesSync, PatchesSyncOptions, PatchesSyncState } from './PatchesSync.js';
+export { PatchesREST, PatchesRESTOptions } from './rest/PatchesREST.js';
+export { BufferedEvent, SSEServer, SSEServerOptions } from './rest/SSEServer.js';
+export { encodeDocId, normalizeIds } from './rest/utils.js';
 export { JSONRPCClient } from './protocol/JSONRPCClient.js';
 export { AccessLevel, ApiDefinition, ConnectionSignalSubscriber, JSONRPCServer, JSONRPCServerOptions, MessageHandler } from './protocol/JSONRPCServer.js';
 export { getAuthContext, getClientId } from './serverContext.js';

package/dist/net/index.js

@@ -1,7 +1,9 @@
 import "../chunk-IZ2YBCUP.js";
 export * from "./http/FetchTransport.js";
 export * from "./PatchesClient.js";
+export * from "./PatchesConnection.js";
 export * from "./PatchesSync.js";
+export * from "./rest/index.js";
 export * from "./protocol/JSONRPCClient.js";
 export * from "./protocol/JSONRPCServer.js";
 import { getAuthContext, getClientId } from "./serverContext.js";

package/dist/net/rest/PatchesREST.d.ts

@@ -0,0 +1,75 @@
+import * as easy_signal from 'easy-signal';
+import { Change, CommitChangesOptions, PatchesState, ChangeInput, DeleteDocOptions, EditableVersionMetadata, ListVersionsOptions, VersionMetadata, PatchesSnapshot } from '../../types.js';
+import { PatchesConnection } from '../PatchesConnection.js';
+import { ConnectionState } from '../protocol/types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+/**
+ * Options for creating a PatchesREST instance.
+ */
+interface PatchesRESTOptions {
+    /**
+     * Explicit client ID. If not provided, restored from sessionStorage (when available)
+     * or generated via crypto.randomUUID(). Persisted to sessionStorage automatically.
+     */
+    clientId?: string;
+    /** Static headers added to every fetch request (e.g. Authorization). */
+    headers?: Record<string, string>;
+    /**
+     * Dynamic header provider called before every fetch request. Useful for token refresh.
+     * Merged on top of static headers (same-name keys override).
+     */
+    getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+}
+/**
+ * Client for the Patches real-time collaboration service using SSE + REST.
+ *
+ * Uses Server-Sent Events for receiving other clients' changes and HTTP/fetch
+ * for sending changes. Drop-in replacement for PatchesWebSocket when paired
+ * with PatchesSync.
+ */
+declare class PatchesREST implements PatchesConnection {
+    /** The client ID used for SSE connection and subscription management. */
+    readonly clientId: string;
+    readonly onStateChange: easy_signal.Signal<(state: ConnectionState) => void>;
+    readonly onChangesCommitted: easy_signal.Signal<(docId: string, changes: Change[], options?: CommitChangesOptions) => void>;
+    readonly onDocDeleted: easy_signal.Signal<(docId: string) => void>;
+    private _url;
+    private _state;
+    private eventSource;
+    private options;
+    private shouldBeConnected;
+    private onlineUnsubscriber;
+    constructor(url: string, options?: PatchesRESTOptions);
+    get url(): string;
+    set url(url: string);
+    connect(): Promise<void>;
+    disconnect(): void;
+    subscribe(ids: string | string[]): Promise<string[]>;
+    unsubscribe(ids: string | string[]): Promise<void>;
+    getDoc<T = any>(docId: string): Promise<PatchesState<T>>;
+    getChangesSince(docId: string, rev: number): Promise<Change[]>;
+    commitChanges(docId: string, changes: ChangeInput[], options?: CommitChangesOptions): Promise<{
+        changes: Change[];
+        docReloadRequired?: true;
+    }>;
+    deleteDoc(docId: string, _options?: DeleteDocOptions): Promise<void>;
+    createVersion(docId: string, metadata: EditableVersionMetadata): Promise<string>;
+    listVersions(docId: string, options?: ListVersionsOptions): Promise<VersionMetadata[]>;
+    getVersionState(docId: string, versionId: string): Promise<PatchesSnapshot>;
+    getVersionChanges(docId: string, versionId: string): Promise<Change[]>;
+    updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
+    listBranches(docId: string): Promise<VersionMetadata[]>;
+    createBranch(docId: string, rev: number, metadata?: EditableVersionMetadata): Promise<string>;
+    closeBranch(branchId: string): Promise<void>;
+    mergeBranch(branchId: string): Promise<void>;
+    private _setState;
+    private _getHeaders;
+    private _fetch;
+    private _ensureOnlineOfflineListeners;
+    private _removeOnlineOfflineListeners;
+}
+
+export { PatchesREST, type PatchesRESTOptions };

package/dist/net/rest/PatchesREST.js

@@ -0,0 +1,234 @@
+import "../../chunk-IZ2YBCUP.js";
+import { signal } from "easy-signal";
+import { StatusError } from "../error.js";
+import { onlineState } from "../websocket/onlineState.js";
+import { encodeDocId, normalizeIds } from "./utils.js";
+const SESSION_STORAGE_KEY = "patches-clientId";
+class PatchesREST {
+  /** The client ID used for SSE connection and subscription management. */
+  clientId;
+  // --- Public Signals ---
+  onStateChange = signal();
+  onChangesCommitted = signal();
+  onDocDeleted = signal();
+  _url;
+  _state = "disconnected";
+  eventSource = null;
+  options;
+  shouldBeConnected = false;
+  onlineUnsubscriber = null;
+  constructor(url, options) {
+    this._url = url.replace(/\/$/, "");
+    this.options = options ?? {};
+    const storage = typeof globalThis.sessionStorage !== "undefined" ? globalThis.sessionStorage : void 0;
+    this.clientId = this.options.clientId ?? storage?.getItem(SESSION_STORAGE_KEY) ?? globalThis.crypto.randomUUID();
+    try {
+      storage?.setItem(SESSION_STORAGE_KEY, this.clientId);
+    } catch {
+    }
+  }
+  // --- URL ---
+  get url() {
+    return this._url;
+  }
+  set url(url) {
+    this._url = url.replace(/\/$/, "");
+  }
+  // --- Connection Lifecycle ---
+  connect() {
+    this.shouldBeConnected = true;
+    this._ensureOnlineOfflineListeners();
+    if (onlineState.isOffline) {
+      return Promise.resolve();
+    }
+    if (this.eventSource) {
+      return Promise.resolve();
+    }
+    this._setState("connecting");
+    return new Promise((resolve, reject) => {
+      const es = new EventSource(`${this._url}/events/${this.clientId}`);
+      this.eventSource = es;
+      let settled = false;
+      es.onopen = () => {
+        this._setState("connected");
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      es.onerror = () => {
+        if (!settled) {
+          settled = true;
+          this._setState("error");
+          reject(new Error("SSE connection failed"));
+          return;
+        }
+        if (this._state === "connected") {
+          this._setState("disconnected");
+          this._setState("connecting");
+        }
+      };
+      es.addEventListener("changesCommitted", (e) => {
+        try {
+          const { docId, changes, options } = JSON.parse(e.data);
+          this.onChangesCommitted.emit(docId, changes, options);
+        } catch {
+        }
+      });
+      es.addEventListener("docDeleted", (e) => {
+        try {
+          const { docId } = JSON.parse(e.data);
+          this.onDocDeleted.emit(docId);
+        } catch {
+        }
+      });
+      es.addEventListener("resync", () => {
+        if (!this.shouldBeConnected) return;
+        this._setState("disconnected");
+        this._setState("connected");
+      });
+    });
+  }
+  disconnect() {
+    this.shouldBeConnected = false;
+    this._removeOnlineOfflineListeners();
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    this._setState("disconnected");
+  }
+  // --- PatchesAPI: Subscriptions ---
+  async subscribe(ids) {
+    const result = await this._fetch(`/subscriptions/${this.clientId}`, {
+      method: "POST",
+      body: { docIds: normalizeIds(ids) }
+    });
+    return result.docIds;
+  }
+  async unsubscribe(ids) {
+    await this._fetch(`/subscriptions/${this.clientId}`, {
+      method: "DELETE",
+      body: { docIds: normalizeIds(ids) }
+    });
+  }
+  // --- PatchesAPI: Documents ---
+  async getDoc(docId) {
+    return this._fetch(`/docs/${encodeDocId(docId)}`);
+  }
+  async getChangesSince(docId, rev) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_changes?since=${rev}`);
+  }
+  async commitChanges(docId, changes, options) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_changes`, {
+      method: "POST",
+      body: { changes, options }
+    });
+  }
+  async deleteDoc(docId, _options) {
+    await this._fetch(`/docs/${encodeDocId(docId)}`, { method: "DELETE" });
+  }
+  // --- PatchesAPI: Versions ---
+  async createVersion(docId, metadata) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_versions`, {
+      method: "POST",
+      body: metadata
+    });
+  }
+  async listVersions(docId, options) {
+    const params = options ? `?${new URLSearchParams(options)}` : "";
+    return this._fetch(`/docs/${encodeDocId(docId)}/_versions${params}`);
+  }
+  async getVersionState(docId, versionId) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_versions/${encodeURIComponent(versionId)}`);
+  }
+  async getVersionChanges(docId, versionId) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_versions/${encodeURIComponent(versionId)}/_changes`);
+  }
+  async updateVersion(docId, versionId, metadata) {
+    await this._fetch(`/docs/${encodeDocId(docId)}/_versions/${encodeURIComponent(versionId)}`, {
+      method: "PUT",
+      body: metadata
+    });
+  }
+  // --- Branch Operations (not in PatchesAPI but matches PatchesClient feature parity) ---
+  async listBranches(docId) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_branches`);
+  }
+  async createBranch(docId, rev, metadata) {
+    return this._fetch(`/docs/${encodeDocId(docId)}/_branches`, {
+      method: "POST",
+      body: { rev, ...metadata }
+    });
+  }
+  async closeBranch(branchId) {
+    await this._fetch(`/docs/${encodeDocId(branchId)}`, { method: "DELETE" });
+  }
+  async mergeBranch(branchId) {
+    await this._fetch(`/docs/${encodeDocId(branchId)}/_merge`, { method: "POST" });
+  }
+  // --- Private Helpers ---
+  _setState(state) {
+    if (state === this._state) return;
+    this._state = state;
+    this.onStateChange.emit(state);
+  }
+  async _getHeaders() {
+    const staticHeaders = this.options.headers ?? {};
+    if (this.options.getHeaders) {
+      const dynamic = await this.options.getHeaders();
+      return { ...staticHeaders, ...dynamic };
+    }
+    return staticHeaders;
+  }
+  async _fetch(path, init) {
+    const headers = await this._getHeaders();
+    const method = init?.method ?? "GET";
+    const hasBody = init?.body !== void 0;
+    const response = await globalThis.fetch(`${this._url}${path}`, {
+      method,
+      headers: {
+        ...hasBody ? { "Content-Type": "application/json" } : {},
+        ...headers
+      },
+      body: hasBody ? JSON.stringify(init.body) : void 0
+    });
+    if (!response.ok) {
+      let message = response.statusText;
+      let data;
+      try {
+        const json = await response.json();
+        message = json.message ?? json.error ?? message;
+        data = json.data;
+      } catch {
+      }
+      throw new StatusError(response.status, message, data);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+  _ensureOnlineOfflineListeners() {
+    if (!this.onlineUnsubscriber) {
+      this.onlineUnsubscriber = onlineState.onOnlineChange((isOnline) => {
+        if (isOnline && this.shouldBeConnected && !this.eventSource) {
+          this.connect();
+        } else if (!isOnline && this.eventSource) {
+          this.eventSource.close();
+          this.eventSource = null;
+          this._setState("disconnected");
+        }
+      });
+    }
+  }
+  _removeOnlineOfflineListeners() {
+    if (this.onlineUnsubscriber) {
+      this.onlineUnsubscriber();
+      this.onlineUnsubscriber = null;
+    }
+  }
+}
+export {
+  PatchesREST
+};

package/dist/net/rest/SSEServer.d.ts

@@ -0,0 +1,151 @@
+import { AuthorizationProvider, AuthContext } from '../websocket/AuthorizationProvider.js';
+import '../../server/types.js';
+import '../../json-patch/types.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+
+/**
+ * A buffered SSE event waiting to be sent or replayed.
+ */
+interface BufferedEvent {
+    id: number;
+    event: string;
+    data: string;
+    timestamp: number;
+}
+/**
+ * Options for creating an SSEServer instance.
+ */
+interface SSEServerOptions {
+    /** Heartbeat interval in milliseconds. Default: 30000 (30 seconds). */
+    heartbeatIntervalMs?: number;
+    /** How long to keep client state after disconnect. Default: 300000 (5 minutes). */
+    bufferTTLMs?: number;
+    /**
+     * Sliding window for the event buffer while connected, in milliseconds.
+     * Must cover the worst-case gap between a silent network failure and
+     * TCP detecting it (heartbeat interval + TCP retransmission timeout).
+     * Default: bufferTTLMs (matches the disconnect buffer lifetime).
+     */
+    bufferWindowMs?: number;
+    /** Authorization provider for subscription access control. */
+    auth?: AuthorizationProvider;
+}
+/**
+ * Framework-agnostic SSE server for the Patches real-time collaboration service.
+ *
+ * Manages SSE connections, document subscriptions, per-client event buffering,
+ * and heartbeats. Does NOT create HTTP routes — the framework calls these methods
+ * from its route handlers.
+ *
+ * Returns standard ReadableStream from connect(), compatible with any Web Standard
+ * framework (Hono, Express + node:stream, Cloudflare Workers, Deno, etc.).
+ *
+ * @example
+ * ```typescript
+ * const sse = new SSEServer();
+ *
+ * // GET /events/:clientId
+ * app.get('/events/:clientId', (c) => {
+ *   const stream = sse.connect(
+ *     c.req.param('clientId'),
+ *     c.req.header('Last-Event-ID')
+ *   );
+ *   return new Response(stream, {
+ *     headers: {
+ *       'Content-Type': 'text/event-stream',
+ *       'Cache-Control': 'no-cache',
+ *       'Connection': 'keep-alive',
+ *       'X-Accel-Buffering': 'no',
+ *     },
+ *   });
+ * });
+ *
+ * // POST /subscriptions/:clientId
+ * app.post('/subscriptions/:clientId', async (c) => {
+ *   const { docIds } = await c.req.json();
+ *   const ctx = { clientId: c.req.param('clientId'), ...authData };
+ *   const subscribed = await sse.subscribe(c.req.param('clientId'), docIds, ctx);
+ *   return c.json({ docIds: subscribed });
+ * });
+ * ```
+ */
+declare class SSEServer {
+    private clients;
+    private heartbeatInterval;
+    private heartbeatIntervalMs;
+    private bufferTTLMs;
+    private bufferWindowMs;
+    private auth?;
+    constructor(options?: SSEServerOptions);
+    private static noop;
+    /**
+     * Opens an SSE connection for a client. Returns a ReadableStream that the
+     * framework pipes to the HTTP response.
+     *
+     * If `lastEventId` is provided (from the Last-Event-ID header on reconnect),
+     * buffered events are replayed. If the buffer has expired, a `resync` event
+     * is sent so the client knows to do a full re-sync.
+     *
+     * The framework MUST call `disconnect(clientId)` when the response closes.
+     */
+    connect(clientId: string, lastEventId?: string): ReadableStream<Uint8Array>;
+    /**
+     * Called when the SSE response stream closes. The framework MUST call this
+     * when the HTTP response ends (e.g., on the response 'close' event).
+     *
+     * Starts the buffer expiry timer. If the client reconnects before it expires,
+     * buffered events are replayed.
+     */
+    disconnect(clientId: string): void;
+    /**
+     * Subscribe a client to documents.
+     *
+     * @param clientId - The client to subscribe.
+     * @param docIds - Document IDs to subscribe to.
+     * @param ctx - Auth context for authorization checks.
+     * @returns The list of document IDs successfully subscribed.
+     */
+    subscribe(clientId: string, docIds: string[], ctx?: AuthContext): Promise<string[]>;
+    /**
+     * Unsubscribe a client from documents.
+     */
+    unsubscribe(clientId: string, docIds: string[]): void;
+    /**
+     * Send a notification event to all clients subscribed to the document.
+     *
+     * Connected clients receive the event immediately via their SSE stream.
+     * Disconnected clients (within buffer TTL) get the event buffered for replay.
+     *
+     * @param event - The SSE event type (e.g. 'changesCommitted', 'docDeleted').
+     * @param params - Event data. Must include `docId` for subscription routing.
+     * @param exceptClientId - Client ID to exclude (typically the one who made the change).
+     */
+    notify(event: string, params: {
+        docId: string;
+        [k: string]: any;
+    }, exceptClientId?: string): void;
+    /**
+     * List all client IDs subscribed to a document.
+     */
+    listSubscriptions(docId: string): string[];
+    /**
+     * Get all active (connected) client IDs.
+     */
+    getConnectionIds(): string[];
+    /**
+     * Clean up all resources (heartbeat interval, client buffers, timers).
+     */
+    destroy(): void;
+    /**
+     * Trim buffer to keep only events within the sliding window (while connected)
+     * or all events (while disconnected — those are managed by the TTL timer).
+     */
+    private _trimBuffer;
+    private _writeEvent;
+    private _startHeartbeat;
+    private _cleanupClient;
+}
+
+export { type BufferedEvent, SSEServer, type SSEServerOptions };

package/dist/net/rest/SSEServer.js

@@ -0,0 +1,248 @@
+import "../../chunk-IZ2YBCUP.js";
+class SSEServer {
+  clients = /* @__PURE__ */ new Map();
+  heartbeatInterval = null;
+  heartbeatIntervalMs;
+  bufferTTLMs;
+  bufferWindowMs;
+  auth;
+  constructor(options) {
+    this.heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 3e4;
+    this.bufferTTLMs = options?.bufferTTLMs ?? 3e5;
+    this.bufferWindowMs = options?.bufferWindowMs ?? this.bufferTTLMs;
+    this.auth = options?.auth;
+    this._startHeartbeat();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  static noop() {
+  }
+  /**
+   * Opens an SSE connection for a client. Returns a ReadableStream that the
+   * framework pipes to the HTTP response.
+   *
+   * If `lastEventId` is provided (from the Last-Event-ID header on reconnect),
+   * buffered events are replayed. If the buffer has expired, a `resync` event
+   * is sent so the client knows to do a full re-sync.
+   *
+   * The framework MUST call `disconnect(clientId)` when the response closes.
+   */
+  connect(clientId, lastEventId) {
+    let client = this.clients.get(clientId);
+    if (client) {
+      if (client.expiryTimer) {
+        globalThis.clearTimeout(client.expiryTimer);
+        client.expiryTimer = null;
+      }
+      if (client.writer) {
+        client.writer.close().catch(SSEServer.noop);
+        client.writer = null;
+      }
+      client.disconnectedAt = null;
+    } else {
+      client = {
+        writer: null,
+        encoder: new TextEncoder(),
+        subscriptions: /* @__PURE__ */ new Set(),
+        buffer: [],
+        nextEventId: 1,
+        disconnectedAt: null,
+        expiryTimer: null
+      };
+      this.clients.set(clientId, client);
+    }
+    const { readable, writable } = new TransformStream();
+    client.writer = writable.getWriter();
+    if (lastEventId) {
+      const lastId = parseInt(lastEventId, 10);
+      if (isNaN(lastId)) {
+        this._writeEvent(client, { id: client.nextEventId++, event: "resync", data: "{}", timestamp: Date.now() });
+        client.buffer = [];
+      } else {
+        const knownClient = client.nextEventId > 1;
+        client.buffer = client.buffer.filter((e) => e.id > lastId);
+        if (!knownClient && lastId > 0) {
+          this._writeEvent(client, { id: client.nextEventId++, event: "resync", data: "{}", timestamp: Date.now() });
+        } else {
+          for (const event of client.buffer) {
+            this._writeEvent(client, event);
+          }
+        }
+      }
+    }
+    return readable;
+  }
+  /**
+   * Called when the SSE response stream closes. The framework MUST call this
+   * when the HTTP response ends (e.g., on the response 'close' event).
+   *
+   * Starts the buffer expiry timer. If the client reconnects before it expires,
+   * buffered events are replayed.
+   */
+  disconnect(clientId) {
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    client.writer = null;
+    client.disconnectedAt = Date.now();
+    client.expiryTimer = globalThis.setTimeout(() => {
+      this._cleanupClient(clientId);
+    }, this.bufferTTLMs);
+  }
+  /**
+   * Subscribe a client to documents.
+   *
+   * @param clientId - The client to subscribe.
+   * @param docIds - Document IDs to subscribe to.
+   * @param ctx - Auth context for authorization checks.
+   * @returns The list of document IDs successfully subscribed.
+   */
+  async subscribe(clientId, docIds, ctx) {
+    const client = this.clients.get(clientId);
+    if (!client) return [];
+    const allowed = [];
+    for (const docId of docIds) {
+      if (this.auth) {
+        try {
+          const ok = await this.auth.canAccess(ctx, docId, "read", "subscribe");
+          if (!ok) continue;
+        } catch {
+          continue;
+        }
+      }
+      allowed.push(docId);
+      client.subscriptions.add(docId);
+    }
+    return allowed;
+  }
+  /**
+   * Unsubscribe a client from documents.
+   */
+  unsubscribe(clientId, docIds) {
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    for (const docId of docIds) {
+      client.subscriptions.delete(docId);
+    }
+  }
+  /**
+   * Send a notification event to all clients subscribed to the document.
+   *
+   * Connected clients receive the event immediately via their SSE stream.
+   * Disconnected clients (within buffer TTL) get the event buffered for replay.
+   *
+   * @param event - The SSE event type (e.g. 'changesCommitted', 'docDeleted').
+   * @param params - Event data. Must include `docId` for subscription routing.
+   * @param exceptClientId - Client ID to exclude (typically the one who made the change).
+   */
+  notify(event, params, exceptClientId) {
+    const { docId } = params;
+    const data = JSON.stringify(params);
+    for (const [clientId, client] of this.clients) {
+      if (clientId === exceptClientId) continue;
+      if (!client.subscriptions.has(docId)) continue;
+      const now = Date.now();
+      const buffered = {
+        id: client.nextEventId++,
+        event,
+        data,
+        timestamp: now
+      };
+      client.buffer.push(buffered);
+      this._trimBuffer(client, now);
+      if (client.writer) {
+        this._writeEvent(client, buffered);
+      }
+    }
+  }
+  /**
+   * List all client IDs subscribed to a document.
+   */
+  listSubscriptions(docId) {
+    const result = [];
+    for (const [clientId, client] of this.clients) {
+      if (client.subscriptions.has(docId)) {
+        result.push(clientId);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all active (connected) client IDs.
+   */
+  getConnectionIds() {
+    const result = [];
+    for (const [clientId, client] of this.clients) {
+      if (client.writer) {
+        result.push(clientId);
+      }
+    }
+    return result;
+  }
+  /**
+   * Clean up all resources (heartbeat interval, client buffers, timers).
+   */
+  destroy() {
+    if (this.heartbeatInterval) {
+      globalThis.clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    for (const [, client] of this.clients) {
+      if (client.expiryTimer) {
+        globalThis.clearTimeout(client.expiryTimer);
+      }
+      if (client.writer) {
+        client.writer.close().catch(SSEServer.noop);
+      }
+    }
+    this.clients.clear();
+  }
+  // --- Private Helpers ---
+  /**
+   * Trim buffer to keep only events within the sliding window (while connected)
+   * or all events (while disconnected — those are managed by the TTL timer).
+   */
+  _trimBuffer(client, now) {
+    if (client.disconnectedAt !== null) return;
+    const cutoff = now - this.bufferWindowMs;
+    const idx = client.buffer.findIndex((e) => e.timestamp >= cutoff);
+    if (idx > 0) {
+      client.buffer = client.buffer.slice(idx);
+    } else if (idx === -1) {
+      client.buffer = [];
+    }
+  }
+  _writeEvent(client, event) {
+    if (!client.writer) return;
+    const msg = `id: ${event.id}
+event: ${event.event}
+data: ${event.data}
+
+`;
+    client.writer.write(client.encoder.encode(msg)).catch(() => {
+    });
+  }
+  _startHeartbeat() {
+    this.heartbeatInterval = globalThis.setInterval(() => {
+      const heartbeat = ": heartbeat\n\n";
+      for (const client of this.clients.values()) {
+        if (client.writer) {
+          client.writer.write(client.encoder.encode(heartbeat)).catch(() => {
+          });
+        }
+      }
+    }, this.heartbeatIntervalMs);
+  }
+  _cleanupClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    if (client.expiryTimer) {
+      globalThis.clearTimeout(client.expiryTimer);
+    }
+    if (client.writer) {
+      client.writer.close().catch(SSEServer.noop);
+    }
+    this.clients.delete(clientId);
+  }
+}
+export {
+  SSEServer
+};

package/dist/net/rest/index.d.ts

@@ -0,0 +1,12 @@
+export { PatchesREST, PatchesRESTOptions } from './PatchesREST.js';
+export { BufferedEvent, SSEServer, SSEServerOptions } from './SSEServer.js';
+export { encodeDocId, normalizeIds } from './utils.js';
+import 'easy-signal';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+import '../PatchesConnection.js';
+import '../protocol/types.js';
+import '../websocket/AuthorizationProvider.js';
+import '../../server/types.js';

package/dist/net/rest/index.js

@@ -0,0 +1,8 @@
+import "../../chunk-IZ2YBCUP.js";
+export * from "./PatchesREST.js";
+export * from "./SSEServer.js";
+import { encodeDocId, normalizeIds } from "./utils.js";
+export {
+  encodeDocId,
+  normalizeIds
+};

package/dist/net/rest/utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Encode a hierarchical doc ID for use in URL path segments.
+ * Each segment is individually encoded so slashes are preserved as path separators.
+ *
+ * @example encodeDocId('users/abc/stats/2026-01') => 'users/abc/stats/2026-01'
+ * @example encodeDocId('docs/hello world') => 'docs/hello%20world'
+ */
+declare function encodeDocId(docId: string): string;
+/**
+ * Normalize a string or string array to a string array.
+ */
+declare function normalizeIds(ids: string | string[]): string[];
+
+export { encodeDocId, normalizeIds };

package/dist/net/rest/utils.js

@@ -0,0 +1,11 @@
+import "../../chunk-IZ2YBCUP.js";
+function encodeDocId(docId) {
+  return docId.split("/").map(encodeURIComponent).join("/");
+}
+function normalizeIds(ids) {
+  return Array.isArray(ids) ? ids : [ids];
+}
+export {
+  encodeDocId,
+  normalizeIds
+};

package/dist/net/websocket/PatchesWebSocket.d.ts

@@ -1,5 +1,6 @@
 import { Signal } from 'easy-signal';
 import { PatchesClient } from '../PatchesClient.js';
+import { PatchesConnection } from '../PatchesConnection.js';
 import { ConnectionState } from '../protocol/types.js';
 import { WebSocketTransport, WebSocketOptions } from './WebSocketTransport.js';
 import '../../types.js';
@@ -15,7 +16,7 @@ import '../../utils/deferred.js';
  * versioning, and other OT-specific functionality
  * over a WebSocket connection.
  */
-declare class PatchesWebSocket extends PatchesClient {
+declare class PatchesWebSocket extends PatchesClient implements PatchesConnection {
     transport: WebSocketTransport;
     /** Signal emitted when the underlying WebSocket connection state changes. */
     readonly onStateChange: Signal<(state: ConnectionState) => void>;
@@ -25,6 +26,9 @@ declare class PatchesWebSocket extends PatchesClient {
      * @param wsOptions - Optional configuration for the underlying WebSocket connection
      */
     constructor(url: string, wsOptions?: WebSocketOptions);
+    /** The WebSocket server URL. */
+    get url(): string;
+    set url(url: string);
     /**
      * Establishes a connection to the Patches server.
      * @returns A promise that resolves when the connection is established

package/dist/net/websocket/PatchesWebSocket.js

@@ -18,6 +18,14 @@ class PatchesWebSocket extends PatchesClient {
     this.transport = transport;
     this.onStateChange = this.transport.onStateChange;
   }
+  // --- URL ---
+  /** The WebSocket server URL. */
+  get url() {
+    return this.transport.url;
+  }
+  set url(url) {
+    this.transport.url = url;
+  }
   // --- Connection Management ---
   /**
    * Establishes a connection to the Patches server.

package/dist/solid/context.d.ts

@@ -9,13 +9,12 @@ import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
 import '../BaseDoc-BT18xPxU.js';
 import '../client/PatchesStore.js';
+import '../algorithms/ot/shared/changeBatching.js';
+import '../net/PatchesConnection.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';
-import '../net/websocket/PatchesWebSocket.js';
-import '../net/PatchesClient.js';
 import '../net/websocket/WebSocketTransport.js';
 import '../utils/deferred.js';
-import '../algorithms/ot/shared/changeBatching.js';
 
 /**
  * Context value containing Patches and optional PatchesSync instances.

package/dist/solid/index.d.ts

@@ -14,10 +14,9 @@ import '../client/ClientAlgorithm.js';
 import '../BaseDoc-BT18xPxU.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
+import '../algorithms/ot/shared/changeBatching.js';
+import '../net/PatchesConnection.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';
-import '../net/websocket/PatchesWebSocket.js';
-import '../net/PatchesClient.js';
 import '../net/websocket/WebSocketTransport.js';
 import '../utils/deferred.js';
-import '../algorithms/ot/shared/changeBatching.js';

package/dist/vue/index.d.ts

@@ -14,10 +14,9 @@ import '../client/ClientAlgorithm.js';
 import '../BaseDoc-BT18xPxU.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
+import '../algorithms/ot/shared/changeBatching.js';
+import '../net/PatchesConnection.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';
-import '../net/websocket/PatchesWebSocket.js';
-import '../net/PatchesClient.js';
 import '../net/websocket/WebSocketTransport.js';
 import '../utils/deferred.js';
-import '../algorithms/ot/shared/changeBatching.js';

package/dist/vue/provider.d.ts

@@ -9,13 +9,12 @@ import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
 import '../BaseDoc-BT18xPxU.js';
 import '../client/PatchesStore.js';
+import '../algorithms/ot/shared/changeBatching.js';
+import '../net/PatchesConnection.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';
-import '../net/websocket/PatchesWebSocket.js';
-import '../net/PatchesClient.js';
 import '../net/websocket/WebSocketTransport.js';
 import '../utils/deferred.js';
-import '../algorithms/ot/shared/changeBatching.js';
 
 /**
  * Injection key for Patches instance.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.7.24",
+  "version": "0.8.0",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {