@igoforth/ws-rpc 1.0.0

package/dist/adapters/client.js

@@ -0,0 +1,241 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import "../protocol-_mpoOPp6.js";
+import "../errors-5BfreE63.js";
+import { t as WebSocketReadyState } from "../types-D_psiH09.js";
+import { n as defaultReconnectOptions, t as calculateReconnectDelay } from "../reconnect-CGAA_1Gf.js";
+import { t as RpcPeer } from "../default-BkrMd28n.js";
+import "./types.js";
+
+//#region src/adapters/client.ts
+/**
+* RPC Client with auto-reconnect
+*
+* Manages WebSocket connection lifecycle and provides RPC capabilities.
+*/
+var RpcClient = class {
+	localSchema;
+	remoteSchema;
+	provider;
+	hooks = {};
+	url;
+	reconnectOptions;
+	defaultTimeout;
+	protocols;
+	headers;
+	WebSocketImpl;
+	ws = null;
+	peer = null;
+	_state = "disconnected";
+	reconnectAttempt = 0;
+	reconnectTimeout = null;
+	intentionalClose = false;
+	constructor(options) {
+		this.url = options.url;
+		this.localSchema = options.localSchema;
+		this.remoteSchema = options.remoteSchema;
+		this.provider = options.provider;
+		this.reconnectOptions = options.reconnect === false ? false : {
+			...defaultReconnectOptions,
+			...options.reconnect
+		};
+		this.defaultTimeout = options.timeout ?? 3e4;
+		this.protocols = options.protocols;
+		this.headers = options.headers;
+		this.WebSocketImpl = options.WebSocket ?? globalThis.WebSocket;
+		if (options.onConnect) this.hooks.onConnect = options.onConnect;
+		if (options.onDisconnect) this.hooks.onDisconnect = options.onDisconnect;
+		if (options.onReconnect) this.hooks.onReconnect = options.onReconnect;
+		if (options.onReconnectFailed) this.hooks.onReconnectFailed = options.onReconnectFailed;
+		if (options.onEvent) this.hooks.onEvent = options.onEvent;
+		if (options.autoConnect) this.connect();
+	}
+	/**
+	* Current connection state
+	*/
+	get state() {
+		return this._state;
+	}
+	/**
+	* Whether the client is currently connected
+	*/
+	get isConnected() {
+		return this._state === "connected" && this.peer?.isOpen === true;
+	}
+	/**
+	* Get the driver for calling remote methods
+	*
+	* @returns Driver proxy for calling remote methods
+	* @throws Error if not connected
+	*/
+	get driver() {
+		if (!this.peer) throw new Error("Not connected - call connect() first");
+		return this.peer.driver;
+	}
+	/**
+	* Emit an event to the server (fire-and-forget)
+	*
+	* @param event - Event name from local schema
+	* @param data - Event data matching the schema
+	*/
+	emit(event, data) {
+		if (!this.peer) {
+			console.warn(`Cannot emit event '${String(event)}': not connected`);
+			return;
+		}
+		this.peer.emit(event, data);
+	}
+	/**
+	* Connect to the WebSocket server
+	*
+	* @returns Promise that resolves when connected
+	* @throws Error if connection fails
+	*/
+	async connect() {
+		if (this._state === "connected" || this._state === "connecting") return;
+		this.intentionalClose = false;
+		this._state = "connecting";
+		return new Promise((resolve, reject) => {
+			try {
+				let wsOptions;
+				if (this.headers) {
+					wsOptions = { headers: this.headers };
+					if (this.protocols) wsOptions.protocols = this.protocols;
+				} else wsOptions = this.protocols;
+				this.ws = new this.WebSocketImpl(this.url, wsOptions);
+			} catch (error) {
+				this._state = "disconnected";
+				reject(error);
+				return;
+			}
+			const onOpen = () => {
+				cleanup();
+				this.handleOpen();
+				resolve();
+			};
+			const onError = (event) => {
+				cleanup();
+				this._state = "disconnected";
+				reject(/* @__PURE__ */ new Error(`WebSocket connection failed: ${event}`));
+			};
+			const onClose = (event) => {
+				cleanup();
+				this._state = "disconnected";
+				const code = typeof event === "object" && event != null && "code" in event ? event.code : "Unknown code";
+				const reason = typeof event === "object" && event != null && "reason" in event ? event.reason : "Unknown reason";
+				reject(/* @__PURE__ */ new Error(`WebSocket closed: ${code} ${reason}`));
+			};
+			const cleanup = () => {
+				this.ws?.removeEventListener?.("open", onOpen);
+				this.ws?.removeEventListener?.("error", onError);
+				this.ws?.removeEventListener?.("close", onClose);
+			};
+			this.ws.addEventListener?.("open", onOpen);
+			this.ws.addEventListener?.("error", onError);
+			this.ws.addEventListener?.("close", onClose);
+		});
+	}
+	/**
+	* Disconnect from the server
+	*
+	* @param code - WebSocket close code (default: 1000)
+	* @param reason - Close reason message (default: "Client disconnect")
+	*/
+	disconnect(code = 1e3, reason = "Client disconnect") {
+		this.intentionalClose = true;
+		this.cancelReconnect();
+		if (this.peer) {
+			this.peer.close();
+			this.peer = null;
+		}
+		if (this.ws && this.ws.readyState !== WebSocketReadyState.CLOSED) this.ws.close(code, reason);
+		this.ws = null;
+		this._state = "disconnected";
+	}
+	/**
+	* Handle WebSocket open event
+	*/
+	handleOpen() {
+		if (!this.ws) return;
+		this._state = "connected";
+		this.reconnectAttempt = 0;
+		this.peer = new RpcPeer({
+			ws: this.ws,
+			localSchema: this.localSchema,
+			remoteSchema: this.remoteSchema,
+			provider: this.provider,
+			onEvent: this.hooks.onEvent,
+			timeout: this.defaultTimeout
+		});
+		this.ws.onmessage = (event) => {
+			if (typeof event === "object" && event != null && "data" in event) this.peer?.handleMessage(event.data);
+			else throw new Error(`Received invalid event type in RpcClient.ws.onmessage ${JSON.stringify(event)}`);
+		};
+		this.ws.onclose = (event) => {
+			if (typeof event === "object" && event != null && "code" in event && "reason" in event && typeof event.code === "number" && typeof event.reason === "string") this.handleClose(event.code, event.reason);
+			else throw new Error(`Received invalid event type in RpcClient.ws.onclose ${JSON.stringify(event)}`);
+		};
+		this.ws.onerror = (event) => {
+			console.error("WebSocket error:", event);
+		};
+		this.hooks.onConnect?.();
+	}
+	/**
+	* Handle WebSocket close event
+	*/
+	handleClose(code, reason) {
+		this.peer?.close();
+		this.peer = null;
+		this.ws = null;
+		this.hooks.onDisconnect?.(code, reason);
+		if (this.intentionalClose) {
+			this._state = "disconnected";
+			return;
+		}
+		if (this.reconnectOptions !== false) this.scheduleReconnect();
+		else this._state = "disconnected";
+	}
+	/**
+	* Schedule a reconnection attempt
+	*/
+	scheduleReconnect() {
+		if (this.reconnectOptions === false) return;
+		const { maxAttempts } = this.reconnectOptions;
+		if (maxAttempts > 0 && this.reconnectAttempt >= maxAttempts) {
+			this._state = "disconnected";
+			this.hooks.onReconnectFailed?.();
+			return;
+		}
+		this._state = "reconnecting";
+		const delay = calculateReconnectDelay(this.reconnectAttempt, this.reconnectOptions);
+		this.reconnectAttempt++;
+		this.hooks.onReconnect?.(this.reconnectAttempt, delay);
+		this.reconnectTimeout = setTimeout(() => {
+			this.reconnectTimeout = null;
+			this.attemptReconnect();
+		}, delay);
+	}
+	/**
+	* Attempt to reconnect
+	*/
+	async attemptReconnect() {
+		try {
+			await this.connect();
+		} catch {
+			if (!this.intentionalClose && this.reconnectOptions !== false) this.scheduleReconnect();
+		}
+	}
+	/**
+	* Cancel any pending reconnection
+	*/
+	cancelReconnect() {
+		if (this.reconnectTimeout) {
+			clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = null;
+		}
+	}
+};
+
+//#endregion
+export { RpcClient };

package/dist/adapters/cloudflare-do.d.ts

@@ -0,0 +1,72 @@
+import { m as RpcSchema, p as Provider } from "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+import "../protocol-DA84zrc2.js";
+import { a as IRpcOptions } from "../types-Be-qmQu0.js";
+import { t as RpcPeer } from "../default-xDNNMrg0.js";
+import { IMultiAdapterHooks, IMultiConnectionAdapter } from "./types.js";
+import { Constructor } from "type-fest";
+import { Actor } from "@cloudflare/actors";
+
+//#region src/adapters/cloudflare-do.d.ts
+
+/**
+ * Extended hooks for Durable Object adapter
+ */
+interface IDOHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IMultiAdapterHooks<TLocalSchema, TRemoteSchema> {
+  /** Called when a peer is recreated after hibernation */
+  onPeerRecreated?(peer: RpcPeer<TLocalSchema, TRemoteSchema>, ws: WebSocket): void;
+}
+/**
+ * Constructor type for the RPC mixin result.
+ *
+ * Subclasses must implement methods from TLocalSchema on `this`.
+ * Runtime enforces this when methods are called via RPC.
+ */
+type RpcActorConstructor<TBase extends Constructor<Actor<unknown>>, TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> = {
+  new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & IMultiConnectionAdapter<TLocalSchema, TRemoteSchema>;
+} & Omit<TBase, "new">;
+/**
+ * Create a mixin that adds RPC capabilities to a Durable Object Actor.
+ *
+ * The resulting class requires implementation of all methods defined in
+ * `localSchema`. TypeScript enforces this at compile time.
+ *
+ * @param Base - The Actor class to extend
+ * @param options - RPC configuration including local/remote schemas and timeout
+ * @returns A new class with RPC capabilities mixed in
+ *
+ * @example
+ * ```ts
+ * const ServerSchema = {
+ *   methods: {
+ *     getData: method({
+ *       input: z.object({}),
+ *       output: z.object({ data: z.array(z.string()) }),
+ *     }),
+ *   },
+ *   events: {},
+ * } as const;
+ *
+ * class MyDO extends withRpc(Actor, {
+ *   localSchema: ServerSchema,
+ *   remoteSchema: ClientSchema,
+ * }) {
+ *   // Required: implement methods from ServerSchema
+ *   async getData() {
+ *     return { data: this.dataList };
+ *   }
+ *
+ *   // Call methods on connected clients
+ *   async notifyClients() {
+ *     const results = await this.driver.clientMethod({ info: "update" });
+ *   }
+ * }
+ * ```
+ */
+declare function withRpc<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema, TEnv, TBase extends Constructor<Actor<TEnv>> & {
+  prototype: Provider<TLocalSchema>;
+}>(Base: TBase, options: IRpcOptions<TLocalSchema, TRemoteSchema>): RpcActorConstructor<TBase, TLocalSchema, TRemoteSchema>;
+//#endregion
+export { IDOHooks, RpcActorConstructor, withRpc };

package/dist/adapters/cloudflare-do.js

@@ -0,0 +1,192 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import "../protocol-_mpoOPp6.js";
+import "../errors-5BfreE63.js";
+import { t as SqlPendingCallStorage } from "../sql-CCjc6Bid.js";
+import "../default-BkrMd28n.js";
+import { n as createDurableRpcPeerFactory } from "../durable-MZjkvyS6.js";
+import { t as MultiPeerBase } from "../multi-peer-BAi9yVzp.js";
+
+//#region src/adapters/cloudflare-do.ts
+/**
+* Concrete MultiPeerBase for Durable Objects using native WebSocket
+*/
+var DOMultiPeer = class extends MultiPeerBase {
+	hooks;
+	_createPeer;
+	constructor(options) {
+		super(options);
+		this.hooks = options.hooks ?? {};
+		this._createPeer = createDurableRpcPeerFactory({
+			actor: options.actor,
+			storage: options.storage,
+			...options.durableTimeout != null && { durableTimeout: options.durableTimeout }
+		});
+	}
+	/**
+	* Create an RPC peer for a WebSocket connection.
+	* Override to use the actor instance as provider via closure.
+	*/
+	createPeerWithProvider(ws, provider) {
+		const peer = this._createPeer({
+			ws,
+			localSchema: this.localSchema,
+			remoteSchema: this.remoteSchema,
+			provider,
+			onEvent: (event, data) => {
+				this.hooks.onEvent?.(peer, event, data);
+			},
+			timeout: this.timeout
+		});
+		return peer;
+	}
+	/**
+	* Get or create RPC peer for a WebSocket
+	* Handles lazy recreation after hibernation.
+	*/
+	getOrCreatePeer(ws, provider, isHibernationRecovery = false) {
+		let peer = this.getPeerFor(ws);
+		if (!peer) {
+			peer = this.createPeerWithProvider(ws, provider);
+			this.addPeer(ws, peer);
+			if (isHibernationRecovery) this.hooks.onPeerRecreated?.(peer, ws);
+		}
+		return peer;
+	}
+	/**
+	* Connect a new WebSocket and create its peer
+	*/
+	connectPeer(ws, provider) {
+		const peer = this.createPeerWithProvider(ws, provider);
+		this.addPeer(ws, peer);
+		return peer;
+	}
+	/**
+	* Disconnect a WebSocket and remove its peer
+	*/
+	disconnectPeer(ws) {
+		this.removePeer(ws);
+	}
+	/**
+	* Handle an error on a WebSocket
+	*/
+	handleError(ws, error) {
+		const peer = this.getPeerFor(ws);
+		if (peer) {
+			peer.close();
+			this.removePeer(ws);
+		}
+		this.hooks.onError?.(peer ?? null, error);
+	}
+};
+/**
+* Create a mixin that adds RPC capabilities to a Durable Object Actor.
+*
+* The resulting class requires implementation of all methods defined in
+* `localSchema`. TypeScript enforces this at compile time.
+*
+* @param Base - The Actor class to extend
+* @param options - RPC configuration including local/remote schemas and timeout
+* @returns A new class with RPC capabilities mixed in
+*
+* @example
+* ```ts
+* const ServerSchema = {
+*   methods: {
+*     getData: method({
+*       input: z.object({}),
+*       output: z.object({ data: z.array(z.string()) }),
+*     }),
+*   },
+*   events: {},
+* } as const;
+*
+* class MyDO extends withRpc(Actor, {
+*   localSchema: ServerSchema,
+*   remoteSchema: ClientSchema,
+* }) {
+*   // Required: implement methods from ServerSchema
+*   async getData() {
+*     return { data: this.dataList };
+*   }
+*
+*   // Call methods on connected clients
+*   async notifyClients() {
+*     const results = await this.driver.clientMethod({ info: "update" });
+*   }
+* }
+* ```
+*/
+function withRpc(Base, options) {
+	return class RpcActor extends Base {
+		__rpc = null;
+		/**
+		* Internal RPC manager (lazily initialized)
+		*
+		* Handles peer management, message routing, and durable storage.
+		* Uses SQL storage from the Durable Object for hibernation-safe calls.
+		*
+		* @throws Error if DurableObjectStorage is not available
+		*/
+		get _rpc() {
+			if (!this.storage.raw) throw new Error("DurableObjectStorage not present in actor `raw`");
+			return this.__rpc ??= new DOMultiPeer({
+				actor: this,
+				storage: new SqlPendingCallStorage(this.storage.raw.sql),
+				localSchema: options.localSchema,
+				remoteSchema: options.remoteSchema,
+				provider: this,
+				...options.timeout !== void 0 && { timeout: options.timeout }
+			});
+		}
+		/**
+		* Driver for calling methods on connected clients
+		*/
+		get driver() {
+			return this._rpc.driver;
+		}
+		/**
+		* Emit an event to connected clients
+		*
+		* @param event - Event name from local schema
+		* @param data - Event data matching the schema
+		* @param ids - Optional array of peer IDs to emit to (broadcasts to all if omitted)
+		*/
+		emit(event, data, ids) {
+			this._rpc.emit(event, data, ids);
+		}
+		/**
+		* Get the number of connected peers
+		*/
+		getConnectionCount() {
+			return this._rpc.getConnectionCount();
+		}
+		/**
+		* Get the IDs of all connected peers
+		*/
+		getConnectionIds() {
+			return this._rpc.getConnectionIds();
+		}
+		/** Called by Actor when WebSocket connects */
+		onWebSocketConnect(ws, _request) {
+			this._rpc.connectPeer(ws, this);
+		}
+		/** Called by Actor when WebSocket message received (handles hibernation recovery) */
+		onWebSocketMessage(ws, message) {
+			const existingPeer = this._rpc.getPeerFor(ws);
+			this._rpc.getOrCreatePeer(ws, this, !existingPeer).handleMessage(message);
+		}
+		/** Called by Actor when WebSocket disconnects */
+		onWebSocketDisconnect(ws) {
+			this._rpc.disconnectPeer(ws);
+		}
+		/** Called by Actor when WebSocket error occurs */
+		onWebSocketError(ws, error) {
+			this._rpc.handleError(ws, error);
+		}
+	};
+}
+
+//#endregion
+export { withRpc };

package/dist/adapters/index.d.ts

@@ -0,0 +1,13 @@
+import "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+import "../protocol-DA84zrc2.js";
+import "../types-Be-qmQu0.js";
+import "../default-xDNNMrg0.js";
+import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
+import { IAdapterHooks, IConnectionAdapter, IMultiAdapterHooks, IMultiConnectionAdapter, MultiCallOptions, MultiCallResult, MultiDriver } from "./types.js";
+import { ConnectionState, RpcClient, RpcClientOptions } from "./client.js";
+import { RpcActorConstructor, withRpc } from "./cloudflare-do.js";
+import { n as RpcServerOptions, r as MultiPeerBase, t as RpcServer } from "../server-zTjpJpoX.js";
+export { type ConnectionState, IAdapterHooks, IConnectionAdapter, IMultiAdapterHooks, IMultiConnectionAdapter, MultiCallOptions, MultiCallResult, MultiDriver, MultiPeerBase, ReconnectOptions, type RpcActorConstructor, RpcClient, type RpcClientOptions, RpcServer, type RpcServerOptions, calculateReconnectDelay, defaultReconnectOptions, withRpc };

package/dist/adapters/index.js

@@ -0,0 +1,16 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import "../protocol-_mpoOPp6.js";
+import "../errors-5BfreE63.js";
+import "../sql-CCjc6Bid.js";
+import { n as defaultReconnectOptions, t as calculateReconnectDelay } from "../reconnect-CGAA_1Gf.js";
+import "../default-BkrMd28n.js";
+import "../durable-MZjkvyS6.js";
+import "./types.js";
+import { RpcClient } from "./client.js";
+import { t as MultiPeerBase } from "../multi-peer-BAi9yVzp.js";
+import { withRpc } from "./cloudflare-do.js";
+import { RpcServer } from "./server.js";
+
+export { MultiPeerBase, RpcClient, RpcServer, calculateReconnectDelay, defaultReconnectOptions, withRpc };

package/dist/adapters/server.d.ts

@@ -0,0 +1,10 @@
+import "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+import "../protocol-DA84zrc2.js";
+import "../types-Be-qmQu0.js";
+import "../default-xDNNMrg0.js";
+import "./types.js";
+import { n as RpcServerOptions, t as RpcServer } from "../server-zTjpJpoX.js";
+export { RpcServer, RpcServerOptions };

package/dist/adapters/server.js

@@ -0,0 +1,122 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import "../protocol-_mpoOPp6.js";
+import "../errors-5BfreE63.js";
+import { t as WebSocketReadyState } from "../types-D_psiH09.js";
+import { t as RpcPeer } from "../default-BkrMd28n.js";
+import { t as MultiPeerBase } from "../multi-peer-BAi9yVzp.js";
+
+//#region src/adapters/server.ts
+/**
+* RPC Server Adapter
+*
+* Manages RpcPeer instances for incoming WebSocket connections.
+* Works with Node.js `ws`, Bun's native WebSocket, or any compatible server.
+*/
+/**
+* RPC Server
+*
+* Manages WebSocket server and client connections with RPC capabilities.
+*
+* @example
+* ```typescript
+* import { WebSocketServer } from "ws";
+* import { RpcServer } from "@igoforth/ws-rpc/adapters/server";
+*
+* const server = new RpcServer({
+*   wss: { port: 8080 },
+*   WebSocketServer,
+*   localSchema: ServerSchema,
+*   remoteSchema: ClientSchema,
+*   provider: {
+*     getUser: async ({ id }) => ({ name: "John", email: "john@example.com" }),
+*   },
+*   hooks: {
+*     onConnect: (peer) => {
+*       console.log(`Client ${peer.id} connected`);
+*       peer.driver.ping({}).then(console.log);
+*     },
+*     onDisconnect: (peer) => console.log(`Client ${peer.id} disconnected`),
+*   },
+* });
+*
+* // Emit to all clients
+* server.emit("orderUpdated", { orderId: "123", status: "shipped" });
+*
+* // Graceful shutdown
+* process.on("SIGTERM", () => server.close());
+* ```
+*/
+var RpcServer = class extends MultiPeerBase {
+	wss;
+	constructor(options) {
+		super({
+			localSchema: options.localSchema,
+			remoteSchema: options.remoteSchema,
+			provider: options.provider,
+			...options.timeout !== void 0 && { timeout: options.timeout },
+			...options.hooks !== void 0 && { hooks: options.hooks }
+		});
+		if ("on" in options.wss && typeof options.wss.on === "function") this.wss = options.wss;
+		else {
+			if (!options.WebSocketServer) throw new Error("WebSocketServer constructor required when passing options");
+			this.wss = new options.WebSocketServer(options.wss);
+		}
+		this.wss.on("connection", (ws) => this.handleConnection(ws));
+		this.wss.on("error", (error) => this.hooks.onError?.(null, error));
+		this.wss.on("close", () => this.hooks.onClose?.());
+	}
+	handleConnection(ws) {
+		const peer = new RpcPeer({
+			ws,
+			localSchema: this.localSchema,
+			remoteSchema: this.remoteSchema,
+			provider: this.provider,
+			timeout: this.timeout,
+			onEvent: (event, data) => {
+				this.hooks.onEvent?.(peer, event, data);
+			}
+		});
+		this.addPeer(ws, peer);
+		ws.onmessage = (event) => {
+			if (typeof event === "object" && event != null && "data" in event && (typeof event.data === "string" || event.data instanceof ArrayBuffer)) peer.handleMessage(event.data);
+		};
+		ws.onclose = () => {
+			this.removePeer(ws);
+		};
+		ws.onerror = (event) => {
+			const error = event instanceof Error ? event : /* @__PURE__ */ new Error(`WebSocket error for peer ${peer.id}`);
+			this.hooks.onError?.(peer, error);
+		};
+	}
+	/**
+	* Close a peer connection with WebSocket close code/reason
+	*
+	* @param id - Peer ID to close
+	* @param code - WebSocket close code (default: 1000)
+	* @param reason - Close reason message (default: "Server disconnect")
+	* @returns true if peer was found and closed, false otherwise
+	*/
+	closePeer(id, code = 1e3, reason = "Server disconnect") {
+		const entry = this.findPeerEntry(id);
+		if (entry) {
+			if (entry.connection.readyState !== WebSocketReadyState.CLOSED) entry.connection.close(code, reason);
+			return super.closePeer(id);
+		}
+		return false;
+	}
+	/**
+	* Close the server and all client connections
+	*
+	* @param callback - Optional callback invoked when server is closed
+	*/
+	close(callback) {
+		for (const entry of this.getOpenEntries()) if (entry.connection.readyState !== WebSocketReadyState.CLOSED) entry.connection.close(1001, "Server shutdown");
+		this.closeAll();
+		this.wss.close(callback);
+	}
+};
+
+//#endregion
+export { RpcServer };