@igoforth/ws-rpc 1.1.0 → 1.1.2

package/README.md

@@ -305,9 +305,9 @@ Real WebSocket RPC round-trip benchmarks (GitHub Actions runner, Node.js 22):
 **Throughput (ops/sec):**
 | Payload | JSON | MessagePack | CBOR | Fastest |
 |---------|------|-------------|------|---------|
-| Small | 1443 | 1798 | 1812 | CBOR |
-| Medium | 1514 | 1591 | 5142 | CBOR |
-| Large | 1656 | 1270 | 1999 | CBOR |
+| Small | 0 | 0 | 0 | JSON |
+| Medium | 0 | 0 | 0 | JSON |
+| Large | 0 | 0 | 0 | JSON |
 
 > 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

@@ -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 { _ as RpcSchema, h as Provider, s as InferEvents, t as Driver, v as StringKeys } from "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.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 { u as RpcProtocol } from "../protocol-DxoHWqMA.js";
+import { a as IRpcOptions, c as WebSocketOptions, o as IWebSocket } from "../types-BUYZxMco.js";
+import "../default-CKJtfuap.js";
 import { t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
 import { IAdapterHooks, IConnectionAdapter } from "./types.js";
 
@@ -13,11 +13,11 @@ import { IAdapterHooks, IConnectionAdapter } from "./types.js";
 /**
  * Options for creating an RpcClient
  */
-interface RpcClientOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IAdapterHooks<TRemoteSchema>, IRpcOptions<TLocalSchema, TRemoteSchema> {
+interface RpcClientOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IAdapterHooks<TRemoteSchema["events"]>, IRpcOptions<TLocalSchema, TRemoteSchema> {
   /** 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) */
@@ -43,8 +43,8 @@ declare class RpcClient<TLocalSchema extends RpcSchema, TRemoteSchema extends Rp
   readonly remoteSchema: TRemoteSchema;
   readonly timeout: number;
   readonly protocol?: RpcProtocol;
-  readonly provider: Provider<TLocalSchema>;
-  readonly hooks: IAdapterHooks<TRemoteSchema>;
+  readonly provider: Provider<TLocalSchema["methods"]>;
+  readonly hooks: IAdapterHooks<TRemoteSchema["events"]>;
   private readonly reconnectOptions;
   private readonly createWebSocket;
   private ws;
@@ -68,14 +68,14 @@ 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)
    *
    * @param event - Event name from local schema
    * @param data - Event data matching the schema
    */
-  emit<K extends StringKeys<TLocalSchema["events"]>>(event: K, data: TLocalSchema["events"] extends Record<string, EventDef> ? InferEventData<TLocalSchema["events"][K]> : never): void;
+  emit<K extends StringKeys<InferEvents<TLocalSchema["events"]>>>(event: K, data: InferEvents<TLocalSchema["events"]>[K]): void;
   /**
    * Connect to the WebSocket server
    *

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

@@ -1,10 +1,10 @@
-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 { _ as RpcSchema, h as Provider, s as InferEvents, v as StringKeys } from "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import { a as IRpcOptions } from "../types-BGM8eZe5.js";
-import { t as RpcPeer } from "../default-DOftsqyK.js";
+import "../protocol-DxoHWqMA.js";
+import { a as IRpcOptions } from "../types-BUYZxMco.js";
+import { t as RpcPeer } from "../default-CKJtfuap.js";
 import { IMultiAdapterHooks, IMultiConnectionAdapter } from "./types.js";
 import { Constructor } from "type-fest";
 import { Actor } from "@cloudflare/actors";
@@ -28,7 +28,7 @@ interface IRpcActorHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends R
   /** 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;
+  onRpcEvent<K extends StringKeys<InferEvents<TRemoteSchema["events"]>>>(peer: RpcPeer<TLocalSchema, TRemoteSchema>, event: K, data: InferEvents<TRemoteSchema["events"]>[K]): 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. */
@@ -87,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, IRpcActorHooks, RpcActorConstructor, withRpc };

package/dist/adapters/index.d.ts

@@ -1,13 +1,13 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import "../types-BGM8eZe5.js";
-import "../default-DOftsqyK.js";
+import "../protocol-DxoHWqMA.js";
+import "../types-BUYZxMco.js";
+import "../default-CKJtfuap.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 { IDOHooks, IRpcActorHooks, RpcActorConstructor, withRpc } from "./cloudflare-do.js";
-import { n as RpcServerOptions, r as MultiPeerBase, t as RpcServer } from "../server-BJm2ViQB.js";
+import { n as RpcServerOptions, r as MultiPeerBase, t as RpcServer } from "../server-q205-WY8.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/server.d.ts

@@ -1,10 +1,10 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import "../types-BGM8eZe5.js";
-import "../default-DOftsqyK.js";
+import "../protocol-DxoHWqMA.js";
+import "../types-BUYZxMco.js";
+import "../default-CKJtfuap.js";
 import "./types.js";
-import { n as RpcServerOptions, t as RpcServer } from "../server-BJm2ViQB.js";
+import { n as RpcServerOptions, t as RpcServer } from "../server-q205-WY8.js";
 export { RpcServer, RpcServerOptions };

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 { _ as RpcSchema, a as EventHandler, c as InferInput, m as MethodDef, r as EventDef, t as Driver, u as InferOutput, v as StringKeys } from "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import { a as IRpcOptions, n as IMethodController, t as IEventController } from "../types-BGM8eZe5.js";
-import { t as RpcPeer } from "../default-DOftsqyK.js";
+import "../protocol-DxoHWqMA.js";
+import { a as IRpcOptions, n as IMethodController, t as IEventController } from "../types-BUYZxMco.js";
+import { t as RpcPeer } from "../default-CKJtfuap.js";
 import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
 
 //#region src/adapters/types.d.ts
@@ -78,7 +78,7 @@ type MultiDriver<TRemoteSchema extends RpcSchema> = TRemoteSchema["methods"] ext
 /**
  * Event emitter type for client callbacks
  */
-interface IAdapterHooks<TRemoteSchema extends RpcSchema> {
+interface IAdapterHooks<TRemoteEvents extends Record<string, EventDef> | undefined> {
   /** Called when WebSocket connection opens */
   onConnect?(): void;
   /** Called when WebSocket connection closes */
@@ -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<TRemoteEvents>;
 }
 interface IMultiAdapterHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
   /** Called when a peer connects */
@@ -96,15 +96,15 @@ 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> {
+interface IConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema["methods"]>, IEventController<TLocalSchema["events"], TRemoteSchema["events"]> {
   /** Driver for calling remote methods on connected peer */
-  readonly driver: Driver<TRemoteSchema>;
-  readonly hooks: IAdapterHooks<TRemoteSchema>;
+  readonly driver: Driver<TRemoteSchema["methods"]>;
+  readonly hooks: IAdapterHooks<TRemoteSchema["events"]>;
 }
 /**
  * Interface for adapters that manage multiple connections
@@ -112,7 +112,7 @@ interface IConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema exten
  * Extends IRpcConnection - `emit()` broadcasts to all connected peers.
  * Implemented by RpcServer and Cloudflare DO adapter.
  */
-interface IMultiConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema>, IEventController<TLocalSchema, TRemoteSchema, [ids?: string[]]> {
+interface IMultiConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema["methods"]>, IEventController<TLocalSchema["events"], TRemoteSchema["events"], [ids?: string[]]> {
   /** Driver for calling remote methods on connected peers */
   readonly driver: MultiDriver<TRemoteSchema>;
   readonly hooks: IMultiAdapterHooks<TLocalSchema, 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-B0zKtaPR.js";
+import { n as CodecFactory } from "../factory-CZioNF7N.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-B0zKtaPR.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-CZioNF7N.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-B0zKtaPR.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-CZioNF7N.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-1pVWk4mJ.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-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-1pVWk4mJ.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-B0zKtaPR.js";
+import { n as CodecFactory } from "../factory-CZioNF7N.js";
 import * as z from "zod";
 
 //#region src/codecs/msgpack.d.ts

package/dist/{default-DOftsqyK.d.ts → default-CKJtfuap.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-BGM8eZe5.js";
+import { _ as RpcSchema, a as EventHandler, h as Provider, s as InferEvents, t as Driver, v as StringKeys } from "./schema-B0zKtaPR.js";
+import { g as WireInput, u as RpcProtocol } from "./protocol-DxoHWqMA.js";
+import { a as IRpcOptions, r as IMinWebSocket } from "./types-BUYZxMco.js";
 
 //#region src/peers/default.d.ts
 
@@ -13,9 +13,9 @@ interface RpcPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends R
   /** WebSocket instance */
   ws: IMinWebSocket;
   /** Implementation of local methods */
-  provider: Partial<Provider<TLocalSchema>>;
+  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;
 }
@@ -42,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
@@ -55,7 +55,7 @@ declare class RpcPeer<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcS
   /**
    * Emit an event to the remote peer (fire-and-forget)
    */
-  emit<K extends StringKeys<TLocalSchema["events"]>>(event: K, data: TLocalSchema["events"] extends Record<string, EventDef> ? InferEventData<TLocalSchema["events"][K]> : never): void;
+  emit<K extends StringKeys<InferEvents<TLocalSchema["events"]>>>(event: K, data: InferEvents<TLocalSchema["events"]>[K]): void;
   /**
    * Handle an incoming WebSocket message
    *

package/dist/{factory-BGezZgAP.d.ts → factory-CZioNF7N.d.ts}

@@ -1,4 +1,4 @@
-import { d as LiteralStringUnion } from "./schema-BPJJ9slm.js";
+import { f as LiteralStringUnion } from "./schema-B0zKtaPR.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 RpcSchema, a as EventHandler, b as method, c as InferInput, h as Provider, l as InferMethods, m as MethodDef, o as InferEventData, r as EventDef, s as InferEvents, t as Driver, u as InferOutput, y as event } from "./schema-B0zKtaPR.js";
+import "./factory-CZioNF7N.js";
+import "./json-1pVWk4mJ.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-BGM8eZe5.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-DxoHWqMA.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-BUYZxMco.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-RK7s4DQf.js";
+import { t as MemoryPendingCallStorage } from "./memory-BxojNC-D.js";
+import { t as SqlPendingCallStorage } from "./sql-xafn7bdx.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-RK7s4DQf.d.ts}

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

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

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

package/dist/{memory-BbN1TQZi.d.ts → memory-BxojNC-D.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-CZioNF7N.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-RK7s4DQf.js";
 
 //#region src/storage/memory.d.ts
 

package/dist/peers/default.d.ts

@@ -1,8 +1,8 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import "../types-BGM8eZe5.js";
-import { n as RpcPeerOptions, t as RpcPeer } from "../default-DOftsqyK.js";
+import "../protocol-DxoHWqMA.js";
+import "../types-BUYZxMco.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-CKJtfuap.js";
 export { RpcPeer, RpcPeerOptions };

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 { _ as RpcSchema } from "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import { g as WireInput } from "../protocol-ipDMUaRc.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";
+import { g as WireInput } from "../protocol-DxoHWqMA.js";
+import "../types-BUYZxMco.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-CKJtfuap.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "../interface-RK7s4DQf.js";
 
 //#region src/peers/durable.d.ts
 

package/dist/peers/index.d.ts

@@ -1,10 +1,10 @@
-import "../schema-BPJJ9slm.js";
-import "../factory-BGezZgAP.js";
-import "../json-BZzd4eNj.js";
+import "../schema-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../protocol-ipDMUaRc.js";
-import "../types-BGM8eZe5.js";
-import { n as RpcPeerOptions, t as RpcPeer } from "../default-DOftsqyK.js";
-import "../interface-CuTDe_Pq.js";
+import "../protocol-DxoHWqMA.js";
+import "../types-BUYZxMco.js";
+import { n as RpcPeerOptions, t as RpcPeer } from "../default-CKJtfuap.js";
+import "../interface-RK7s4DQf.js";
 import { CallContext, DurableRpcPeer, DurableRpcPeerOptions } from "./durable.js";
 export { type CallContext, DurableRpcPeer, type DurableRpcPeerOptions, RpcPeer, type RpcPeerOptions };

package/dist/{protocol-ipDMUaRc.d.ts → protocol-DxoHWqMA.d.ts}

@@ -1,4 +1,4 @@
-import { a as WireCodec } from "./factory-BGezZgAP.js";
+import { a as WireCodec } from "./factory-CZioNF7N.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-B0zKtaPR.js";
+import "./factory-CZioNF7N.js";
+import "./json-1pVWk4mJ.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-DxoHWqMA.js";
 export { JsonProtocol, RpcError, RpcErrorCodes, RpcErrorSchema, RpcEvent, RpcEventSchema, RpcMessage, RpcMessageCodec, RpcMessageSchema, RpcProtocol, RpcRequest, RpcRequestSchema, RpcResponse, RpcResponseSchema, RpcWireCodec, WireInput, createProtocol };

package/dist/schema-B0zKtaPR.d.ts

@@ -0,0 +1,118 @@
+import * as z from "zod";
+import { LiteralUnion } from "type-fest";
+
+//#region src/schema.d.ts
+
+type StringKeys<T> = keyof T extends string ? keyof T : never;
+type LiteralString = "" | (string & Record<never, never>);
+type LiteralStringUnion<T> = LiteralUnion<T, string>;
+/**
+ * Method definition with input and output schemas
+ */
+interface MethodDef<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> {
+  _type: "method";
+  input: TInput;
+  output: TOutput;
+}
+type Method = (input: unknown) => unknown | Promise<unknown>;
+/**
+ * Event definition with data schema
+ */
+interface EventDef<TData extends z.ZodType = z.ZodType> {
+  _type: "event";
+  data: TData;
+}
+type Event = unknown;
+/**
+ * Define an RPC method with input/output schemas
+ *
+ * @param def - Object containing input and output Zod schemas
+ * @returns MethodDef with preserved type information
+ *
+ * @example
+ * ```ts
+ * const getUser = method({
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ name: z.string(), email: z.string() }),
+ * });
+ * ```
+ */
+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
+ *
+ * @param def - Object containing data Zod schema
+ * @returns EventDef with preserved type information
+ *
+ * @example
+ * ```ts
+ * const userCreated = event({
+ *   data: z.object({ id: z.string(), name: z.string() }),
+ * });
+ * ```
+ */
+declare function event<TData extends z.ZodType>(def: {
+  data: TData;
+}): EventDef<TData>;
+/**
+ * Schema definition containing methods and events
+ */
+interface RpcSchema {
+  methods?: Record<string, MethodDef>;
+  events?: Record<string, EventDef>;
+}
+interface RpcCollection {
+  methods?: Record<string, Method>;
+  events?: Record<string, Event>;
+}
+/**
+ * Infer the input type from a method definition
+ *
+ * @typeParam T - A MethodDef type to extract the input from
+ */
+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 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 extends EventDef> = z.infer<T["data"]>;
+/**
+ * Infer method signatures from a schema's methods
+ */
+type InferMethods<T extends RpcSchema["methods"]> = 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"]>> } : Record<string, Method>;
+/**
+ * Infer event emitter signatures from a schema's events
+ */
+type InferEvents<T extends RpcSchema["events"]> = T extends Record<string, EventDef> ? { [K in StringKeys<T>]: z.infer<T[K]["data"]> } : Record<string, Event>;
+/**
+ * Provider type - implements the local methods defined in a schema
+ */
+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["methods"]> = T extends Record<string, MethodDef> ? InferMethods<T> : {};
+/**
+ * Event handler type - handles incoming events
+ */
+interface EventHandler<T extends RpcSchema["events"], ExtraArgs extends any[] = []> {
+  <K$1 extends StringKeys<InferEvents<T>>>(...args: [...ExtraArgs, event: K$1, data: InferEvents<T>[K$1]]): void;
+}
+/**
+ * Event emitter type - emits outgoing events
+ */
+interface EventEmitter<T extends RpcSchema["events"], ExtraArgs extends any[] = []> {
+  <K$1 extends StringKeys<InferEvents<T>>>(...args: [event: K$1, data: InferEvents<T>[K$1], ...ExtraArgs]): void;
+}
+//#endregion
+export { RpcSchema as _, EventHandler as a, method as b, InferInput as c, LiteralString as d, LiteralStringUnion as f, RpcCollection as g, Provider as h, EventEmitter as i, InferMethods as l, MethodDef as m, Event as n, InferEventData as o, Method as p, EventDef as r, InferEvents as s, Driver as t, InferOutput as u, StringKeys as v, event as y };

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";
-export { Driver, EventDef, EventEmitter, EventHandler, InferEventData, InferEvents, InferInput, InferMethods, InferOutput, LiteralString, LiteralStringUnion, MethodDef, Provider, RpcSchema, StringKeys, event, method };
+import { _ as RpcSchema, a as EventHandler, b as method, c as InferInput, d as LiteralString, f as LiteralStringUnion, g as RpcCollection, h as Provider, i as EventEmitter, l as InferMethods, m as MethodDef, n as Event, o as InferEventData, p as Method, r as EventDef, s as InferEvents, t as Driver, u as InferOutput, v as StringKeys, y as event } from "./schema-B0zKtaPR.js";
+export { Driver, Event, EventDef, EventEmitter, EventHandler, InferEventData, InferEvents, InferInput, InferMethods, InferOutput, LiteralString, LiteralStringUnion, Method, MethodDef, Provider, RpcCollection, RpcSchema, StringKeys, event, method };

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

@@ -1,7 +1,7 @@
-import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider } from "./schema-BPJJ9slm.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 { _ as RpcSchema, h as Provider, s as InferEvents, v as StringKeys } from "./schema-B0zKtaPR.js";
+import { u as RpcProtocol } from "./protocol-DxoHWqMA.js";
+import { a as IRpcOptions, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, u as WebSocketServerOptions } from "./types-BUYZxMco.js";
+import { t as RpcPeer } from "./default-CKJtfuap.js";
 import { IMultiAdapterHooks, IMultiConnectionAdapter, MultiDriver } from "./adapters/types.js";
 
 //#region src/adapters/multi-peer.d.ts
@@ -15,7 +15,7 @@ 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 */
@@ -43,7 +43,7 @@ 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 */
@@ -115,7 +115,7 @@ declare abstract class MultiPeerBase<TLocalSchema extends RpcSchema, TRemoteSche
    * @param data - Event data matching the schema
    * @param ids - Optional array of peer IDs to emit to (broadcasts to all if omitted)
    */
-  emit<K extends StringKeys<TLocalSchema["events"]>>(event: K, data: TLocalSchema["events"] extends Record<string, EventDef> ? InferEventData<TLocalSchema["events"][K]> : never, ids?: string[]): void;
+  emit<K extends StringKeys<InferEvents<TLocalSchema["events"]>>>(event: K, data: InferEvents<TLocalSchema["events"]>[K], ids?: string[]): void;
   /**
    * Close a specific peer by ID
    *
@@ -148,7 +148,7 @@ 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 (required when passing options instead of server instance) */

package/dist/{sql-BpEL9udW.d.ts → sql-xafn7bdx.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-CZioNF7N.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-RK7s4DQf.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-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.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-RK7s4DQf.js";
+import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-BxojNC-D.js";
+import { n as SqlPendingCallStorageOptions, t as SqlPendingCallStorage } from "../sql-xafn7bdx.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-B0zKtaPR.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-RK7s4DQf.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-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.js";
 import "../index-Be7jjS77.js";
-import "../interface-CuTDe_Pq.js";
-import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-BbN1TQZi.js";
+import "../interface-RK7s4DQf.js";
+import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-BxojNC-D.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-B0zKtaPR.js";
+import "../factory-CZioNF7N.js";
+import "../json-1pVWk4mJ.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-RK7s4DQf.js";
+import { i as SqlStorageCursor, n as SqlPendingCallStorageOptions, r as SqlStorage, t as SqlPendingCallStorage } from "../sql-xafn7bdx.js";
 export { SqlPendingCallStorage, SqlPendingCallStorageOptions, SqlStorage, SqlStorageCursor };

package/dist/{types-BGM8eZe5.d.ts → types-BUYZxMco.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, u as RpcProtocol } from "./protocol-ipDMUaRc.js";
+import { _ as RpcSchema, a as EventHandler, h as Provider, i as EventEmitter, m as MethodDef, r as EventDef } from "./schema-B0zKtaPR.js";
+import { g as WireInput, u as RpcProtocol } from "./protocol-DxoHWqMA.js";
 
 //#region src/types.d.ts
 
@@ -83,9 +83,9 @@ interface IRpcOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcS
  *
  * @typeParam TLocalSchema - Schema defining local methods
  */
-interface IMethodController<TLocalSchema extends RpcSchema> {
+interface IMethodController<TLocalMethods extends Record<string, MethodDef> | undefined> {
   /** Implementation of local methods */
-  readonly provider: Provider<TLocalSchema>;
+  readonly provider: Provider<TLocalMethods>;
 }
 /**
  * Interface for types that can emit and receive events
@@ -95,18 +95,18 @@ interface IMethodController<TLocalSchema extends RpcSchema> {
  * @typeParam EmitArgs - Additional arguments for emit (e.g., peer IDs)
  * @typeParam EventArgs - Additional arguments for event handler
  */
-interface IEventController<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema, EmitArgs extends any[] = [], EventArgs extends any[] = []> {
+interface IEventController<TLocalEvents extends Record<string, EventDef> | undefined, TRemoteEvents extends Record<string, EventDef> | undefined, EmitArgs extends any[] = [], EventArgs extends any[] = []> {
   /** Emit an event to the connected peer */
-  emit: EventEmitter<TLocalSchema, EmitArgs>;
+  emit: EventEmitter<TLocalEvents, EmitArgs>;
   /** Called when receiving an event from the connected peer */
-  onEvent?: EventHandler<TRemoteSchema, EventArgs>;
+  onEvent?: EventHandler<TRemoteEvents, EventArgs>;
 }
 /**
  * Base interface for RPC connections (1-1)
  *
  * Implemented by RpcPeer.
  */
-interface IRpcConnection<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema>, IEventController<TLocalSchema, TRemoteSchema> {
+interface IRpcConnection<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema["methods"]>, IEventController<TLocalSchema["events"], TRemoteSchema["events"]> {
   /** Timeout for RPC calls in ms */
   readonly timeout: number;
   /** Handle an incoming WebSocket message */

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-import "./schema-BPJJ9slm.js";
-import "./factory-BGezZgAP.js";
-import "./json-BZzd4eNj.js";
+import "./schema-B0zKtaPR.js";
+import "./factory-CZioNF7N.js";
+import "./json-1pVWk4mJ.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-BGM8eZe5.js";
+import "./protocol-DxoHWqMA.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-BUYZxMco.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.1.0",
+  "version": "1.1.2",
   "description": "Bidirectional RPC over WebSocket with Zod schema validation, TypeScript inference, and Cloudflare Durable Object support",
   "type": "module",
   "license": "MIT",

package/dist/schema-BPJJ9slm.d.ts

@@ -1,108 +0,0 @@
-import * as z from "zod";
-import { LiteralUnion } from "type-fest";
-
-//#region src/schema.d.ts
-
-type StringKeys<T> = keyof T extends string ? keyof T : never;
-type LiteralString = "" | (string & Record<never, never>);
-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> {
-  _type: "method";
-  input: TInput$1;
-  output: TOutput$1;
-}
-/**
- * Event definition with data schema
- */
-interface EventDef<TData$1 extends z.ZodType = z.ZodType> {
-  _type: "event";
-  data: TData$1;
-}
-/**
- * Define an RPC method with input/output schemas
- *
- * @param def - Object containing input and output Zod schemas
- * @returns MethodDef with preserved type information
- *
- * @example
- * ```ts
- * const getUser = method({
- *   input: z.object({ id: z.string() }),
- *   output: z.object({ name: z.string(), email: z.string() }),
- * });
- * ```
- */
-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>;
-/**
- * Define a fire-and-forget event with data schema
- *
- * @param def - Object containing data Zod schema
- * @returns EventDef with preserved type information
- *
- * @example
- * ```ts
- * const userCreated = event({
- *   data: z.object({ id: z.string(), name: z.string() }),
- * });
- * ```
- */
-declare function event<TData$1 extends z.ZodType>(def: {
-  data: TData$1;
-}): EventDef<TData$1>;
-/**
- * Schema definition containing methods and events
- */
-interface RpcSchema {
-  methods?: Record<string, MethodDef>;
-  events?: Record<string, EventDef>;
-}
-/**
- * Infer the input type from a method definition
- *
- * @typeParam T - A MethodDef type to extract the input from
- */
-type InferInput<T> = T extends MethodDef<infer TInput, z.ZodType> ? z.input<TInput> : never;
-/**
- * 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * 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;
-/**
- * Provider type - implements the local methods defined in a schema
- */
-type Provider<T extends RpcSchema> = InferMethods<T>;
-/**
- * Driver type - proxy to call remote methods defined in a schema
- */
-type Driver<T extends RpcSchema> = 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;
-/**
- * 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;
-//#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 };