@igoforth/ws-rpc 1.0.2 → 1.1.0

package/README.md

@@ -185,6 +185,7 @@ process.on("SIGTERM", () => server.close());
 ```typescript
 import { Actor } from "@cloudflare/actors";
 import { withRpc } from "@igoforth/ws-rpc/adapters/cloudflare-do";
+import { RpcPeer } from "@igoforth/ws-rpc/peers";
 import { ServerSchema, ClientSchema } from "./schemas";
 
 // First, create an Actor with the RPC method implementations
@@ -222,138 +223,32 @@ export class GameRoom extends withRpc(GameRoomActor, {
   getPlayerCount() {
     return this.getConnectionCount();
   }
-}
-```
-
-## API Reference
-
-### Schema Definition
-
-```typescript
-import { method, event } from "@igoforth/ws-rpc/schema";
-import { z } from "zod";
-
-// Define a method with input/output validation
-const myMethod = method({
-  input: z.object({ /* ... */ }),
-  output: z.object({ /* ... */ }),
-});
 
-// Define an event (fire-and-forget)
-const myEvent = event({
-  data: z.object({ /* ... */ }),
-});
-
-// Combine into a schema
-const MySchema = {
-  methods: { myMethod },
-  events: { myEvent },
-} satisfies RpcSchema;
-```
-
-### Type Inference
-
-```typescript
-import type { Provider, Driver, InferInput, InferOutput } from "@igoforth/ws-rpc/schema";
-
-// Get the provider type (what you implement)
-type MyProvider = Provider<typeof MySchema>;
-
-// Get the driver type (what you call)
-type MyDriver = Driver<typeof MySchema>;
-
-// Get input/output types for a specific method
-type MyMethodInput = InferInput<typeof MySchema["methods"]["myMethod"]>;
-type MyMethodOutput = InferOutput<typeof MySchema["methods"]["myMethod"]>;
-```
-
-### Codecs
-
-```typescript
-import { createMsgpackCodec } from "@igoforth/ws-rpc/codecs/msgpack";
-import { createCborCodec } from "@igoforth/ws-rpc/codecs/cbor";
-import { createJsonCodec } from "@igoforth/ws-rpc/codecs/json";
-
-// JSON (default)
-const jsonCodec = createJsonCodec(z.unknown());
-
-// MessagePack (requires @msgpack/msgpack)
-const msgpackCodec = createMsgpackCodec(z.unknown());
+  // Override RPC lifecycle hooks
+  protected override onRpcConnect(peer: RpcPeer<typeof ServerSchema, typeof ClientSchema>) {
+    console.log(`Player ${peer.id} joined`);
+  }
 
-// CBOR (requires cbor-x)
-const cborCodec = createCborCodec(z.unknown());
-```
+  protected override onRpcDisconnect(peer: RpcPeer<typeof ServerSchema, typeof ClientSchema>) {
+    console.log(`Player ${peer.id} left`);
+  }
 
-### Error Handling
+  protected override onRpcError(
+    peer: RpcPeer<typeof ServerSchema, typeof ClientSchema> | null,
+    error: Error,
+  ) {
+    console.error(`Error from ${peer?.id}:`, error);
+  }
 
-```typescript
-import {
-  RpcError,
-  RpcTimeoutError,
-  RpcRemoteError,
-  RpcConnectionClosed,
-  RpcValidationError,
-  RpcMethodNotFoundError,
-} from "@igoforth/ws-rpc/errors";
-
-try {
-  await client.driver.someMethod({ /* ... */ });
-} catch (error) {
-  if (error instanceof RpcTimeoutError) {
-    console.log(`Request '${error.method}' timed out after ${error.timeoutMs}ms`);
-  } else if (error instanceof RpcValidationError) {
-    console.log("Invalid input/output:", error.message);
-  } else if (error instanceof RpcRemoteError) {
-    console.log("Server error:", error.message, error.code);
-  } else if (error instanceof RpcMethodNotFoundError) {
-    console.log(`Method '${error.method}' not found`);
-  } else if (error instanceof RpcConnectionClosed) {
-    console.log("Connection closed");
+  protected override onRpcPeerRecreated(
+    peer: RpcPeer<typeof ServerSchema, typeof ClientSchema>,
+    ws: WebSocket,
+  ) {
+    console.log(`Player ${peer.id} recovered from hibernation`);
   }
 }
 ```
 
-### Client Options
-
-```typescript
-const client = new RpcClient({
-  url: "wss://...",
-  localSchema: MyLocalSchema,
-  remoteSchema: MyRemoteSchema,
-  provider: { /* method implementations */ },
-
-  // Reconnection options (set to false to disable)
-  reconnect: {
-    initialDelay: 1000,    // First retry delay (ms)
-    maxDelay: 30000,       // Maximum retry delay (ms)
-    backoffMultiplier: 2,  // Exponential backoff multiplier
-    maxAttempts: 0,        // Max attempts (0 = unlimited)
-    jitter: 0.1,           // Random jitter factor (0-1)
-  },
-
-  // Request timeout (ms)
-  timeout: 30000,
-
-  // Auto-connect on creation (default: false)
-  autoConnect: true,
-
-  // WebSocket options
-  protocols: ["v1"],                    // Subprotocols
-  headers: { Authorization: "Bearer ..." }, // Headers (Node.js/Bun only)
-
-  // Event handlers
-  onConnect: () => console.log("Connected"),
-  onDisconnect: (code, reason) => console.log("Disconnected"),
-  onReconnect: (attempt, delay) => console.log(`Reconnecting in ${delay}ms`),
-  onReconnectFailed: () => console.log("Reconnection failed"),
-  onEvent: (event, data) => console.log("Event:", event, data),
-});
-
-// Connection state
-client.state;       // "disconnected" | "connecting" | "connected" | "reconnecting"
-client.isConnected; // boolean
-```
-
 ## Hibernation-Safe Durable Objects
 
 For Cloudflare Durable Objects that need hibernation-safe outgoing calls, use `DurableRpcPeer` with continuation-passing style:
@@ -410,9 +305,9 @@ Real WebSocket RPC round-trip benchmarks (GitHub Actions runner, Node.js 22):
 **Throughput (ops/sec):**
 | Payload | JSON | MessagePack | CBOR | Fastest |
 |---------|------|-------------|------|---------|
-| Small | 0 | 0 | 0 | JSON |
-| Medium | 0 | 0 | 0 | JSON |
-| Large | 0 | 0 | 0 | JSON |
+| Small | 1443 | 1798 | 1812 | CBOR |
+| Medium | 1514 | 1591 | 5142 | CBOR |
+| Large | 1656 | 1270 | 1999 | CBOR |
 
 > Benchmarks run automatically via GitHub Actions. Results may vary based on runner load.
 > Run locally with `pnpm bench` for your environment.

package/dist/adapters/client.d.ts

@@ -2,9 +2,9 @@ import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p
 import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import { a as IRpcOptions, c as WebSocketOptions, o as IWebSocket } from "../types-BVaXox7F.js";
-import "../default-C5z3UDd1.js";
+import { u as RpcProtocol } from "../protocol-ipDMUaRc.js";
+import { a as IRpcOptions, c as WebSocketOptions, o as IWebSocket } from "../types-BGM8eZe5.js";
+import "../default-DOftsqyK.js";
 import { t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
 import { IAdapterHooks, IConnectionAdapter } from "./types.js";
 
@@ -41,14 +41,12 @@ type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecti
 declare class RpcClient<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> implements IConnectionAdapter<TLocalSchema, TRemoteSchema> {
   readonly localSchema: TLocalSchema;
   readonly remoteSchema: TRemoteSchema;
+  readonly timeout: number;
+  readonly protocol?: RpcProtocol;
   readonly provider: Provider<TLocalSchema>;
   readonly hooks: IAdapterHooks<TRemoteSchema>;
-  private readonly url;
   private readonly reconnectOptions;
-  private readonly defaultTimeout;
-  private readonly protocols;
-  private readonly headers;
-  private readonly WebSocketImpl;
+  private readonly createWebSocket;
   private ws;
   private peer;
   private _state;

package/dist/adapters/client.js

@@ -5,7 +5,7 @@ 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 { t as RpcPeer } from "../default-B6CVJfTD.js";
 import "./types.js";
 
 //#region src/adapters/client.ts
@@ -17,14 +17,12 @@ import "./types.js";
 var RpcClient = class {
 	localSchema;
 	remoteSchema;
+	timeout;
+	protocol;
 	provider;
 	hooks = {};
-	url;
 	reconnectOptions;
-	defaultTimeout;
-	protocols;
-	headers;
-	WebSocketImpl;
+	createWebSocket;
 	ws = null;
 	peer = null;
 	_state = "disconnected";
@@ -32,18 +30,25 @@ var RpcClient = class {
 	reconnectTimeout = null;
 	intentionalClose = false;
 	constructor(options) {
-		this.url = options.url;
 		this.localSchema = options.localSchema;
 		this.remoteSchema = options.remoteSchema;
+		this.timeout = options.timeout ?? 3e4;
+		if (options.protocol) this.protocol = options.protocol;
 		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;
+		const url = options.url;
+		const protocols = options.protocols;
+		const headers = options.headers;
+		const WebSocketImpl = options.WebSocket ?? globalThis.WebSocket;
+		this.createWebSocket = () => {
+			return new WebSocketImpl(url, headers ? {
+				headers,
+				...protocols && { protocols }
+			} : protocols);
+		};
 		if (options.onConnect) this.hooks.onConnect = options.onConnect;
 		if (options.onDisconnect) this.hooks.onDisconnect = options.onDisconnect;
 		if (options.onReconnect) this.hooks.onReconnect = options.onReconnect;
@@ -98,12 +103,7 @@ var RpcClient = class {
 		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);
+				this.ws = this.createWebSocket();
 			} catch (error) {
 				this._state = "disconnected";
 				reject(error);
@@ -165,8 +165,9 @@ var RpcClient = class {
 			localSchema: this.localSchema,
 			remoteSchema: this.remoteSchema,
 			provider: this.provider,
+			...this.protocol !== void 0 && { protocol: this.protocol },
 			onEvent: this.hooks.onEvent,
-			timeout: this.defaultTimeout
+			timeout: this.timeout
 		});
 		this.ws.onmessage = (event) => {
 			if (typeof event === "object" && event != null && "data" in event) this.peer?.handleMessage(event.data);

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

@@ -1,10 +1,10 @@
-import { m as RpcSchema, p as Provider } from "../schema-BPJJ9slm.js";
+import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider } from "../schema-BPJJ9slm.js";
 import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import "../protocol-ipDMUaRc.js";
-import { a as IRpcOptions } from "../types-BVaXox7F.js";
-import { t as RpcPeer } from "../default-C5z3UDd1.js";
+import { a as IRpcOptions } from "../types-BGM8eZe5.js";
+import { t as RpcPeer } from "../default-DOftsqyK.js";
 import { IMultiAdapterHooks, IMultiConnectionAdapter } from "./types.js";
 import { Constructor } from "type-fest";
 import { Actor } from "@cloudflare/actors";
@@ -18,6 +18,22 @@ interface IDOHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSche
   /** Called when a peer is recreated after hibernation */
   onPeerRecreated?(peer: RpcPeer<TLocalSchema, TRemoteSchema>, ws: WebSocket): void;
 }
+/**
+ * Interface for overridable RPC hooks exposed by the mixin.
+ * Subclasses can override these to handle RPC lifecycle events.
+ */
+interface IRpcActorHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
+  /** Called when a peer connects. Override to handle connection events. */
+  onRpcConnect(peer: RpcPeer<TLocalSchema, TRemoteSchema>): void;
+  /** Called when a peer disconnects. Override to handle disconnection events. */
+  onRpcDisconnect(peer: RpcPeer<TLocalSchema, TRemoteSchema>): void;
+  /** Called when an event is received from a peer. Override to handle events. */
+  onRpcEvent<K extends StringKeys<TRemoteSchema["events"]>>(peer: RpcPeer<TLocalSchema, TRemoteSchema>, event: K, data: TRemoteSchema["events"] extends Record<string, EventDef> ? InferEventData<TRemoteSchema["events"][K]> : never): void;
+  /** Called when a peer encounters an error. Override to handle errors. */
+  onRpcError(peer: RpcPeer<TLocalSchema, TRemoteSchema> | null, error: Error): void;
+  /** Called when a peer is recreated after hibernation. Override to handle recovery. */
+  onRpcPeerRecreated(peer: RpcPeer<TLocalSchema, TRemoteSchema>, ws: WebSocket): void;
+}
 /**
  * Constructor type for the RPC mixin result.
  *
@@ -25,7 +41,7 @@ interface IDOHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSche
  * 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>;
+  new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & IMultiConnectionAdapter<TLocalSchema, TRemoteSchema> & IRpcActorHooks<TLocalSchema, TRemoteSchema>;
 } & Omit<TBase, "new">;
 /**
  * Create a mixin that adds RPC capabilities to a Durable Object Actor.
@@ -74,4 +90,4 @@ declare function withRpc<TLocalSchema extends RpcSchema, TRemoteSchema extends R
   prototype: Provider<TLocalSchema>;
 }>(Base: TBase, options: IRpcOptions<TLocalSchema, TRemoteSchema>): RpcActorConstructor<TBase, TLocalSchema, TRemoteSchema>;
 //#endregion
-export { IDOHooks, RpcActorConstructor, withRpc };
+export { IDOHooks, IRpcActorHooks, RpcActorConstructor, withRpc };

package/dist/adapters/cloudflare-do.js

@@ -4,9 +4,9 @@ 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";
+import "../default-B6CVJfTD.js";
+import { n as createDurableRpcPeerFactory } from "../durable-DENcbnTp.js";
+import { t as MultiPeerBase } from "../multi-peer-DFUqFBsx.js";
 
 //#region src/adapters/cloudflare-do.ts
 /**
@@ -34,6 +34,7 @@ var DOMultiPeer = class extends MultiPeerBase {
 			localSchema: this.localSchema,
 			remoteSchema: this.remoteSchema,
 			provider,
+			...this.protocol !== void 0 && { protocol: this.protocol },
 			onEvent: (event, data) => {
 				this.hooks.onEvent?.(peer, event, data);
 			},
@@ -142,9 +143,27 @@ function withRpc(Base, options) {
 				localSchema: options.localSchema,
 				remoteSchema: options.remoteSchema,
 				provider: this,
-				...options.timeout !== void 0 && { timeout: options.timeout }
+				...options.timeout !== void 0 && { timeout: options.timeout },
+				...options.protocol !== void 0 && { protocol: options.protocol },
+				hooks: {
+					onConnect: (peer) => this.onRpcConnect(peer),
+					onDisconnect: (peer) => this.onRpcDisconnect(peer),
+					onEvent: (peer, event, data) => this.onRpcEvent(peer, event, data),
+					onError: (peer, error) => this.onRpcError(peer, error),
+					onPeerRecreated: (peer, ws) => this.onRpcPeerRecreated(peer, ws)
+				}
 			});
 		}
+		/** Called when a peer connects. Override to handle connection events. */
+		onRpcConnect(_peer) {}
+		/** Called when a peer disconnects. Override to handle disconnection events. */
+		onRpcDisconnect(_peer) {}
+		/** Called when an event is received from a peer. Override to handle events. */
+		onRpcEvent(_peer, _event, _data) {}
+		/** Called when a peer encounters an error. Override to handle errors. */
+		onRpcError(_peer, _error) {}
+		/** Called when a peer is recreated after hibernation. Override to handle recovery. */
+		onRpcPeerRecreated(_peer, _ws) {}
 		/**
 		* Driver for calling methods on connected clients
 		*/

package/dist/adapters/index.d.ts

@@ -3,11 +3,11 @@ import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import "../default-C5z3UDd1.js";
+import "../types-BGM8eZe5.js";
+import "../default-DOftsqyK.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-C5EvcG9T.js";
-export { type ConnectionState, IAdapterHooks, IConnectionAdapter, IMultiAdapterHooks, IMultiConnectionAdapter, MultiCallOptions, MultiCallResult, MultiDriver, MultiPeerBase, ReconnectOptions, type RpcActorConstructor, RpcClient, type RpcClientOptions, RpcServer, type RpcServerOptions, calculateReconnectDelay, defaultReconnectOptions, withRpc };
+import { IDOHooks, IRpcActorHooks, RpcActorConstructor, withRpc } from "./cloudflare-do.js";
+import { n as RpcServerOptions, r as MultiPeerBase, t as RpcServer } from "../server-BJm2ViQB.js";
+export { type ConnectionState, IAdapterHooks, IConnectionAdapter, type IDOHooks, IMultiAdapterHooks, IMultiConnectionAdapter, type IRpcActorHooks, MultiCallOptions, MultiCallResult, MultiDriver, MultiPeerBase, ReconnectOptions, type RpcActorConstructor, RpcClient, type RpcClientOptions, RpcServer, type RpcServerOptions, calculateReconnectDelay, defaultReconnectOptions, withRpc };

package/dist/adapters/index.js

@@ -5,11 +5,11 @@ 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 "../default-B6CVJfTD.js";
+import "../durable-DENcbnTp.js";
 import "./types.js";
 import { RpcClient } from "./client.js";
-import { t as MultiPeerBase } from "../multi-peer-BAi9yVzp.js";
+import { t as MultiPeerBase } from "../multi-peer-DFUqFBsx.js";
 import { withRpc } from "./cloudflare-do.js";
 import { RpcServer } from "./server.js";
 

package/dist/adapters/server.d.ts

@@ -3,8 +3,8 @@ import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import "../default-C5z3UDd1.js";
+import "../types-BGM8eZe5.js";
+import "../default-DOftsqyK.js";
 import "./types.js";
-import { n as RpcServerOptions, t as RpcServer } from "../server-C5EvcG9T.js";
+import { n as RpcServerOptions, t as RpcServer } from "../server-BJm2ViQB.js";
 export { RpcServer, RpcServerOptions };

package/dist/adapters/server.js

@@ -4,8 +4,8 @@ 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";
+import { t as RpcPeer } from "../default-B6CVJfTD.js";
+import { t as MultiPeerBase } from "../multi-peer-DFUqFBsx.js";
 
 //#region src/adapters/server.ts
 /**
@@ -15,6 +15,14 @@ import { t as MultiPeerBase } from "../multi-peer-BAi9yVzp.js";
 * Works with Node.js `ws`, Bun's native WebSocket, or any compatible server.
 */
 /**
+* Create or return existing WebSocket server
+*/
+function createWebSocketServer(wss, WebSocketServer) {
+	if ("on" in wss && typeof wss.on === "function") return wss;
+	if (!WebSocketServer) throw new Error("WebSocketServer constructor required when passing options");
+	return new WebSocketServer(wss);
+}
+/**
 * RPC Server
 *
 * Manages WebSocket server and client connections with RPC capabilities.
@@ -56,13 +64,10 @@ var RpcServer = class extends MultiPeerBase {
 			remoteSchema: options.remoteSchema,
 			provider: options.provider,
 			...options.timeout !== void 0 && { timeout: options.timeout },
+			...options.protocol !== void 0 && { protocol: options.protocol },
 			...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 = createWebSocketServer(options.wss, options.WebSocketServer);
 		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?.());
@@ -73,6 +78,7 @@ var RpcServer = class extends MultiPeerBase {
 			localSchema: this.localSchema,
 			remoteSchema: this.remoteSchema,
 			provider: this.provider,
+			...this.protocol !== void 0 && { protocol: this.protocol },
 			timeout: this.timeout,
 			onEvent: (event, data) => {
 				this.hooks.onEvent?.(peer, event, data);

package/dist/adapters/types.d.ts

@@ -3,8 +3,8 @@ import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import "../protocol-ipDMUaRc.js";
-import { a as IRpcOptions, n as IMethodController, t as IEventController } from "../types-BVaXox7F.js";
-import { t as RpcPeer } from "../default-C5z3UDd1.js";
+import { a as IRpcOptions, n as IMethodController, t as IEventController } from "../types-BGM8eZe5.js";
+import { t as RpcPeer } from "../default-DOftsqyK.js";
 import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
 
 //#region src/adapters/types.d.ts

package/dist/{default-BkrMd28n.js → default-B6CVJfTD.js}

@@ -143,7 +143,7 @@ var RpcPeer = class {
 			this.sendError(id, RpcErrorCodes.METHOD_NOT_FOUND, `Method '${method}' not found`);
 			return;
 		}
-		const parseResult = methodDef.input.safeParse(params);
+		const parseResult = await methodDef.input.safeParseAsync(params);
 		if (!parseResult.success) {
 			this.sendError(id, RpcErrorCodes.INVALID_PARAMS, `Invalid params for '${method}'`, parseResult.error);
 			return;
@@ -155,7 +155,7 @@ var RpcPeer = class {
 		}
 		try {
 			const result = await handler.call(this.provider, parseResult.data);
-			const outputResult = methodDef.output.safeParse(result);
+			const outputResult = await methodDef.output.safeParseAsync(result);
 			if (!outputResult.success) {
 				this.sendError(id, RpcErrorCodes.INTERNAL_ERROR, `Invalid output from '${method}'`, outputResult.error);
 				return;

package/dist/{default-C5z3UDd1.d.ts → default-DOftsqyK.d.ts}

@@ -1,6 +1,6 @@
 import { a as InferEventData, h as StringKeys, i as EventHandler, m as RpcSchema, n as EventDef, p as Provider, t as Driver } from "./schema-BPJJ9slm.js";
 import { g as WireInput, u as RpcProtocol } from "./protocol-ipDMUaRc.js";
-import { a as IRpcOptions, r as IMinWebSocket } from "./types-BVaXox7F.js";
+import { a as IRpcOptions, r as IMinWebSocket } from "./types-BGM8eZe5.js";
 
 //#region src/peers/default.d.ts
 
@@ -14,23 +14,6 @@ interface RpcPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends R
   ws: IMinWebSocket;
   /** Implementation of local methods */
   provider: Partial<Provider<TLocalSchema>>;
-  /**
-   * Protocol for encoding/decoding messages
-   *
-   * Defaults to JSON. Use createProtocol() with a binary codec for better performance.
-   *
-   * @example
-   * ```ts
-   * import { createProtocol, RpcMessageSchema } from "@igoforth/ws-rpc/protocol";
-   * import { createMsgpackCodec } from "@igoforth/ws-rpc/codecs/msgpack";
-   *
-   * const peer = new RpcPeer({
-   *   protocol: createProtocol(createMsgpackCodec(RpcMessageSchema)),
-   *   // ...
-   * });
-   * ```
-   */
-  protocol?: RpcProtocol | undefined;
   /** Handler for incoming events */
   onEvent?: EventHandler<TRemoteSchema> | undefined;
   /** Generate unique request IDs */

package/dist/{durable-MZjkvyS6.js → durable-DENcbnTp.js}

@@ -1,4 +1,4 @@
-import { t as RpcPeer } from "./default-BkrMd28n.js";
+import { t as RpcPeer } from "./default-B6CVJfTD.js";
 
 //#region src/peers/durable.ts
 /**

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import "./factory-BGezZgAP.js";
 import "./json-BZzd4eNj.js";
 import "./index-Be7jjS77.js";
 import { _ as createProtocol, a as RpcEvent, c as RpcMessageCodec, d as RpcRequest, f as RpcRequestSchema, h as RpcWireCodec, i as RpcErrorSchema, l as RpcMessageSchema, m as RpcResponseSchema, n as RpcError$1, o as RpcEventSchema, p as RpcResponse, r as RpcErrorCodes, s as RpcMessage, t as JsonProtocol, u as RpcProtocol } from "./protocol-ipDMUaRc.js";
-import { a as IRpcOptions, c as WebSocketOptions, i as IRpcConnection, l as WebSocketReadyState, n as IMethodController, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, t as IEventController, u as WebSocketServerOptions } from "./types-BVaXox7F.js";
+import { a as IRpcOptions, c as WebSocketOptions, i as IRpcConnection, l as WebSocketReadyState, n as IMethodController, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, t as IEventController, u as WebSocketServerOptions } from "./types-BGM8eZe5.js";
 import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "./reconnect-DbcN0R_1.js";
 import { RpcConnectionClosed, RpcError, RpcMethodNotFoundError, RpcRemoteError, RpcTimeoutError, RpcValidationError } from "./errors.js";
 import { a as PendingCallStorage, i as PendingCall, o as StorageMode, r as MaybePromise, s as SyncPendingCallStorage, t as AsyncPendingCallStorage } from "./interface-CuTDe_Pq.js";

package/dist/{multi-peer-BAi9yVzp.js → multi-peer-DFUqFBsx.js}

@@ -1,4 +1,4 @@
-import { t as RpcPeer } from "./default-BkrMd28n.js";
+import { t as RpcPeer } from "./default-B6CVJfTD.js";
 
 //#region src/adapters/multi-peer.ts
 /**
@@ -30,6 +30,8 @@ var MultiPeerBase = class {
 	provider;
 	/** Default timeout for RPC calls */
 	timeout;
+	/** Protocol for encoding/decoding messages */
+	protocol;
 	/** Lifecycle hooks */
 	hooks;
 	constructor(options) {
@@ -37,6 +39,7 @@ var MultiPeerBase = class {
 		this.remoteSchema = options.remoteSchema;
 		this.provider = options.provider;
 		this.timeout = options.timeout ?? 3e4;
+		if (options.protocol) this.protocol = options.protocol;
 		this.hooks = options.hooks ?? {};
 	}
 	/**
@@ -49,6 +52,7 @@ var MultiPeerBase = class {
 			localSchema: this.localSchema,
 			remoteSchema: this.remoteSchema,
 			provider: this.provider,
+			...this.protocol !== void 0 && { protocol: this.protocol },
 			onEvent: this.hooks.onEvent ? (event, data) => {
 				const peer = this.findPeerByWs(ws);
 				if (peer) this.hooks.onEvent(peer, event, data);

package/dist/peers/default.d.ts

@@ -3,6 +3,6 @@ import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import { n as RpcPeerOptions, t as RpcPeer } from "../default-C5z3UDd1.js";
+import "../types-BGM8eZe5.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-DOftsqyK.js";
 export { RpcPeer, RpcPeerOptions };

package/dist/peers/default.js

@@ -3,6 +3,6 @@ import "../json-Bshec-bZ.js";
 import "../codecs-BmYG2d_U.js";
 import "../protocol-_mpoOPp6.js";
 import "../errors-5BfreE63.js";
-import { t as RpcPeer } from "../default-BkrMd28n.js";
+import { t as RpcPeer } from "../default-B6CVJfTD.js";
 
 export { RpcPeer };

package/dist/peers/durable.d.ts

@@ -3,8 +3,8 @@ import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import { g as WireInput } from "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import { n as RpcPeerOptions, t as RpcPeer } from "../default-C5z3UDd1.js";
+import "../types-BGM8eZe5.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-DOftsqyK.js";
 import { i as PendingCall, s as SyncPendingCallStorage } from "../interface-CuTDe_Pq.js";
 
 //#region src/peers/durable.d.ts

package/dist/peers/durable.js

@@ -3,7 +3,7 @@ import "../json-Bshec-bZ.js";
 import "../codecs-BmYG2d_U.js";
 import "../protocol-_mpoOPp6.js";
 import "../errors-5BfreE63.js";
-import "../default-BkrMd28n.js";
-import { n as createDurableRpcPeerFactory, t as DurableRpcPeer } from "../durable-MZjkvyS6.js";
+import "../default-B6CVJfTD.js";
+import { n as createDurableRpcPeerFactory, t as DurableRpcPeer } from "../durable-DENcbnTp.js";
 
 export { DurableRpcPeer, createDurableRpcPeerFactory };

package/dist/peers/index.d.ts

@@ -3,8 +3,8 @@ import "../factory-BGezZgAP.js";
 import "../json-BZzd4eNj.js";
 import "../index-Be7jjS77.js";
 import "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import { n as RpcPeerOptions, t as RpcPeer } from "../default-C5z3UDd1.js";
+import "../types-BGM8eZe5.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-DOftsqyK.js";
 import "../interface-CuTDe_Pq.js";
 import { CallContext, DurableRpcPeer, DurableRpcPeerOptions } from "./durable.js";
 export { type CallContext, DurableRpcPeer, type DurableRpcPeerOptions, RpcPeer, type RpcPeerOptions };

package/dist/peers/index.js

@@ -3,7 +3,7 @@ import "../json-Bshec-bZ.js";
 import "../codecs-BmYG2d_U.js";
 import "../protocol-_mpoOPp6.js";
 import "../errors-5BfreE63.js";
-import { t as RpcPeer } from "../default-BkrMd28n.js";
-import { t as DurableRpcPeer } from "../durable-MZjkvyS6.js";
+import { t as RpcPeer } from "../default-B6CVJfTD.js";
+import { t as DurableRpcPeer } from "../durable-DENcbnTp.js";
 
 export { DurableRpcPeer, RpcPeer };

package/dist/{server-C5EvcG9T.d.ts → server-BJm2ViQB.d.ts}

@@ -1,6 +1,7 @@
 import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider } from "./schema-BPJJ9slm.js";
-import { a as IRpcOptions, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, u as WebSocketServerOptions } from "./types-BVaXox7F.js";
-import { t as RpcPeer } from "./default-C5z3UDd1.js";
+import { u as RpcProtocol } from "./protocol-ipDMUaRc.js";
+import { a as IRpcOptions, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, u as WebSocketServerOptions } from "./types-BGM8eZe5.js";
+import { t as RpcPeer } from "./default-DOftsqyK.js";
 import { IMultiAdapterHooks, IMultiConnectionAdapter, MultiDriver } from "./adapters/types.js";
 
 //#region src/adapters/multi-peer.d.ts
@@ -17,6 +18,8 @@ interface MultiPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends
   provider: Provider<TLocalSchema>;
   /** Default timeout for RPC calls in ms */
   timeout?: number;
+  /** Protocol for encoding/decoding messages */
+  protocol?: RpcProtocol;
   /** Lifecycle hooks */
   hooks?: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
 }
@@ -43,6 +46,8 @@ declare abstract class MultiPeerBase<TLocalSchema extends RpcSchema, TRemoteSche
   readonly provider: Provider<TLocalSchema>;
   /** Default timeout for RPC calls */
   readonly timeout: number;
+  /** Protocol for encoding/decoding messages */
+  readonly protocol?: RpcProtocol;
   /** Lifecycle hooks */
   readonly hooks: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
   constructor(options: MultiPeerOptions<TLocalSchema, TRemoteSchema>);
@@ -146,7 +151,7 @@ interface RpcServerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends
   provider: Provider<TLocalSchema>;
   /** WebSocket server instance or options to create one */
   wss: IWebSocketServer | WebSocketServerOptions;
-  /** WebSocket server constructor (defaults to require('ws').WebSocketServer) */
+  /** WebSocket server constructor (required when passing options instead of server instance) */
   WebSocketServer?: new (options: WebSocketServerOptions) => IWebSocketServer;
   /** Lifecycle hooks */
   hooks?: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;

package/dist/{types-BVaXox7F.d.ts → types-BGM8eZe5.d.ts}

@@ -1,5 +1,5 @@
 import { i as EventHandler, m as RpcSchema, p as Provider, r as EventEmitter } from "./schema-BPJJ9slm.js";
-import { g as WireInput } from "./protocol-ipDMUaRc.js";
+import { g as WireInput, u as RpcProtocol } from "./protocol-ipDMUaRc.js";
 
 //#region src/types.d.ts
 
@@ -72,6 +72,11 @@ interface IRpcOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcS
   readonly remoteSchema: TRemoteSchema;
   /** Default timeout for RPC calls in ms */
   readonly timeout?: number;
+  /**
+   * Protocol for encoding/decoding messages.
+   * Defaults to JSON. Use createProtocol() with a binary codec for better performance.
+   */
+  readonly protocol?: RpcProtocol;
 }
 /**
  * Interface for types that provide RPC method implementations

package/dist/types.d.ts

@@ -3,5 +3,5 @@ import "./factory-BGezZgAP.js";
 import "./json-BZzd4eNj.js";
 import "./index-Be7jjS77.js";
 import "./protocol-ipDMUaRc.js";
-import { a as IRpcOptions, c as WebSocketOptions, i as IRpcConnection, l as WebSocketReadyState, n as IMethodController, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, t as IEventController, u as WebSocketServerOptions } from "./types-BVaXox7F.js";
+import { a as IRpcOptions, c as WebSocketOptions, i as IRpcConnection, l as WebSocketReadyState, n as IMethodController, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, t as IEventController, u as WebSocketServerOptions } from "./types-BGM8eZe5.js";
 export { IEventController, IMethodController, IMinWebSocket, IRpcConnection, IRpcOptions, IWebSocket, IWebSocketServer, WebSocketOptions, WebSocketReadyState, WebSocketServerOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igoforth/ws-rpc",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Bidirectional RPC over WebSocket with Zod schema validation, TypeScript inference, and Cloudflare Durable Object support",
   "type": "module",
   "license": "MIT",
@@ -135,6 +135,7 @@
     "@msgpack/msgpack": "^3.1.2",
     "@types/node": "^22.10.2",
     "@types/ws": "^8.18.1",
+    "@vitest/coverage-istanbul": "^3.2.4",
     "cbor-x": "^1.6.0",
     "tsdown": "^0.18.1",
     "typescript": "^5.9.3",
@@ -148,6 +149,7 @@
     "test:watch": "vitest",
     "bench": "vitest bench --config vitest.config.bench.ts",
     "typecheck": "tsc --noEmit",
+    "typecheck:test": "tsc --noEmit -p tsconfig.test.json",
     "typegen": "wrangler types",
     "lint": "biome check .",
     "format": "biome format --write ."