@dabble/patches 0.9.1 → 0.9.5

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';
@@ -8,6 +10,6 @@ import '@dabble/delta';
 import '../../json-patch/types.js';
 import '../PatchesConnection.js';
 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,136 @@
+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" || !Array.isArray(parsed.params)) return false;
+    const { id } = parsed;
+    const [to, data] = parsed.params;
+    if (typeof to !== "string" || !to) return false;
+    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;
@@ -19,7 +20,7 @@ class WebRTCTransport {
       this.rpc.on("peer-disconnected", ({ id }) => {
         this._removePeer(id);
       }),
-      this.rpc.on("peer-signal", ({ from, data }) => {
+      this.rpc.on("signal", ({ from, data }) => {
         if (!this.peers.has(from)) {
           this._connectToPeer(from, false);
         }
@@ -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;
@@ -112,7 +113,7 @@ class WebRTCTransport {
   _connectToPeer(peerId, initiator) {
     const peer = new Peer({ initiator, trickle: false });
     peer.on("signal", (data) => {
-      this.rpc.call("peer-signal", peerId, data);
+      this.rpc.notify("peer-signal", peerId, data);
     });
     peer.on("connect", () => {
       this.peers.set(peerId, { id: peerId, peer, connected: true });

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/package.json

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