@igoforth/ws-rpc 1.0.2 → 1.1.1

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:

package/dist/adapters/client.d.ts

@@ -1,10 +1,10 @@
-import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider, t as Driver } from "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider, t as Driver } from "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.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-4AgHYQBE.js";
+import { a as IRpcOptions, c as WebSocketOptions, o as IWebSocket } from "../types-NYBscFQZ.js";
+import "../default-DY19RYXA.js";
 import { t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
 import { IAdapterHooks, IConnectionAdapter } from "./types.js";
 
@@ -17,7 +17,7 @@ interface RpcClientOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends
   /** WebSocket URL to connect to */
   url: string;
   /** Implementation of local methods */
-  provider: Provider<TLocalSchema>;
+  provider: Provider<TLocalSchema["methods"]>;
   /** Auto-reconnect options (set to false to disable) */
   reconnect?: ReconnectOptions | false;
   /** Automatically connect when client is created (default: false) */
@@ -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 provider: Provider<TLocalSchema>;
+  readonly timeout: number;
+  readonly protocol?: RpcProtocol;
+  readonly provider: Provider<TLocalSchema["methods"]>;
   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;
@@ -70,7 +68,7 @@ declare class RpcClient<TLocalSchema extends RpcSchema, TRemoteSchema extends Rp
    * @returns Driver proxy for calling remote methods
    * @throws Error if not connected
    */
-  get driver(): Driver<TRemoteSchema>;
+  get driver(): Driver<TRemoteSchema["methods"]>;
   /**
    * Emit an event to the server (fire-and-forget)
    *

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 "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider } from "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.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 "../protocol-4AgHYQBE.js";
+import { a as IRpcOptions } from "../types-NYBscFQZ.js";
+import { t as RpcPeer } from "../default-DY19RYXA.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.
@@ -71,7 +87,7 @@ type RpcActorConstructor<TBase extends Constructor<Actor<unknown>>, TLocalSchema
  * ```
  */
 declare function withRpc<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema, TEnv, TBase extends Constructor<Actor<TEnv>> & {
-  prototype: Provider<TLocalSchema>;
+  prototype: Provider<TLocalSchema["methods"]>;
 }>(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

@@ -1,13 +1,13 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import "../default-C5z3UDd1.js";
+import "../protocol-4AgHYQBE.js";
+import "../types-NYBscFQZ.js";
+import "../default-DY19RYXA.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-Dp8DSL5I.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

@@ -1,10 +1,10 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import "../types-BVaXox7F.js";
-import "../default-C5z3UDd1.js";
+import "../protocol-4AgHYQBE.js";
+import "../types-NYBscFQZ.js";
+import "../default-DY19RYXA.js";
 import "./types.js";
-import { n as RpcServerOptions, t as RpcServer } from "../server-C5EvcG9T.js";
+import { n as RpcServerOptions, t as RpcServer } from "../server-Dp8DSL5I.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

@@ -1,10 +1,10 @@
-import { f as MethodDef, h as StringKeys, i as EventHandler, l as InferOutput, m as RpcSchema, s as InferInput, t as Driver } from "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import { f as MethodDef, h as StringKeys, i as EventHandler, l as InferOutput, m as RpcSchema, s as InferInput, t as Driver } from "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.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 "../protocol-4AgHYQBE.js";
+import { a as IRpcOptions, n as IMethodController, t as IEventController } from "../types-NYBscFQZ.js";
+import { t as RpcPeer } from "../default-DY19RYXA.js";
 import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
 
 //#region src/adapters/types.d.ts
@@ -88,7 +88,7 @@ interface IAdapterHooks<TRemoteSchema extends RpcSchema> {
   /** Called when reconnection fails after max attempts */
   onReconnectFailed?(): void;
   /** Called when receiving an event from the server */
-  onEvent?: EventHandler<TRemoteSchema>;
+  onEvent?: EventHandler<TRemoteSchema["events"]>;
 }
 interface IMultiAdapterHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
   /** Called when a peer connects */
@@ -96,14 +96,14 @@ interface IMultiAdapterHooks<TLocalSchema extends RpcSchema, TRemoteSchema exten
   /** Called when a peer disconnects */
   onDisconnect?(peer: RpcPeer<TLocalSchema, TRemoteSchema>): void;
   /** Called when an event is received from a peer */
-  onEvent?: EventHandler<TRemoteSchema, [peer: RpcPeer<TLocalSchema, TRemoteSchema>]>;
+  onEvent?: EventHandler<TRemoteSchema["events"], [peer: RpcPeer<TLocalSchema, TRemoteSchema>]>;
   /** Called when a peer encounters an error */
   onError?(peer: RpcPeer<TLocalSchema, TRemoteSchema> | null, error: Error): void;
   onClose?(): void;
 }
 interface IConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema>, IEventController<TLocalSchema, TRemoteSchema> {
   /** Driver for calling remote methods on connected peer */
-  readonly driver: Driver<TRemoteSchema>;
+  readonly driver: Driver<TRemoteSchema["methods"]>;
   readonly hooks: IAdapterHooks<TRemoteSchema>;
 }
 /**

package/dist/codecs/cbor.d.ts

@@ -1,5 +1,5 @@
-import "../schema-BPJJ9slm.js";
-import { n as CodecFactory } from "../factory-BGezZgAP.js";
+import "../schema-BzaFWzeV.js";
+import { n as CodecFactory } from "../factory-Dapk2aA3.js";
 import * as z from "zod";
 
 //#region src/codecs/cbor.d.ts

package/dist/codecs/factory.d.ts

@@ -1,3 +1,3 @@
-import "../schema-BPJJ9slm.js";
-import { a as WireCodec, c as createStringCodecFactory, i as StringCodec, l as isBinaryCodec, n as CodecFactory, o as WireData, r as CodecOptions, s as createBinaryCodecFactory, t as BinaryCodec, u as isStringCodec } from "../factory-BGezZgAP.js";
+import "../schema-BzaFWzeV.js";
+import { a as WireCodec, c as createStringCodecFactory, i as StringCodec, l as isBinaryCodec, n as CodecFactory, o as WireData, r as CodecOptions, s as createBinaryCodecFactory, t as BinaryCodec, u as isStringCodec } from "../factory-Dapk2aA3.js";
 export { BinaryCodec, CodecFactory, CodecOptions, StringCodec, WireCodec, WireData, createBinaryCodecFactory, createStringCodecFactory, isBinaryCodec, isStringCodec };

package/dist/codecs/index.d.ts

@@ -1,5 +1,5 @@
-import "../schema-BPJJ9slm.js";
-import { a as WireCodec, c as createStringCodecFactory, i as StringCodec, l as isBinaryCodec, n as CodecFactory, o as WireData, r as CodecOptions, s as createBinaryCodecFactory, t as BinaryCodec, u as isStringCodec } from "../factory-BGezZgAP.js";
-import { n as createJsonCodec, t as JsonCodec } from "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import { a as WireCodec, c as createStringCodecFactory, i as StringCodec, l as isBinaryCodec, n as CodecFactory, o as WireData, r as CodecOptions, s as createBinaryCodecFactory, t as BinaryCodec, u as isStringCodec } from "../factory-Dapk2aA3.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-ZQ5sjEbW.js";
 import "../index-Be7jjS77.js";
 export { BinaryCodec, CodecFactory, CodecOptions, JsonCodec, StringCodec, WireCodec, WireData, createBinaryCodecFactory, createJsonCodec, createStringCodecFactory, isBinaryCodec, isStringCodec };

package/dist/codecs/json.d.ts

@@ -1,4 +1,4 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import { n as createJsonCodec, t as JsonCodec } from "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-ZQ5sjEbW.js";
 export { JsonCodec, createJsonCodec };

package/dist/codecs/msgpack.d.ts

@@ -1,5 +1,5 @@
-import "../schema-BPJJ9slm.js";
-import { n as CodecFactory } from "../factory-BGezZgAP.js";
+import "../schema-BzaFWzeV.js";
+import { n as CodecFactory } from "../factory-Dapk2aA3.js";
 import * as z from "zod";
 
 //#region src/codecs/msgpack.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-DY19RYXA.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 InferEventData, h as StringKeys, i as EventHandler, m as RpcSchema, n as EventDef, p as Provider, t as Driver } from "./schema-BzaFWzeV.js";
+import { g as WireInput, u as RpcProtocol } from "./protocol-4AgHYQBE.js";
+import { a as IRpcOptions, r as IMinWebSocket } from "./types-NYBscFQZ.js";
 
 //#region src/peers/default.d.ts
 
@@ -13,26 +13,9 @@ interface RpcPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends R
   /** WebSocket instance */
   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;
+  provider: Partial<Provider<TLocalSchema["methods"]>>;
   /** Handler for incoming events */
-  onEvent?: EventHandler<TRemoteSchema> | undefined;
+  onEvent?: EventHandler<TRemoteSchema["events"]> | undefined;
   /** Generate unique request IDs */
   generateId?: (() => string) | undefined;
 }
@@ -59,7 +42,7 @@ declare class RpcPeer<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcS
   private requestCounter;
   private closed;
   /** Proxy for calling remote methods */
-  readonly driver: Driver<TRemoteSchema>;
+  readonly driver: Driver<TRemoteSchema["methods"]>;
   constructor(options: RpcPeerOptions<TLocalSchema, TRemoteSchema>);
   /**
    * Create a proxy that allows calling remote methods

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/{factory-BGezZgAP.d.ts → factory-Dapk2aA3.d.ts}

@@ -1,4 +1,4 @@
-import { d as LiteralStringUnion } from "./schema-BPJJ9slm.js";
+import { d as LiteralStringUnion } from "./schema-BzaFWzeV.js";
 import * as z from "zod";
 
 //#region src/codecs/factory.d.ts

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { _ as method, a as InferEventData, c as InferMethods, f as MethodDef, g as event, i as EventHandler, l as InferOutput, m as RpcSchema, n as EventDef, o as InferEvents, p as Provider, s as InferInput, t as Driver } from "./schema-BPJJ9slm.js";
-import "./factory-BGezZgAP.js";
-import "./json-BZzd4eNj.js";
+import { _ as method, a as InferEventData, c as InferMethods, f as MethodDef, g as event, i as EventHandler, l as InferOutput, m as RpcSchema, n as EventDef, o as InferEvents, p as Provider, s as InferInput, t as Driver } from "./schema-BzaFWzeV.js";
+import "./factory-Dapk2aA3.js";
+import "./json-ZQ5sjEbW.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 { _ 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-4AgHYQBE.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-NYBscFQZ.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";
-import { t as MemoryPendingCallStorage } from "./memory-BbN1TQZi.js";
-import { t as SqlPendingCallStorage } from "./sql-BpEL9udW.js";
+import { a as PendingCallStorage, i as PendingCall, o as StorageMode, r as MaybePromise, s as SyncPendingCallStorage, t as AsyncPendingCallStorage } from "./interface-CoVQ0KnO.js";
+import { t as MemoryPendingCallStorage } from "./memory-DSlJL2of.js";
+import { t as SqlPendingCallStorage } from "./sql-bFsho2vn.js";
 import "./storage/index.js";
 import "./utils/index.js";
 export { type AsyncPendingCallStorage, type Driver, type EventDef, type EventHandler, type IEventController, type IMethodController, type IMinWebSocket, type IRpcConnection, type IRpcOptions, type IWebSocket, type IWebSocketServer, type InferEventData, type InferEvents, type InferInput, type InferMethods, type InferOutput, JsonProtocol, type MaybePromise, MemoryPendingCallStorage, type MethodDef, type PendingCall, type PendingCallStorage, type Provider, type ReconnectOptions, RpcConnectionClosed, RpcError, RpcErrorCodes, type RpcError$1 as RpcErrorMessage, RpcErrorSchema, type RpcEvent, RpcEventSchema, type RpcMessage, RpcMessageCodec, RpcMessageSchema, RpcMethodNotFoundError, type RpcProtocol, RpcRemoteError, type RpcRequest, RpcRequestSchema, type RpcResponse, RpcResponseSchema, type RpcSchema, RpcTimeoutError, RpcValidationError, type RpcWireCodec, SqlPendingCallStorage, type StorageMode, type SyncPendingCallStorage, type WebSocketOptions, WebSocketReadyState, type WebSocketServerOptions, calculateReconnectDelay, createProtocol, defaultReconnectOptions, event, method };

package/dist/{interface-CuTDe_Pq.d.ts → interface-CoVQ0KnO.d.ts}

@@ -1,4 +1,4 @@
-import { m as RpcSchema } from "./schema-BPJJ9slm.js";
+import { m as RpcSchema } from "./schema-BzaFWzeV.js";
 
 //#region src/storage/interface.d.ts
 

package/dist/{json-BZzd4eNj.d.ts → json-ZQ5sjEbW.d.ts}

@@ -1,4 +1,4 @@
-import { n as CodecFactory } from "./factory-BGezZgAP.js";
+import { n as CodecFactory } from "./factory-Dapk2aA3.js";
 import * as z from "zod";
 
 //#region src/codecs/json.d.ts

package/dist/{memory-BbN1TQZi.d.ts → memory-DSlJL2of.d.ts}

@@ -1,5 +1,5 @@
-import { i as StringCodec } from "./factory-BGezZgAP.js";
-import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-CuTDe_Pq.js";
+import { i as StringCodec } from "./factory-Dapk2aA3.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-CoVQ0KnO.js";
 
 //#region src/storage/memory.d.ts
 

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

@@ -1,8 +1,8 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.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 "../protocol-4AgHYQBE.js";
+import "../types-NYBscFQZ.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-DY19RYXA.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

@@ -1,11 +1,11 @@
-import { m as RpcSchema } from "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import { m as RpcSchema } from "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.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 { i as PendingCall, s as SyncPendingCallStorage } from "../interface-CuTDe_Pq.js";
+import { g as WireInput } from "../protocol-4AgHYQBE.js";
+import "../types-NYBscFQZ.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-DY19RYXA.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "../interface-CoVQ0KnO.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

@@ -1,10 +1,10 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.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 "../interface-CuTDe_Pq.js";
+import "../protocol-4AgHYQBE.js";
+import "../types-NYBscFQZ.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-DY19RYXA.js";
+import "../interface-CoVQ0KnO.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/{protocol-ipDMUaRc.d.ts → protocol-4AgHYQBE.d.ts}

@@ -1,4 +1,4 @@
-import { a as WireCodec } from "./factory-BGezZgAP.js";
+import { a as WireCodec } from "./factory-Dapk2aA3.js";
 import * as z from "zod";
 
 //#region src/protocol.d.ts

package/dist/protocol.d.ts

@@ -1,6 +1,6 @@
-import "./schema-BPJJ9slm.js";
-import "./factory-BGezZgAP.js";
-import "./json-BZzd4eNj.js";
+import "./schema-BzaFWzeV.js";
+import "./factory-Dapk2aA3.js";
+import "./json-ZQ5sjEbW.js";
 import "./index-Be7jjS77.js";
-import { _ as createProtocol, a as RpcEvent, c as RpcMessageCodec, d as RpcRequest, f as RpcRequestSchema, g as WireInput, h as RpcWireCodec, i as RpcErrorSchema, l as RpcMessageSchema, m as RpcResponseSchema, n as RpcError, o as RpcEventSchema, p as RpcResponse, r as RpcErrorCodes, s as RpcMessage, t as JsonProtocol, u as RpcProtocol } from "./protocol-ipDMUaRc.js";
+import { _ as createProtocol, a as RpcEvent, c as RpcMessageCodec, d as RpcRequest, f as RpcRequestSchema, g as WireInput, h as RpcWireCodec, i as RpcErrorSchema, l as RpcMessageSchema, m as RpcResponseSchema, n as RpcError, o as RpcEventSchema, p as RpcResponse, r as RpcErrorCodes, s as RpcMessage, t as JsonProtocol, u as RpcProtocol } from "./protocol-4AgHYQBE.js";
 export { JsonProtocol, RpcError, RpcErrorCodes, RpcErrorSchema, RpcEvent, RpcEventSchema, RpcMessage, RpcMessageCodec, RpcMessageSchema, RpcProtocol, RpcRequest, RpcRequestSchema, RpcResponse, RpcResponseSchema, RpcWireCodec, WireInput, createProtocol };

package/dist/{schema-BPJJ9slm.d.ts → schema-BzaFWzeV.d.ts}

@@ -9,17 +9,17 @@ type LiteralStringUnion<T> = LiteralUnion<T, string>;
 /**
  * Method definition with input and output schemas
  */
-interface MethodDef<TInput$1 extends z.ZodType = z.ZodType, TOutput$1 extends z.ZodType = z.ZodType> {
+interface MethodDef<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> {
   _type: "method";
-  input: TInput$1;
-  output: TOutput$1;
+  input: TInput;
+  output: TOutput;
 }
 /**
  * Event definition with data schema
  */
-interface EventDef<TData$1 extends z.ZodType = z.ZodType> {
+interface EventDef<TData extends z.ZodType = z.ZodType> {
   _type: "event";
-  data: TData$1;
+  data: TData;
 }
 /**
  * Define an RPC method with input/output schemas
@@ -35,10 +35,10 @@ interface EventDef<TData$1 extends z.ZodType = z.ZodType> {
  * });
  * ```
  */
-declare function method<TInput$1 extends z.ZodType, TOutput$1 extends z.ZodType>(def: {
-  input: TInput$1;
-  output: TOutput$1;
-}): MethodDef<TInput$1, TOutput$1>;
+declare function method<TInput extends z.ZodType, TOutput extends z.ZodType>(def: {
+  input: TInput;
+  output: TOutput;
+}): MethodDef<TInput, TOutput>;
 /**
  * Define a fire-and-forget event with data schema
  *
@@ -52,9 +52,9 @@ declare function method<TInput$1 extends z.ZodType, TOutput$1 extends z.ZodType>
  * });
  * ```
  */
-declare function event<TData$1 extends z.ZodType>(def: {
-  data: TData$1;
-}): EventDef<TData$1>;
+declare function event<TData extends z.ZodType>(def: {
+  data: TData;
+}): EventDef<TData>;
 /**
  * Schema definition containing methods and events
  */
@@ -67,42 +67,42 @@ interface RpcSchema {
  *
  * @typeParam T - A MethodDef type to extract the input from
  */
-type InferInput<T> = T extends MethodDef<infer TInput, z.ZodType> ? z.input<TInput> : never;
+type InferInput<T extends MethodDef> = z.input<T["input"]>;
 /**
  * Infer the output type from a method definition
  *
  * @typeParam T - A MethodDef type to extract the output from
  */
-type InferOutput<T> = T extends MethodDef<z.ZodType, infer TOutput> ? z.output<TOutput> : never;
+type InferOutput<T extends MethodDef> = z.output<T["output"]>;
 /**
  * Infer the data type from an event definition
  *
  * @typeParam T - An EventDef type to extract the data type from
  */
-type InferEventData<T> = T extends EventDef<infer TData> ? z.infer<TData> : never;
+type InferEventData<T extends EventDef> = z.infer<T["data"]>;
 /**
  * Infer method signatures from a schema's methods
  */
-type InferMethods<T extends RpcSchema> = T["methods"] extends Record<string, MethodDef> ? { [K in StringKeys<T["methods"]>]: (input: InferInput<T["methods"][K]>) => InferOutput<T["methods"][K]> | Promise<InferOutput<T["methods"][K]>> } : object;
+type InferMethods<T extends Record<string, MethodDef>> = { [K in StringKeys<T>]: (input: z.input<T[K]["input"]>) => z.output<T[K]["output"]> | Promise<z.output<T[K]["output"]>> };
 /**
  * Infer event emitter signatures from a schema's events
  */
-type InferEvents<T extends RpcSchema> = T["events"] extends Record<string, EventDef> ? { [K in StringKeys<T["events"]>]: InferEventData<T["events"][K]> } : object;
+type InferEvents<T extends Record<string, EventDef>> = { [K in StringKeys<T>]: InferEventData<T[K]> };
 /**
  * Provider type - implements the local methods defined in a schema
  */
-type Provider<T extends RpcSchema> = InferMethods<T>;
+type Provider<T extends RpcSchema["methods"]> = T extends Record<string, MethodDef> ? InferMethods<T> : {};
 /**
  * Driver type - proxy to call remote methods defined in a schema
  */
-type Driver<T extends RpcSchema> = InferMethods<T>;
+type Driver<T extends RpcSchema["methods"]> = T extends Record<string, MethodDef> ? InferMethods<T> : {};
 /**
  * Event handler type - handles incoming events
  */
-type EventHandler<T extends RpcSchema, ExtraArgs extends any[] = []> = <K$1 extends StringKeys<T["events"]>>(...args: [...ExtraArgs, event: K$1, data: T["events"] extends Record<string, EventDef> ? InferEventData<T["events"][K$1]> : never]) => void;
+type EventHandler<T extends RpcSchema["events"], ExtraArgs extends any[] = []> = <K$1 extends StringKeys<T>>(...args: [...ExtraArgs, event: K$1, data: T extends Record<string, EventDef> ? InferEventData<T[K$1]> : never]) => void;
 /**
  * Event emitter type - emits outgoing events
  */
-type EventEmitter<T extends RpcSchema, ExtraArgs extends any[] = []> = <K$1 extends StringKeys<T["events"]>>(...args: [event: K$1, data: T["events"] extends Record<string, EventDef> ? InferEventData<T["events"][K$1]> : never, ...ExtraArgs]) => void;
+type EventEmitter<T extends RpcSchema["events"], ExtraArgs extends any[] = []> = <K$1 extends StringKeys<T>>(...args: [event: K$1, data: T extends Record<string, EventDef> ? InferEventData<T[K$1]> : never, ...ExtraArgs]) => void;
 //#endregion
 export { method as _, InferEventData as a, InferMethods as c, LiteralStringUnion as d, MethodDef as f, event as g, StringKeys as h, EventHandler as i, InferOutput as l, RpcSchema as m, EventDef as n, InferEvents as o, Provider as p, EventEmitter as r, InferInput as s, Driver as t, LiteralString as u };

package/dist/schema.d.ts

@@ -1,2 +1,2 @@
-import { _ as method, a as InferEventData, c as InferMethods, d as LiteralStringUnion, f as MethodDef, g as event, h as StringKeys, i as EventHandler, l as InferOutput, m as RpcSchema, n as EventDef, o as InferEvents, p as Provider, r as EventEmitter, s as InferInput, t as Driver, u as LiteralString } from "./schema-BPJJ9slm.js";
+import { _ as method, a as InferEventData, c as InferMethods, d as LiteralStringUnion, f as MethodDef, g as event, h as StringKeys, i as EventHandler, l as InferOutput, m as RpcSchema, n as EventDef, o as InferEvents, p as Provider, r as EventEmitter, s as InferInput, t as Driver, u as LiteralString } from "./schema-BzaFWzeV.js";
 export { Driver, EventDef, EventEmitter, EventHandler, InferEventData, InferEvents, InferInput, InferMethods, InferOutput, LiteralString, LiteralStringUnion, MethodDef, Provider, RpcSchema, StringKeys, event, method };

package/dist/{server-C5EvcG9T.d.ts → server-Dp8DSL5I.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 { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider } from "./schema-BzaFWzeV.js";
+import { u as RpcProtocol } from "./protocol-4AgHYQBE.js";
+import { a as IRpcOptions, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, u as WebSocketServerOptions } from "./types-NYBscFQZ.js";
+import { t as RpcPeer } from "./default-DY19RYXA.js";
 import { IMultiAdapterHooks, IMultiConnectionAdapter, MultiDriver } from "./adapters/types.js";
 
 //#region src/adapters/multi-peer.d.ts
@@ -14,9 +15,11 @@ interface MultiPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends
   /** Schema defining remote methods we can call */
   remoteSchema: TRemoteSchema;
   /** Implementation of local methods */
-  provider: Provider<TLocalSchema>;
+  provider: Provider<TLocalSchema["methods"]>;
   /** Default timeout for RPC calls in ms */
   timeout?: number;
+  /** Protocol for encoding/decoding messages */
+  protocol?: RpcProtocol;
   /** Lifecycle hooks */
   hooks?: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
 }
@@ -40,9 +43,11 @@ declare abstract class MultiPeerBase<TLocalSchema extends RpcSchema, TRemoteSche
   /** Remote schema */
   readonly remoteSchema: TRemoteSchema;
   /** Implementation of local methods */
-  readonly provider: Provider<TLocalSchema>;
+  readonly provider: Provider<TLocalSchema["methods"]>;
   /** 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>);
@@ -143,10 +148,10 @@ declare abstract class MultiPeerBase<TLocalSchema extends RpcSchema, TRemoteSche
  */
 interface RpcServerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema> {
   /** Implementation of local methods */
-  provider: Provider<TLocalSchema>;
+  provider: Provider<TLocalSchema["methods"]>;
   /** 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/{sql-BpEL9udW.d.ts → sql-bFsho2vn.d.ts}

@@ -1,5 +1,5 @@
-import { i as StringCodec } from "./factory-BGezZgAP.js";
-import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-CuTDe_Pq.js";
+import { i as StringCodec } from "./factory-Dapk2aA3.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-CoVQ0KnO.js";
 
 //#region src/storage/sql.d.ts
 

package/dist/storage/index.d.ts

@@ -1,8 +1,8 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.js";
 import "../index-Be7jjS77.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";
-import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-BbN1TQZi.js";
-import { n as SqlPendingCallStorageOptions, t as SqlPendingCallStorage } from "../sql-BpEL9udW.js";
+import { a as PendingCallStorage, i as PendingCall, o as StorageMode, r as MaybePromise, s as SyncPendingCallStorage, t as AsyncPendingCallStorage } from "../interface-CoVQ0KnO.js";
+import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-DSlJL2of.js";
+import { n as SqlPendingCallStorageOptions, t as SqlPendingCallStorage } from "../sql-bFsho2vn.js";
 export { type AsyncPendingCallStorage, type MaybePromise, MemoryPendingCallStorage, type MemoryPendingCallStorageOptions, type PendingCall, type PendingCallStorage, SqlPendingCallStorage, type SqlPendingCallStorageOptions, type StorageMode, type SyncPendingCallStorage };

package/dist/storage/interface.d.ts

@@ -1,3 +1,3 @@
-import "../schema-BPJJ9slm.js";
-import { a as PendingCallStorage, i as PendingCall, n as IContinuationHandler, o as StorageMode, r as MaybePromise, s as SyncPendingCallStorage, t as AsyncPendingCallStorage } from "../interface-CuTDe_Pq.js";
+import "../schema-BzaFWzeV.js";
+import { a as PendingCallStorage, i as PendingCall, n as IContinuationHandler, o as StorageMode, r as MaybePromise, s as SyncPendingCallStorage, t as AsyncPendingCallStorage } from "../interface-CoVQ0KnO.js";
 export { AsyncPendingCallStorage, IContinuationHandler, MaybePromise, PendingCall, PendingCallStorage, StorageMode, SyncPendingCallStorage };

package/dist/storage/memory.d.ts

@@ -1,7 +1,7 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.js";
 import "../index-Be7jjS77.js";
-import "../interface-CuTDe_Pq.js";
-import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-BbN1TQZi.js";
+import "../interface-CoVQ0KnO.js";
+import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-DSlJL2of.js";
 export { MemoryPendingCallStorage, MemoryPendingCallStorageOptions };

package/dist/storage/sql.d.ts

@@ -1,7 +1,7 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-BzaFWzeV.js";
+import "../factory-Dapk2aA3.js";
+import "../json-ZQ5sjEbW.js";
 import "../index-Be7jjS77.js";
-import "../interface-CuTDe_Pq.js";
-import { i as SqlStorageCursor, n as SqlPendingCallStorageOptions, r as SqlStorage, t as SqlPendingCallStorage } from "../sql-BpEL9udW.js";
+import "../interface-CoVQ0KnO.js";
+import { i as SqlStorageCursor, n as SqlPendingCallStorageOptions, r as SqlStorage, t as SqlPendingCallStorage } from "../sql-bFsho2vn.js";
 export { SqlPendingCallStorage, SqlPendingCallStorageOptions, SqlStorage, SqlStorageCursor };

package/dist/{types-BVaXox7F.d.ts → types-NYBscFQZ.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 { i as EventHandler, m as RpcSchema, p as Provider, r as EventEmitter } from "./schema-BzaFWzeV.js";
+import { g as WireInput, u as RpcProtocol } from "./protocol-4AgHYQBE.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
@@ -80,7 +85,7 @@ interface IRpcOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcS
  */
 interface IMethodController<TLocalSchema extends RpcSchema> {
   /** Implementation of local methods */
-  readonly provider: Provider<TLocalSchema>;
+  readonly provider: Provider<TLocalSchema["methods"]>;
 }
 /**
  * Interface for types that can emit and receive events
@@ -92,9 +97,9 @@ interface IMethodController<TLocalSchema extends RpcSchema> {
  */
 interface IEventController<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema, EmitArgs extends any[] = [], EventArgs extends any[] = []> {
   /** Emit an event to the connected peer */
-  emit: EventEmitter<TLocalSchema, EmitArgs>;
+  emit: EventEmitter<TLocalSchema["events"], EmitArgs>;
   /** Called when receiving an event from the connected peer */
-  onEvent?: EventHandler<TRemoteSchema, EventArgs>;
+  onEvent?: EventHandler<TRemoteSchema["events"], EventArgs>;
 }
 /**
  * Base interface for RPC connections (1-1)

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-import "./schema-BPJJ9slm.js";
-import "./factory-BGezZgAP.js";
-import "./json-BZzd4eNj.js";
+import "./schema-BzaFWzeV.js";
+import "./factory-Dapk2aA3.js";
+import "./json-ZQ5sjEbW.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 "./protocol-4AgHYQBE.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-NYBscFQZ.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.1",
   "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 ."