@dabble/patches 0.9.1 → 0.9.2

package/README.md

@@ -254,7 +254,7 @@ When to use which? WebSocket for document sync. WebRTC for presence/cursors to r
 
 ### Awareness (Presence & Cursors)
 
-Show who's online, where their cursor is, what they're selecting. Works over both WebSocket and WebRTC.
+Show who's online, where their cursor is, what they're selecting. `WebRTCAwareness` carries presence over peer-to-peer WebRTC connections, with the signaling handshake multiplexed over whatever sync channel you already have open — `WebSocketTransport` or `PatchesREST` (SSE+REST). No second connection, same `clientId`.
 
 See [Awareness documentation](./docs/awareness.md) for implementation details.
 

package/dist/{BaseDoc-CXHXcW18.d.ts → BaseDoc-rCKMFV6B.d.ts}

@@ -246,4 +246,4 @@ declare abstract class BaseDoc<T extends object = object> extends ReadonlyStoreC
     abstract import(snapshot: PatchesSnapshot<T>): void;
 }
 
-export { BaseDoc as B, OTDoc as O, type PatchesDocOptions as P, type PatchesDoc as a };
+export { BaseDoc as B, OTDoc as O, type PatchesDoc as P, type PatchesDocOptions as a };

package/dist/algorithms/ot/server/createVersion.d.ts

@@ -1,5 +1,5 @@
 import { OTStoreBackend } from '../../../server/types.js';
-import { EditableVersionMetadata, VersionMetadata, Change } from '../../../types.js';
+import { EditableVersionMetadata, Change, VersionMetadata } from '../../../types.js';
 import '../../../json-patch/types.js';
 import '../../../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/BaseDoc.d.ts

@@ -1,6 +1,6 @@
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';
-export { B as BaseDoc } from '../BaseDoc-CXHXcW18.js';
+export { B as BaseDoc } from '../BaseDoc-rCKMFV6B.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/ClientAlgorithm.d.ts

@@ -1,6 +1,6 @@
 import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
-import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import { PatchesStore, TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { LWWClientStore } from './LWWClientStore.js';
-import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWDoc.d.ts

@@ -1,6 +1,6 @@
 import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
-import { B as BaseDoc } from '../BaseDoc-CXHXcW18.js';
+import { B as BaseDoc } from '../BaseDoc-rCKMFV6B.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import 'easy-signal';

package/dist/client/OTAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { OTClientStore } from './OTClientStore.js';
-import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { a as PatchesDocOptions, P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/OTDoc.d.ts

@@ -1,5 +1,5 @@
 import '../types.js';
-export { O as OTDoc } from '../BaseDoc-CXHXcW18.js';
+export { O as OTDoc } from '../BaseDoc-rCKMFV6B.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';

package/dist/client/Patches.d.ts

@@ -3,7 +3,7 @@ import { Unsubscriber } from 'easy-signal';
 import { JSONPatchOp } from '../json-patch/types.js';
 import { Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
-import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { a as PatchesDocOptions, P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import { AlgorithmName } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/PatchesBranchClient.d.ts

@@ -8,7 +8,7 @@ import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
 import './ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 
 interface PatchesBranchClientOptions {
     /** Algorithm to use for the branch document (defaults to the Patches instance default). */

package/dist/client/PatchesDoc.d.ts

@@ -1,6 +1,6 @@
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';
-export { O as OTDoc, a as PatchesDoc, P as PatchesDocOptions } from '../BaseDoc-CXHXcW18.js';
+export { O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-rCKMFV6B.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/factories.d.ts

@@ -1,6 +1,6 @@
 import { AlgorithmName } from './PatchesStore.js';
 import { Patches } from './Patches.js';
-import { P as PatchesDocOptions } from '../BaseDoc-CXHXcW18.js';
+import { a as PatchesDocOptions } from '../BaseDoc-rCKMFV6B.js';
 import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BaseDoc, O as OTDoc, a as PatchesDoc, P as PatchesDocOptions } from '../BaseDoc-CXHXcW18.js';
+export { B as BaseDoc, O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-rCKMFV6B.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmExternalDBPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches, upgradePatchesDB } from './factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
 export { OTIndexedDBStore } from './OTIndexedDBStore.js';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Delta } from '@dabble/delta';
-export { B as BaseDoc, O as OTDoc, a as PatchesDoc, P as PatchesDocOptions } from './BaseDoc-CXHXcW18.js';
+export { B as BaseDoc, O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from './BaseDoc-rCKMFV6B.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmExternalDBPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches, upgradePatchesDB } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';

package/dist/net/PatchesSync.d.ts

@@ -13,7 +13,7 @@ import { WebSocketOptions } from './websocket/WebSocketTransport.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../utils/deferred.js';
 
 interface PatchesSyncState {

package/dist/net/index.d.ts

@@ -4,17 +4,19 @@ 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 { PatchesRESTSignalingTransport } from './rest/PatchesRESTSignalingTransport.js';
 export { BufferedEvent, SSEServer, SSEServerOptions } from './rest/SSEServer.js';
+export { SSESignalingService } from './rest/SSESignalingService.js';
 export { normalizeIds } from './rest/utils.js';
 export { JSONRPCClient } from './protocol/JSONRPCClient.js';
 export { ApiDefinition, ConnectionSignalSubscriber, JSONRPCServer, JSONRPCServerOptions, MessageHandler } from './protocol/JSONRPCServer.js';
 export { getAuthContext, getClientId } from './serverContext.js';
-export { AwarenessUpdateNotificationParams, BranchAPI, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams } from './protocol/types.js';
+export { AwarenessUpdateNotificationParams, BranchAPI, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams, SignalingTransport } from './protocol/types.js';
 export { rpcError, rpcNotification, rpcResponse } from './protocol/utils.js';
 export { Access, AuthContext, AuthorizationProvider, allowAll, assertNotDeleted, denyAll } from './websocket/AuthorizationProvider.js';
 export { onlineState } from './websocket/onlineState.js';
 export { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
-export { JsonRpcMessage, SignalingService } from './websocket/SignalingService.js';
+export { JsonRpcMessage, SignalingService } from './signaling/SignalingService.js';
 export { WebSocketServer, WebSocketServerOptions } from './websocket/WebSocketServer.js';
 export { WebSocketOptions, WebSocketTransport } from './websocket/WebSocketTransport.js';
 export { CommitChangesOptions } from '../types.js';
@@ -23,7 +25,7 @@ import '../algorithms/ot/shared/changeBatching.js';
 import '../client/BranchClientStore.js';
 import '../client/ClientAlgorithm.js';
 import '../json-patch/types.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';
 import '../client/Patches.js';
 import '../server/types.js';

package/dist/net/index.js

@@ -12,7 +12,7 @@ export * from "./protocol/utils.js";
 export * from "./websocket/AuthorizationProvider.js";
 export * from "./websocket/onlineState.js";
 export * from "./websocket/PatchesWebSocket.js";
-export * from "./websocket/SignalingService.js";
+export * from "./signaling/SignalingService.js";
 export * from "./websocket/WebSocketServer.js";
 export * from "./websocket/WebSocketTransport.js";
 export {

package/dist/net/protocol/types.d.ts

@@ -1,4 +1,4 @@
-import { Unsubscriber } from 'easy-signal';
+import { Unsubscriber, Signal } from 'easy-signal';
 import { ListBranchesOptions, Branch, CreateBranchMetadata, EditableBranchMetadata, PatchesState, Change, ChangeInput, CommitChangesOptions, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
@@ -31,6 +31,20 @@ interface ClientTransport {
      */
     onMessage(cb: (raw: string) => void): Unsubscriber;
 }
+/**
+ * Lifecycle-aware transport that {@link WebRTCTransport} can ride on top of as a
+ * signaling channel. Anything implementing {@link ClientTransport} plus a
+ * `connect()` / `state` / `onStateChange` triplet qualifies — including
+ * `WebSocketTransport` and `PatchesRESTSignalingTransport`.
+ */
+interface SignalingTransport extends ClientTransport {
+    /** Open the underlying channel. May be a no-op if the channel is already open. */
+    connect(): Promise<void> | void;
+    /** Current connection state. */
+    readonly state: ConnectionState;
+    /** Emits whenever {@link state} changes. */
+    readonly onStateChange: Signal<(state: ConnectionState) => void>;
+}
 /**
  * Minimal contract for server-side transports that can have **multiple** logical peers.
  * Each message must indicate the **from / to** connection. Any additional lifecycle
@@ -155,4 +169,4 @@ interface SignalNotificationParams {
     data: any;
 }
 
-export { type AwarenessUpdateNotificationParams, type BranchAPI, type ClientTransport, CommitChangesOptions, type ConnectionState, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type Message, type PatchesAPI, type PatchesNotificationParams, type ServerTransport, type SignalNotificationParams };
+export { type AwarenessUpdateNotificationParams, type BranchAPI, type ClientTransport, CommitChangesOptions, type ConnectionState, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type Message, type PatchesAPI, type PatchesNotificationParams, type ServerTransport, type SignalNotificationParams, type SignalingTransport };

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

@@ -37,6 +37,11 @@ declare class PatchesREST implements PatchesConnection {
     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>;
+    /**
+     * Emits raw JSON-RPC strings received over the multiplexed `signal` SSE channel.
+     * Used by `PatchesRESTSignalingTransport` to drive `WebRTCTransport`'s signaling.
+     */
+    readonly onSignal: easy_signal.Signal<(raw: string) => void>;
     private _url;
     private _state;
     private eventSource;
@@ -46,6 +51,8 @@ declare class PatchesREST implements PatchesConnection {
     constructor(url: string, options?: PatchesRESTOptions);
     get url(): string;
     set url(url: string);
+    /** Current connection state of the underlying SSE stream. */
+    get state(): ConnectionState;
     connect(): Promise<void>;
     disconnect(): void;
     subscribe(ids: string | string[]): Promise<string[]>;
@@ -91,6 +98,22 @@ declare class PatchesREST implements PatchesConnection {
      * `POST /docs/:docId/_members/:uid/revoke`
      */
     revokeMember(docId: string, targetUid: string): Promise<boolean>;
+    /**
+     * POSTs a raw JSON-RPC string to `/signal/:clientId`. Used as the upstream
+     * half of the multiplexed signaling channel: receive happens via the `signal`
+     * SSE event (see {@link onSignal}).
+     *
+     * The body is sent verbatim — callers pass an already-stringified JSON-RPC
+     * message. The endpoint forwards it to {@link SignalingService.handleClientMessage}.
+     *
+     * Silently no-ops when the SSE stream is not connected. Signaling is
+     * inherently best-effort and the server has no live `signal` channel back
+     * to this client until the stream is up, so a frame sent before connect
+     * resolves can't be relayed anyway. Throwing here would surface as an
+     * unhandled rejection through `JSONRPCClient.call`, which doesn't await
+     * `transport.send`.
+     */
+    sendSignal(raw: string): Promise<void>;
     private _setState;
     private _getHeaders;
     private _fetch;

package/dist/net/rest/PatchesREST.js

@@ -13,6 +13,11 @@ class PatchesREST {
   onStateChange = signal();
   onChangesCommitted = signal();
   onDocDeleted = signal();
+  /**
+   * Emits raw JSON-RPC strings received over the multiplexed `signal` SSE channel.
+   * Used by `PatchesRESTSignalingTransport` to drive `WebRTCTransport`'s signaling.
+   */
+  onSignal = signal();
   _url;
   _state = "disconnected";
   eventSource = null;
@@ -36,6 +41,11 @@ class PatchesREST {
   set url(url) {
     this._url = url.replace(/\/$/, "");
   }
+  // --- Connection State ---
+  /** Current connection state of the underlying SSE stream. */
+  get state() {
+    return this._state;
+  }
   // --- Connection Lifecycle ---
   connect() {
     this.shouldBeConnected = true;
@@ -94,6 +104,9 @@ class PatchesREST {
         } catch {
         }
       });
+      es.addEventListener("signal", (e) => {
+        this.onSignal.emit(e.data);
+      });
       es.addEventListener("resync", () => {
         if (!this.shouldBeConnected) return;
         this._setState("disconnected");
@@ -235,6 +248,39 @@ class PatchesREST {
     );
     return Boolean(result?.ok);
   }
+  // --- WebRTC Signaling ---
+  /**
+   * POSTs a raw JSON-RPC string to `/signal/:clientId`. Used as the upstream
+   * half of the multiplexed signaling channel: receive happens via the `signal`
+   * SSE event (see {@link onSignal}).
+   *
+   * The body is sent verbatim — callers pass an already-stringified JSON-RPC
+   * message. The endpoint forwards it to {@link SignalingService.handleClientMessage}.
+   *
+   * Silently no-ops when the SSE stream is not connected. Signaling is
+   * inherently best-effort and the server has no live `signal` channel back
+   * to this client until the stream is up, so a frame sent before connect
+   * resolves can't be relayed anyway. Throwing here would surface as an
+   * unhandled rejection through `JSONRPCClient.call`, which doesn't await
+   * `transport.send`.
+   */
+  async sendSignal(raw) {
+    if (this._state !== "connected") return;
+    const headers = await this._getHeaders();
+    const response = await globalThis.fetch(`${this._url}/signal/${this.clientId}`, {
+      method: "POST",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: raw,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new StatusError(response.status, response.statusText);
+    }
+  }
   // --- Private Helpers ---
   _setState(state) {
     if (state === this._state) return;

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

@@ -0,0 +1,42 @@
+import * as easy_signal from 'easy-signal';
+import { Unsubscriber } from 'easy-signal';
+import { SignalingTransport, ConnectionState } from '../protocol/types.js';
+import { PatchesREST } from './PatchesREST.js';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+import '../PatchesConnection.js';
+import '../invite.js';
+
+/**
+ * Adapter that exposes a {@link PatchesREST} connection as a {@link SignalingTransport}
+ * for `WebRTCTransport`. Multiplexes signaling over the existing SSE stream:
+ *
+ * - **send** → `PatchesREST.sendSignal()` → `POST /signal/:clientId`.
+ * - **receive** → subscribes to `PatchesREST.onSignal` (the `signal` SSE event).
+ *
+ * Does not own the connection. The application calls `patches.connect()`
+ * directly; `connect()` here just delegates so callers can still `await` it.
+ */
+declare class PatchesRESTSignalingTransport implements SignalingTransport {
+    private patches;
+    /**
+     * @param patches - The shared `PatchesREST` instance handling document sync.
+     *   The same `clientId` is used for both, so signaling addressing matches.
+     */
+    constructor(patches: PatchesREST);
+    get state(): ConnectionState;
+    get onStateChange(): easy_signal.Signal<(state: ConnectionState) => void>;
+    /**
+     * Delegates to {@link PatchesREST.connect}. Safe to call multiple times — if
+     * the SSE stream is already open, the underlying call is a no-op.
+     */
+    connect(): Promise<void>;
+    /** Sends a raw JSON-RPC frame upstream over the signaling REST endpoint. */
+    send(raw: string): Promise<void>;
+    /** Subscribes to inbound JSON-RPC frames received via the `signal` SSE event. */
+    onMessage(cb: (raw: string) => void): Unsubscriber;
+}
+
+export { PatchesRESTSignalingTransport };

package/dist/net/rest/PatchesRESTSignalingTransport.js

@@ -0,0 +1,34 @@
+import "../../chunk-IZ2YBCUP.js";
+class PatchesRESTSignalingTransport {
+  /**
+   * @param patches - The shared `PatchesREST` instance handling document sync.
+   *   The same `clientId` is used for both, so signaling addressing matches.
+   */
+  constructor(patches) {
+    this.patches = patches;
+  }
+  get state() {
+    return this.patches.state;
+  }
+  get onStateChange() {
+    return this.patches.onStateChange;
+  }
+  /**
+   * Delegates to {@link PatchesREST.connect}. Safe to call multiple times — if
+   * the SSE stream is already open, the underlying call is a no-op.
+   */
+  async connect() {
+    await this.patches.connect();
+  }
+  /** Sends a raw JSON-RPC frame upstream over the signaling REST endpoint. */
+  send(raw) {
+    return this.patches.sendSignal(raw);
+  }
+  /** Subscribes to inbound JSON-RPC frames received via the `signal` SSE event. */
+  onMessage(cb) {
+    return this.patches.onSignal(cb);
+  }
+}
+export {
+  PatchesRESTSignalingTransport
+};

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

@@ -127,6 +127,21 @@ declare class SSEServer {
      * @param exceptClientId - Client ID to exclude (typically the one who made the change).
      */
     notify(docId: string, event: string, params: Record<string, any>, exceptClientId?: string): void;
+    /**
+     * Send an event directly to a single connected client, bypassing subscription
+     * routing. Used for client-targeted traffic like WebRTC signaling.
+     *
+     * Unlike {@link notify}, this does NOT buffer through expiry: if the client
+     * is currently disconnected, the call returns false and the event is dropped.
+     * Stale signaling replayed after a buffer expiry is harmful (peers gone, ICE
+     * candidates moot), so we deliberately do not preserve it.
+     *
+     * @param clientId - Target client.
+     * @param event - SSE event type (e.g. `'signal'`).
+     * @param data - Pre-serialised event payload.
+     * @returns true if the client was connected and the event was written.
+     */
+    sendToClient(clientId: string, event: string, data: string): boolean;
     /**
      * List all client IDs subscribed to a document.
      */

package/dist/net/rest/SSEServer.js

@@ -157,6 +157,31 @@ class SSEServer {
       }
     }
   }
+  /**
+   * Send an event directly to a single connected client, bypassing subscription
+   * routing. Used for client-targeted traffic like WebRTC signaling.
+   *
+   * Unlike {@link notify}, this does NOT buffer through expiry: if the client
+   * is currently disconnected, the call returns false and the event is dropped.
+   * Stale signaling replayed after a buffer expiry is harmful (peers gone, ICE
+   * candidates moot), so we deliberately do not preserve it.
+   *
+   * @param clientId - Target client.
+   * @param event - SSE event type (e.g. `'signal'`).
+   * @param data - Pre-serialised event payload.
+   * @returns true if the client was connected and the event was written.
+   */
+  sendToClient(clientId, event, data) {
+    const client = this.clients.get(clientId);
+    if (!client || !client.writer) return false;
+    this._writeEvent(client, {
+      id: client.nextEventId++,
+      event,
+      data,
+      timestamp: Date.now()
+    });
+    return true;
+  }
   /**
    * List all client IDs subscribed to a document.
    */

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

@@ -0,0 +1,60 @@
+import { SignalingService, JsonRpcMessage } from '../signaling/SignalingService.js';
+import { SSEServer } from './SSEServer.js';
+import '../protocol/types.js';
+import 'easy-signal';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+import '../websocket/AuthorizationProvider.js';
+import '../../server/types.js';
+
+/**
+ * {@link SignalingService} that delivers WebRTC signaling frames over an
+ * {@link SSEServer} stream as the multiplexed `signal` event.
+ *
+ * Wire it up in your routes alongside the existing SSE doc-sync handlers.
+ *
+ * **Security:** the `fromId` passed to {@link handleClientMessage} MUST come
+ * from your authenticated session, not from the request URL. If you trust the
+ * URL `:clientId`, client A can POST to `/signal/B` and impersonate B in the
+ * WebRTC mesh, redirecting peer connections. Treat the URL parameter as
+ * untrusted input and bind sender identity to auth.
+ *
+ * ```typescript
+ * const sse = new SSEServer();
+ * const signaling = new SSESignalingService(sse);
+ *
+ * // GET /events/:clientId — after creating the SSE stream:
+ * const clientId = req.auth.clientId; // authenticated, not URL-derived
+ * await signaling.onClientConnected(clientId);
+ *
+ * // POST /signal/:clientId
+ * app.post('/signal/:clientId', async (req, res) => {
+ *   if (req.auth.clientId !== req.params.clientId) return res.status(403).end();
+ *   const body = await readBody(req);
+ *   await signaling.handleClientMessage(req.auth.clientId, body);
+ *   res.status(204).end();
+ * });
+ *
+ * // On SSE stream close:
+ * await signaling.onClientDisconnected(clientId);
+ * ```
+ */
+declare class SSESignalingService extends SignalingService {
+    private sse;
+    constructor(sse: SSEServer);
+    /**
+     * Derived from the live SSE connection set rather than tracked separately,
+     * so peer-routing decisions can't drift from actual writer liveness. If a
+     * client's SSE stream silently dies, `getConnectionIds()` excludes it
+     * immediately and `handleClientMessage` will respond with "Target not
+     * connected" instead of relaying into the void.
+     */
+    getClients(): Promise<Set<string>>;
+    /** No-op: the SSEServer's connection set is the source of truth. */
+    setClients(_clients: Set<string>): Promise<void>;
+    send(id: string, message: JsonRpcMessage): void;
+}
+
+export { SSESignalingService };

package/dist/net/rest/SSESignalingService.js

@@ -0,0 +1,27 @@
+import "../../chunk-IZ2YBCUP.js";
+import { SignalingService } from "../signaling/SignalingService.js";
+class SSESignalingService extends SignalingService {
+  constructor(sse) {
+    super();
+    this.sse = sse;
+  }
+  /**
+   * Derived from the live SSE connection set rather than tracked separately,
+   * so peer-routing decisions can't drift from actual writer liveness. If a
+   * client's SSE stream silently dies, `getConnectionIds()` excludes it
+   * immediately and `handleClientMessage` will respond with "Target not
+   * connected" instead of relaying into the void.
+   */
+  async getClients() {
+    return new Set(this.sse.getConnectionIds());
+  }
+  /** No-op: the SSEServer's connection set is the source of truth. */
+  async setClients(_clients) {
+  }
+  send(id, message) {
+    this.sse.sendToClient(id, "signal", JSON.stringify(message));
+  }
+}
+export {
+  SSESignalingService
+};

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

@@ -1,5 +1,7 @@
 export { PatchesREST, PatchesRESTOptions } from './PatchesREST.js';
+export { PatchesRESTSignalingTransport } from './PatchesRESTSignalingTransport.js';
 export { BufferedEvent, SSEServer, SSEServerOptions } from './SSEServer.js';
+export { SSESignalingService } from './SSESignalingService.js';
 export { normalizeIds } from './utils.js';
 import 'easy-signal';
 import '../../types.js';
@@ -11,3 +13,4 @@ import '../protocol/types.js';
 import '../invite.js';
 import '../websocket/AuthorizationProvider.js';
 import '../../server/types.js';
+import '../signaling/SignalingService.js';

package/dist/net/rest/index.js

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

package/dist/net/signaling/SignalingService.d.ts

@@ -0,0 +1,74 @@
+import { JsonRpcRequest, JsonRpcResponse } from '../protocol/types.js';
+import 'easy-signal';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+/** Union type for all possible JSON-RPC message types */
+type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse;
+/**
+ * Service that facilitates WebRTC connection establishment by relaying signaling messages.
+ * Acts as a central hub for WebRTC peers to exchange connection information.
+ *
+ * Transport-agnostic: concrete subclasses implement {@link send} over WebSocket,
+ * SSE, or any other channel.
+ */
+declare abstract class SignalingService {
+    protected clients: Set<string>;
+    abstract send(id: string, message: JsonRpcMessage): void | Promise<void>;
+    /**
+     * Returns the list of all connected client IDs.
+     * @returns Array of client IDs
+     */
+    getClients(): Promise<Set<string>>;
+    /**
+     * Sets the list of all connected client IDs.
+     * @param clients - Set of client IDs
+     */
+    setClients(clients: Set<string>): Promise<void>;
+    /**
+     * Registers a new client connection with the signaling service.
+     * Assigns a unique ID to the client and informs them of other connected peers.
+     *
+     * @param id - Optional client ID (generated if not provided)
+     * @returns The client's assigned ID
+     */
+    onClientConnected(id?: string): Promise<string>;
+    /**
+     * Handles a client disconnection by removing them from the registry
+     * and notifying all other connected clients.
+     *
+     * @param id - ID of the disconnected client
+     */
+    onClientDisconnected(id: string): Promise<void>;
+    /**
+     * Handles a signaling message from a client, relaying WebRTC session data
+     * between peers to facilitate connection establishment.
+     *
+     * @param fromId - ID of the client sending the message
+     * @param message - The JSON-RPC message or its string representation
+     * @returns True if the message was a valid signaling message and was handled, false otherwise
+     */
+    handleClientMessage(fromId: string, message: string | JsonRpcRequest): Promise<boolean>;
+    /**
+     * Sends a successful JSON-RPC response to a client.
+     *
+     * @protected
+     * @param toId - ID of the client to send the response to
+     * @param id - Request ID to match in the response
+     * @param result - Result data to include in the response
+     */
+    protected respond(toId: string, id: number, result: any): Promise<void>;
+    /**
+     * Sends an error JSON-RPC response to a client.
+     *
+     * @protected
+     * @param toId - ID of the client to send the error response to
+     * @param id - Request ID to match in the response, or undefined for notifications
+     * @param message - Error message to include
+     */
+    protected respondError(toId: string, id: number | undefined, message: string): Promise<void>;
+}
+
+export { type JsonRpcMessage, SignalingService };

package/dist/net/signaling/SignalingService.js

@@ -0,0 +1,135 @@
+import "../../chunk-IZ2YBCUP.js";
+import { createId } from "crypto-id";
+class SignalingService {
+  clients = /* @__PURE__ */ new Set();
+  /**
+   * Returns the list of all connected client IDs.
+   * @returns Array of client IDs
+   */
+  async getClients() {
+    return new Set(this.clients);
+  }
+  /**
+   * Sets the list of all connected client IDs.
+   * @param clients - Set of client IDs
+   */
+  async setClients(clients) {
+    this.clients = clients;
+  }
+  /**
+   * Registers a new client connection with the signaling service.
+   * Assigns a unique ID to the client and informs them of other connected peers.
+   *
+   * @param id - Optional client ID (generated if not provided)
+   * @returns The client's assigned ID
+   */
+  async onClientConnected(id = createId(14)) {
+    const clients = await this.getClients();
+    clients.add(id);
+    await this.setClients(clients);
+    const welcome = {
+      jsonrpc: "2.0",
+      method: "peer-welcome",
+      params: {
+        id,
+        peers: Array.from(clients).filter((pid) => pid !== id)
+      }
+    };
+    await this.send(id, welcome);
+    return id;
+  }
+  /**
+   * Handles a client disconnection by removing them from the registry
+   * and notifying all other connected clients.
+   *
+   * @param id - ID of the disconnected client
+   */
+  async onClientDisconnected(id) {
+    const clients = await this.getClients();
+    clients.delete(id);
+    await this.setClients(clients);
+    const message = {
+      jsonrpc: "2.0",
+      method: "peer-disconnected",
+      params: { id }
+    };
+    await Promise.all(Array.from(clients).map((clientId) => this.send(clientId, message)));
+  }
+  /**
+   * Handles a signaling message from a client, relaying WebRTC session data
+   * between peers to facilitate connection establishment.
+   *
+   * @param fromId - ID of the client sending the message
+   * @param message - The JSON-RPC message or its string representation
+   * @returns True if the message was a valid signaling message and was handled, false otherwise
+   */
+  async handleClientMessage(fromId, message) {
+    let parsed;
+    try {
+      parsed = typeof message === "string" ? JSON.parse(message) : message;
+    } catch {
+      return false;
+    }
+    if (parsed.jsonrpc !== "2.0" || parsed.method !== "peer-signal" || !parsed.params?.to) return false;
+    const { params, id } = parsed;
+    const { to, data } = params;
+    const clients = await this.getClients();
+    if (!clients.has(to)) {
+      this.respondError(fromId, id, "Target not connected");
+      return true;
+    }
+    const outbound = {
+      jsonrpc: "2.0",
+      method: "signal",
+      params: {
+        from: fromId,
+        data
+      }
+    };
+    await this.send(to, outbound);
+    if (id !== void 0) {
+      await this.respond(fromId, id, "ok");
+    }
+    return true;
+  }
+  /**
+   * Sends a successful JSON-RPC response to a client.
+   *
+   * @protected
+   * @param toId - ID of the client to send the response to
+   * @param id - Request ID to match in the response
+   * @param result - Result data to include in the response
+   */
+  async respond(toId, id, result) {
+    const clients = await this.getClients();
+    if (!clients.has(toId)) return;
+    const response = {
+      jsonrpc: "2.0",
+      result,
+      id
+    };
+    await this.send(toId, response);
+  }
+  /**
+   * Sends an error JSON-RPC response to a client.
+   *
+   * @protected
+   * @param toId - ID of the client to send the error response to
+   * @param id - Request ID to match in the response, or undefined for notifications
+   * @param message - Error message to include
+   */
+  async respondError(toId, id, message) {
+    if (id === void 0) return;
+    const clients = await this.getClients();
+    if (!clients.has(toId)) return;
+    const response = {
+      jsonrpc: "2.0",
+      error: { code: -32e3, message },
+      id
+    };
+    await this.send(toId, response);
+  }
+}
+export {
+  SignalingService
+};

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

@@ -0,0 +1,7 @@
+export { JsonRpcMessage, SignalingService } from './SignalingService.js';
+import '../protocol/types.js';
+import 'easy-signal';
+import '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';

package/dist/net/signaling/index.js

@@ -0,0 +1 @@
+export * from "./SignalingService.js";

package/dist/net/webrtc/WebRTCAwareness.d.ts

@@ -6,8 +6,6 @@ import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
 import 'simple-peer';
-import '../websocket/WebSocketTransport.js';
-import '../../utils/deferred.js';
 
 /**
  * Base type for awareness states, representing arbitrary structured data

package/dist/net/webrtc/WebRTCTransport.d.ts

@@ -1,17 +1,17 @@
-import { ClientTransport, ConnectionState } from '../protocol/types.js';
+import { ClientTransport, ConnectionState, SignalingTransport } from '../protocol/types.js';
 import * as easy_signal from 'easy-signal';
 import Peer from 'simple-peer';
-import { WebSocketTransport } from '../websocket/WebSocketTransport.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
-import '../../utils/deferred.js';
 
 /**
  * WebRTC-based transport implementation that enables direct peer-to-peer communication.
- * Uses a WebSocket transport as a signaling channel to establish WebRTC connections.
- * Once connections are established, data flows directly between peers without going through a server.
+ * Uses a {@link SignalingTransport} (e.g. `WebSocketTransport`,
+ * `PatchesRESTSignalingTransport`) as a signaling channel to establish WebRTC
+ * connections. Once connections are established, data flows directly between peers
+ * without going through a server.
  */
 declare class WebRTCTransport implements ClientTransport {
     private transport;
@@ -36,14 +36,15 @@ declare class WebRTCTransport implements ClientTransport {
     readonly onPeerDisconnect: easy_signal.Signal<(peerId: string, peer: Peer.Instance) => void>;
     /**
      * Signal that emits when the underlying signaling transport's state changes.
-     * This is delegated directly from the WebSocketTransport.
+     * This is delegated directly from the signaling transport.
      */
     get onStateChange(): easy_signal.Signal<(state: ConnectionState) => void>;
     /**
      * Creates a new WebRTC transport instance.
-     * @param transport - The WebSocket transport to use for signaling
+     * @param transport - A signaling-capable transport (e.g. `WebSocketTransport`
+     *   or `PatchesRESTSignalingTransport`) used to relay WebRTC handshake messages.
      */
-    constructor(transport: WebSocketTransport);
+    constructor(transport: SignalingTransport);
     /**
      * Gets the unique ID assigned to this peer by the signaling server.
      * @returns The peer ID, or undefined if not yet connected

package/dist/net/webrtc/WebRTCTransport.js

@@ -6,7 +6,8 @@ import { rpcError } from "../protocol/utils.js";
 class WebRTCTransport {
   /**
    * Creates a new WebRTC transport instance.
-   * @param transport - The WebSocket transport to use for signaling
+   * @param transport - A signaling-capable transport (e.g. `WebSocketTransport`
+   *   or `PatchesRESTSignalingTransport`) used to relay WebRTC handshake messages.
    */
   constructor(transport) {
     this.transport = transport;
@@ -48,7 +49,7 @@ class WebRTCTransport {
   onPeerDisconnect = signal();
   /**
    * Signal that emits when the underlying signaling transport's state changes.
-   * This is delegated directly from the WebSocketTransport.
+   * This is delegated directly from the signaling transport.
    */
   get onStateChange() {
     return this.transport.onStateChange;

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

@@ -7,5 +7,3 @@ import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
 import 'simple-peer';
-import '../websocket/WebSocketTransport.js';
-import '../../utils/deferred.js';

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

@@ -1,71 +1,7 @@
-import { JsonRpcRequest, JsonRpcResponse } from '../protocol/types.js';
+export { JsonRpcMessage, SignalingService } from '../signaling/SignalingService.js';
+import '../protocol/types.js';
 import 'easy-signal';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
-
-/** Union type for all possible JSON-RPC message types */
-type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse;
-/**
- * Service that facilitates WebRTC connection establishment by relaying signaling messages.
- * Acts as a central hub for WebRTC peers to exchange connection information.
- */
-declare abstract class SignalingService {
-    protected clients: Set<string>;
-    abstract send(id: string, message: JsonRpcMessage): void | Promise<void>;
-    /**
-     * Returns the list of all connected client IDs.
-     * @returns Array of client IDs
-     */
-    getClients(): Promise<Set<string>>;
-    /**
-     * Sets the list of all connected client IDs.
-     * @param clients - Set of client IDs
-     */
-    setClients(clients: Set<string>): Promise<void>;
-    /**
-     * Registers a new client connection with the signaling service.
-     * Assigns a unique ID to the client and informs them of other connected peers.
-     *
-     * @param id - Optional client ID (generated if not provided)
-     * @returns The client's assigned ID
-     */
-    onClientConnected(id?: string): Promise<string>;
-    /**
-     * Handles a client disconnection by removing them from the registry
-     * and notifying all other connected clients.
-     *
-     * @param id - ID of the disconnected client
-     */
-    onClientDisconnected(id: string): Promise<void>;
-    /**
-     * Handles a signaling message from a client, relaying WebRTC session data
-     * between peers to facilitate connection establishment.
-     *
-     * @param fromId - ID of the client sending the message
-     * @param message - The JSON-RPC message or its string representation
-     * @returns True if the message was a valid signaling message and was handled, false otherwise
-     */
-    handleClientMessage(fromId: string, message: string | JsonRpcRequest): Promise<boolean>;
-    /**
-     * Sends a successful JSON-RPC response to a client.
-     *
-     * @protected
-     * @param toId - ID of the client to send the response to
-     * @param id - Request ID to match in the response
-     * @param result - Result data to include in the response
-     */
-    protected respond(toId: string, id: number, result: any): Promise<void>;
-    /**
-     * Sends an error JSON-RPC response to a client.
-     *
-     * @protected
-     * @param toId - ID of the client to send the error response to
-     * @param id - Request ID to match in the response, or undefined for notifications
-     * @param message - Error message to include
-     */
-    protected respondError(toId: string, id: number | undefined, message: string): Promise<void>;
-}
-
-export { type JsonRpcMessage, SignalingService };

package/dist/net/websocket/SignalingService.js

@@ -1,135 +1 @@
-import "../../chunk-IZ2YBCUP.js";
-import { createId } from "crypto-id";
-class SignalingService {
-  clients = /* @__PURE__ */ new Set();
-  /**
-   * Returns the list of all connected client IDs.
-   * @returns Array of client IDs
-   */
-  async getClients() {
-    return new Set(this.clients);
-  }
-  /**
-   * Sets the list of all connected client IDs.
-   * @param clients - Set of client IDs
-   */
-  async setClients(clients) {
-    this.clients = clients;
-  }
-  /**
-   * Registers a new client connection with the signaling service.
-   * Assigns a unique ID to the client and informs them of other connected peers.
-   *
-   * @param id - Optional client ID (generated if not provided)
-   * @returns The client's assigned ID
-   */
-  async onClientConnected(id = createId(14)) {
-    const clients = await this.getClients();
-    clients.add(id);
-    await this.setClients(clients);
-    const welcome = {
-      jsonrpc: "2.0",
-      method: "peer-welcome",
-      params: {
-        id,
-        peers: Array.from(this.clients).filter((pid) => pid !== id)
-      }
-    };
-    this.send(id, welcome);
-    return id;
-  }
-  /**
-   * Handles a client disconnection by removing them from the registry
-   * and notifying all other connected clients.
-   *
-   * @param id - ID of the disconnected client
-   */
-  async onClientDisconnected(id) {
-    const clients = await this.getClients();
-    clients.delete(id);
-    await this.setClients(clients);
-    const message = {
-      jsonrpc: "2.0",
-      method: "peer-disconnected",
-      params: { id }
-    };
-    await Promise.all(Array.from(clients).map((clientId) => this.send(clientId, message)));
-  }
-  /**
-   * Handles a signaling message from a client, relaying WebRTC session data
-   * between peers to facilitate connection establishment.
-   *
-   * @param fromId - ID of the client sending the message
-   * @param message - The JSON-RPC message or its string representation
-   * @returns True if the message was a valid signaling message and was handled, false otherwise
-   */
-  async handleClientMessage(fromId, message) {
-    let parsed;
-    try {
-      parsed = typeof message === "string" ? JSON.parse(message) : message;
-    } catch {
-      return false;
-    }
-    if (parsed.jsonrpc !== "2.0" || parsed.method !== "peer-signal" || !parsed.params?.to) return false;
-    const { params, id } = parsed;
-    const { to, data } = params;
-    const clients = await this.getClients();
-    if (!clients.has(to)) {
-      this.respondError(fromId, id, "Target not connected");
-      return true;
-    }
-    const outbound = {
-      jsonrpc: "2.0",
-      method: "signal",
-      params: {
-        from: fromId,
-        data
-      }
-    };
-    await this.send(to, outbound);
-    if (id !== void 0) {
-      await this.respond(fromId, id, "ok");
-    }
-    return true;
-  }
-  /**
-   * Sends a successful JSON-RPC response to a client.
-   *
-   * @protected
-   * @param toId - ID of the client to send the response to
-   * @param id - Request ID to match in the response
-   * @param result - Result data to include in the response
-   */
-  async respond(toId, id, result) {
-    const clients = await this.getClients();
-    if (!clients.has(toId)) return;
-    const response = {
-      jsonrpc: "2.0",
-      result,
-      id
-    };
-    await this.send(toId, response);
-  }
-  /**
-   * Sends an error JSON-RPC response to a client.
-   *
-   * @protected
-   * @param toId - ID of the client to send the error response to
-   * @param id - Request ID to match in the response, or undefined for notifications
-   * @param message - Error message to include
-   */
-  async respondError(toId, id, message) {
-    if (id === void 0) return;
-    const clients = await this.getClients();
-    if (!clients.has(toId)) return;
-    const response = {
-      jsonrpc: "2.0",
-      error: { code: -32e3, message },
-      id
-    };
-    await this.send(toId, response);
-  }
-}
-export {
-  SignalingService
-};
+export * from "../signaling/SignalingService.js";

package/dist/server/branchUtils.d.ts

@@ -1,5 +1,5 @@
 import { ApiDefinition } from '../net/protocol/JSONRPCServer.js';
-import { EditableBranchMetadata, CreateBranchMetadata, Branch } from '../types.js';
+import { EditableBranchMetadata, Branch, CreateBranchMetadata } from '../types.js';
 import 'easy-signal';
 import '../net/websocket/AuthorizationProvider.js';
 import './types.js';

package/dist/shared/doc-manager.d.ts

@@ -1,5 +1,5 @@
 import { Patches, OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';

package/dist/solid/context.d.ts

@@ -7,7 +7,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/BranchClientStore.js';

package/dist/solid/doc-manager.d.ts

@@ -6,5 +6,5 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';

package/dist/solid/index.d.ts

@@ -11,7 +11,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../algorithms/ot/shared/changeBatching.js';

package/dist/solid/primitives.d.ts

@@ -1,6 +1,6 @@
 import { Accessor } from 'solid-js';
 import { OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import { ChangeMutator } from '../types.js';
 import 'easy-signal';
 import '../json-patch/types.js';

package/dist/vue/composables.d.ts

@@ -1,6 +1,6 @@
-import { ShallowRef, Ref, MaybeRefOrGetter, MaybeRef } from 'vue';
+import { ShallowRef, Ref, MaybeRef, MaybeRefOrGetter } from 'vue';
 import { OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-CXHXcW18.js';
+import { P as PatchesDoc } from '../BaseDoc-rCKMFV6B.js';
 import { ChangeMutator } from '../types.js';
 import 'easy-signal';
 import '../json-patch/types.js';

package/dist/vue/doc-manager.d.ts

@@ -6,5 +6,5 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';

package/dist/vue/index.d.ts

@@ -11,7 +11,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../algorithms/ot/shared/changeBatching.js';

package/dist/vue/managed-docs.d.ts

@@ -1,4 +1,4 @@
-import { Ref, ShallowRef } from 'vue';
+import { ShallowRef, Ref } from 'vue';
 import { OpenDocOptions } from '../client/Patches.js';
 import 'easy-signal';
 import '../json-patch/types.js';
@@ -6,7 +6,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';
 
 /**

package/dist/vue/provider.d.ts

@@ -7,7 +7,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-CXHXcW18.js';
+import '../BaseDoc-rCKMFV6B.js';
 import '../client/PatchesStore.js';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/BranchClientStore.js';

package/package.json

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