@igoforth/ws-rpc 1.0.0

package/dist/server-zTjpJpoX.d.ts

@@ -0,0 +1,209 @@
+import { a as InferEventData, h as StringKeys, m as RpcSchema, n as EventDef, p as Provider } from "./schema-CN5HHHku.js";
+import { a as IRpcOptions, o as IWebSocket, r as IMinWebSocket, s as IWebSocketServer, u as WebSocketServerOptions } from "./types-Be-qmQu0.js";
+import { t as RpcPeer } from "./default-xDNNMrg0.js";
+import { IMultiAdapterHooks, IMultiConnectionAdapter, MultiDriver } from "./adapters/types.js";
+
+//#region src/adapters/multi-peer.d.ts
+
+/**
+ * Options for creating a MultiPeerBase subclass
+ */
+interface MultiPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
+  /** Schema defining local methods we implement */
+  localSchema: TLocalSchema;
+  /** Schema defining remote methods we can call */
+  remoteSchema: TRemoteSchema;
+  /** Implementation of local methods */
+  provider: Provider<TLocalSchema>;
+  /** Default timeout for RPC calls in ms */
+  timeout?: number;
+  /** Lifecycle hooks */
+  hooks?: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
+}
+/**
+ * Abstract base class for multi-peer adapters
+ *
+ * Provides shared functionality for managing multiple RPC peers:
+ * - Driver for calling methods on multiple peers
+ * - Broadcast emit to all peers
+ * - Peer lookup by ID
+ * - Connection count/IDs
+ *
+ * @typeParam TLocalSchema - Schema for methods/events this side provides
+ * @typeParam TRemoteSchema - Schema for methods/events the remote side provides
+ * @typeParam TConnection - Connection type (IWebSocket, WebSocket, etc.)
+ */
+declare abstract class MultiPeerBase<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema, TConnection> implements IMultiConnectionAdapter<TLocalSchema, TRemoteSchema> {
+  protected readonly peers: Map<TConnection, RpcPeer<TLocalSchema, TRemoteSchema>>;
+  /** Local schema */
+  readonly localSchema: TLocalSchema;
+  /** Remote schema */
+  readonly remoteSchema: TRemoteSchema;
+  /** Implementation of local methods */
+  readonly provider: Provider<TLocalSchema>;
+  /** Default timeout for RPC calls */
+  readonly timeout: number;
+  /** Lifecycle hooks */
+  readonly hooks: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
+  constructor(options: MultiPeerOptions<TLocalSchema, TRemoteSchema>);
+  /**
+   * Create an RPC peer for a WebSocket connection.
+   * Subclasses can override to customize peer creation.
+   */
+  protected createPeer(ws: IMinWebSocket): RpcPeer<TLocalSchema, TRemoteSchema>;
+  /**
+   * Find peer by WebSocket (internal helper for event routing)
+   */
+  private findPeerByWs;
+  /**
+   * Add a peer (called by subclass when connection established)
+   */
+  protected addPeer(connection: TConnection, peer: RpcPeer<TLocalSchema, TRemoteSchema>): void;
+  /**
+   * Remove a peer (called by subclass when connection closes)
+   */
+  protected removePeer(connection: TConnection): RpcPeer<TLocalSchema, TRemoteSchema> | null;
+  /**
+   * Get peer by connection object
+   */
+  getPeerFor(connection: TConnection): RpcPeer<TLocalSchema, TRemoteSchema> | null;
+  /**
+   * Get peer by ID
+   */
+  getPeer(id: string): RpcPeer<TLocalSchema, TRemoteSchema> | null;
+  /**
+   * Find peer entry by ID (internal - includes connection)
+   */
+  protected findPeerEntry(id: string): {
+    peer: RpcPeer<TLocalSchema, TRemoteSchema>;
+    connection: TConnection;
+  } | null;
+  /**
+   * Get all peers
+   */
+  getPeers(): IterableIterator<RpcPeer<TLocalSchema, TRemoteSchema>>;
+  /**
+   * Get all open peer entries (internal)
+   */
+  protected getOpenEntries(): Array<{
+    peer: RpcPeer<TLocalSchema, TRemoteSchema>;
+    connection: TConnection;
+  }>;
+  /**
+   * Get count of open connections
+   */
+  getConnectionCount(): number;
+  /**
+   * Get all open peer IDs
+   */
+  getConnectionIds(): string[];
+  /**
+   * Driver for calling remote methods on connected peers
+   *
+   * @returns MultiDriver proxy for calling methods on all or specific peers
+   */
+  get driver(): MultiDriver<TRemoteSchema>;
+  /**
+   * Emit an event to connected peers
+   *
+   * @param event - Event name from local schema
+   * @param data - Event data matching the schema
+   * @param ids - Optional array of peer IDs to emit to (broadcasts to all if omitted)
+   */
+  emit<K extends StringKeys<TLocalSchema["events"]>>(event: K, data: TLocalSchema["events"] extends Record<string, EventDef> ? InferEventData<TLocalSchema["events"][K]> : never, ids?: string[]): void;
+  /**
+   * Close a specific peer by ID
+   *
+   * @param id - Peer ID to close
+   * @returns true if peer was found and closed, false otherwise
+   */
+  closePeer(id: string): boolean;
+  /**
+   * Close all peers
+   */
+  protected closeAll(): void;
+  /**
+   * Create a driver proxy for calling remote methods on multiple peers
+   */
+  private createMultiDriver;
+  /**
+   * Call a method on multiple peers with timeout handling
+   *
+   * @param method - Method name to call
+   * @param input - Method input parameters
+   * @param options - Call options including target peer IDs and timeout
+   * @returns Array of results from each peer (success or error)
+   */
+  private callMethod;
+}
+//#endregion
+//#region src/adapters/server.d.ts
+/**
+ * Options for creating an RpcServer
+ */
+interface RpcServerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema> {
+  /** Implementation of local methods */
+  provider: Provider<TLocalSchema>;
+  /** WebSocket server instance or options to create one */
+  wss: IWebSocketServer | WebSocketServerOptions;
+  /** WebSocket server constructor (defaults to require('ws').WebSocketServer) */
+  WebSocketServer?: new (options: WebSocketServerOptions) => IWebSocketServer;
+  /** Lifecycle hooks */
+  hooks?: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
+}
+/**
+ * RPC Server
+ *
+ * Manages WebSocket server and client connections with RPC capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { WebSocketServer } from "ws";
+ * import { RpcServer } from "@igoforth/ws-rpc/adapters/server";
+ *
+ * const server = new RpcServer({
+ *   wss: { port: 8080 },
+ *   WebSocketServer,
+ *   localSchema: ServerSchema,
+ *   remoteSchema: ClientSchema,
+ *   provider: {
+ *     getUser: async ({ id }) => ({ name: "John", email: "john@example.com" }),
+ *   },
+ *   hooks: {
+ *     onConnect: (peer) => {
+ *       console.log(`Client ${peer.id} connected`);
+ *       peer.driver.ping({}).then(console.log);
+ *     },
+ *     onDisconnect: (peer) => console.log(`Client ${peer.id} disconnected`),
+ *   },
+ * });
+ *
+ * // Emit to all clients
+ * server.emit("orderUpdated", { orderId: "123", status: "shipped" });
+ *
+ * // Graceful shutdown
+ * process.on("SIGTERM", () => server.close());
+ * ```
+ */
+declare class RpcServer<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends MultiPeerBase<TLocalSchema, TRemoteSchema, IWebSocket> {
+  private readonly wss;
+  constructor(options: RpcServerOptions<TLocalSchema, TRemoteSchema>);
+  private handleConnection;
+  /**
+   * Close a peer connection with WebSocket close code/reason
+   *
+   * @param id - Peer ID to close
+   * @param code - WebSocket close code (default: 1000)
+   * @param reason - Close reason message (default: "Server disconnect")
+   * @returns true if peer was found and closed, false otherwise
+   */
+  closePeer(id: string, code?: number, reason?: string): boolean;
+  /**
+   * Close the server and all client connections
+   *
+   * @param callback - Optional callback invoked when server is closed
+   */
+  close(callback?: (err?: Error) => void): void;
+}
+//#endregion
+export { RpcServerOptions as n, MultiPeerBase as r, RpcServer as t };

package/dist/sql-CCjc6Bid.js

@@ -0,0 +1,142 @@
+import { n as createJsonCodec } from "./json-Bshec-bZ.js";
+import * as z from "zod";
+
+//#region src/storage/sql.ts
+/**
+* SQL Pending Call Storage
+*
+* Synchronous storage implementation using Durable Object SQL storage.
+* Calls are persisted to SQLite and survive hibernation.
+*/
+/**
+* Table name for pending calls
+*/
+const TABLE_NAME = "_rpc_pending_calls";
+/**
+* Default codec for params serialization (JSON)
+*/
+const defaultParamsCodec = createJsonCodec(z.unknown());
+/**
+* SQL-backed pending call storage for Durable Objects
+*
+* Uses synchronous SQLite operations available in DO context.
+*/
+var SqlPendingCallStorage = class {
+	mode = "sync";
+	sql;
+	paramsCodec;
+	initialized = false;
+	/**
+	* Create a SQL-backed pending call storage
+	*
+	* @param sql - Durable Object SQL storage instance
+	* @param options - Optional configuration including custom params codec
+	*/
+	constructor(sql, options) {
+		this.sql = sql;
+		this.paramsCodec = options?.paramsCodec ?? defaultParamsCodec;
+	}
+	/**
+	* Ensure table exists (lazy initialization)
+	*/
+	ensureTable() {
+		if (this.initialized) return;
+		this.sql.exec(`
+			CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (
+				id TEXT PRIMARY KEY NOT NULL,
+				method TEXT NOT NULL,
+				params TEXT NOT NULL,
+				callback TEXT NOT NULL,
+				sent_at INTEGER NOT NULL,
+				timeout_at INTEGER NOT NULL
+			)
+		`);
+		this.sql.exec(`
+			CREATE INDEX IF NOT EXISTS idx_${TABLE_NAME}_timeout
+			ON ${TABLE_NAME}(timeout_at)
+		`);
+		this.initialized = true;
+	}
+	/**
+	* Save a pending call to storage
+	*
+	* @param call - The pending call to persist
+	*/
+	save(call) {
+		this.ensureTable();
+		const encodedParams = this.paramsCodec.encode(call.params);
+		this.sql.exec(`INSERT OR REPLACE INTO ${TABLE_NAME}
+			 (id, method, params, callback, sent_at, timeout_at)
+			 VALUES (?, ?, ?, ?, ?, ?)`, call.id, call.method, encodedParams, call.callback, call.sentAt, call.timeoutAt);
+	}
+	/**
+	* Get a pending call by ID
+	*
+	* @param id - The unique request ID
+	* @returns The pending call or null if not found
+	*/
+	get(id) {
+		this.ensureTable();
+		const row = [...this.sql.exec(`SELECT * FROM ${TABLE_NAME} WHERE id = ?`, id)][0];
+		if (!row) return null;
+		return this.rowToCall(row);
+	}
+	/**
+	* Delete a pending call by ID
+	*
+	* @param id - The unique request ID
+	* @returns true if the call existed and was deleted
+	*/
+	delete(id) {
+		this.ensureTable();
+		const exists = this.get(id) !== null;
+		if (exists) this.sql.exec(`DELETE FROM ${TABLE_NAME} WHERE id = ?`, id);
+		return exists;
+	}
+	/**
+	* List all calls that have exceeded their timeout
+	*
+	* @param before - Unix timestamp (ms); returns calls with timeoutAt <= before
+	* @returns Array of expired pending calls ordered by timeout
+	*/
+	listExpired(before) {
+		this.ensureTable();
+		return [...this.sql.exec(`SELECT * FROM ${TABLE_NAME} WHERE timeout_at <= ? ORDER BY timeout_at ASC`, before)].map((row) => this.rowToCall(row));
+	}
+	/**
+	* List all pending calls
+	*
+	* @returns Array of all pending calls ordered by sent time
+	*/
+	listAll() {
+		this.ensureTable();
+		return [...this.sql.exec(`SELECT * FROM ${TABLE_NAME} ORDER BY sent_at ASC`)].map((row) => this.rowToCall(row));
+	}
+	/**
+	* Delete all pending calls
+	*/
+	clear() {
+		this.ensureTable();
+		this.sql.exec(`DELETE FROM ${TABLE_NAME}`);
+	}
+	/**
+	* Convert a database row to a PendingCall
+	*
+	* @param row - Database row with call data
+	* @returns Deserialized pending call
+	*/
+	rowToCall(row) {
+		const params = this.paramsCodec.decode(row.params);
+		return {
+			id: row.id,
+			method: row.method,
+			params,
+			callback: row.callback,
+			sentAt: row.sent_at,
+			timeoutAt: row.timeout_at
+		};
+	}
+};
+
+//#endregion
+export { SqlPendingCallStorage as t };

package/dist/sql-DPmHOeZy.d.ts

@@ -0,0 +1,131 @@
+import { i as StringCodec } from "./factory-C1v0AEHY.js";
+import { i as PendingCall, s as SyncPendingCallStorage } from "./interface-C4S-WCqW.js";
+
+//#region src/storage/sql.d.ts
+
+/**
+ * SQL storage value types (matches Cloudflare SqlStorageValue)
+ */
+type SqlStorageValue = ArrayBuffer | string | number | null;
+/**
+ * Cursor returned by SqlStorage.exec()
+ *
+ * Compatible with Cloudflare's SqlStorageCursor.
+ */
+interface SqlStorageCursor<T extends Record<string, SqlStorageValue>> extends Iterable<T> {
+  next(): {
+    done?: false;
+    value: T;
+  } | {
+    done: true;
+    value?: never;
+  };
+  toArray(): T[];
+  one(): T;
+  readonly rowsRead: number;
+  readonly rowsWritten: number;
+}
+/**
+ * Minimal SqlStorage interface for Durable Object SQL
+ *
+ * Compatible with `DurableObjectState.storage.sql` in Cloudflare Workers.
+ */
+interface SqlStorage {
+  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: unknown[]): SqlStorageCursor<T>;
+}
+/**
+ * Options for SQL pending call storage
+ */
+interface SqlPendingCallStorageOptions {
+  /**
+   * Codec for serializing/deserializing params
+   *
+   * Use a custom codec to support additional JavaScript types like
+   * Date, Map, Set, BigInt, etc.
+   *
+   * @example
+   * ```ts
+   * import superjson from "superjson";
+   * import { createStringCodecFactory } from "@igoforth/ws-rpc/codecs";
+   *
+   * const superJsonCodec = createStringCodecFactory(
+   *   superjson.stringify,
+   *   superjson.parse,
+   *   "superjson"
+   * );
+   *
+   * const storage = new SqlPendingCallStorage(sql, {
+   *   paramsCodec: superJsonCodec(z.unknown()),
+   * });
+   * ```
+   */
+  paramsCodec?: StringCodec;
+}
+/**
+ * SQL-backed pending call storage for Durable Objects
+ *
+ * Uses synchronous SQLite operations available in DO context.
+ */
+declare class SqlPendingCallStorage implements SyncPendingCallStorage {
+  readonly mode: "sync";
+  private readonly sql;
+  private readonly paramsCodec;
+  private initialized;
+  /**
+   * Create a SQL-backed pending call storage
+   *
+   * @param sql - Durable Object SQL storage instance
+   * @param options - Optional configuration including custom params codec
+   */
+  constructor(sql: SqlStorage, options?: SqlPendingCallStorageOptions);
+  /**
+   * Ensure table exists (lazy initialization)
+   */
+  private ensureTable;
+  /**
+   * Save a pending call to storage
+   *
+   * @param call - The pending call to persist
+   */
+  save(call: PendingCall): void;
+  /**
+   * Get a pending call by ID
+   *
+   * @param id - The unique request ID
+   * @returns The pending call or null if not found
+   */
+  get(id: string): PendingCall | null;
+  /**
+   * Delete a pending call by ID
+   *
+   * @param id - The unique request ID
+   * @returns true if the call existed and was deleted
+   */
+  delete(id: string): boolean;
+  /**
+   * List all calls that have exceeded their timeout
+   *
+   * @param before - Unix timestamp (ms); returns calls with timeoutAt <= before
+   * @returns Array of expired pending calls ordered by timeout
+   */
+  listExpired(before: number): PendingCall[];
+  /**
+   * List all pending calls
+   *
+   * @returns Array of all pending calls ordered by sent time
+   */
+  listAll(): PendingCall[];
+  /**
+   * Delete all pending calls
+   */
+  clear(): void;
+  /**
+   * Convert a database row to a PendingCall
+   *
+   * @param row - Database row with call data
+   * @returns Deserialized pending call
+   */
+  private rowToCall;
+}
+//#endregion
+export { SqlStorageCursor as i, SqlPendingCallStorageOptions as n, SqlStorage as r, SqlPendingCallStorage as t };

package/dist/storage/index.d.ts

@@ -0,0 +1,8 @@
+import "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.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-C4S-WCqW.js";
+import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-D1nGjzzH.js";
+import { n as SqlPendingCallStorageOptions, t as SqlPendingCallStorage } from "../sql-DPmHOeZy.js";
+export { type AsyncPendingCallStorage, type MaybePromise, MemoryPendingCallStorage, type MemoryPendingCallStorageOptions, type PendingCall, type PendingCallStorage, SqlPendingCallStorage, type SqlPendingCallStorageOptions, type StorageMode, type SyncPendingCallStorage };

package/dist/storage/index.js

@@ -0,0 +1,7 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import { t as MemoryPendingCallStorage } from "../memory-Bqb3KEVr.js";
+import { t as SqlPendingCallStorage } from "../sql-CCjc6Bid.js";
+
+export { MemoryPendingCallStorage, SqlPendingCallStorage };

package/dist/storage/interface.d.ts

@@ -0,0 +1,3 @@
+import "../schema-CN5HHHku.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-C4S-WCqW.js";
+export { AsyncPendingCallStorage, IContinuationHandler, MaybePromise, PendingCall, PendingCallStorage, StorageMode, SyncPendingCallStorage };

package/dist/storage/memory.d.ts

@@ -0,0 +1,7 @@
+import "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+import "../interface-C4S-WCqW.js";
+import { n as MemoryPendingCallStorageOptions, t as MemoryPendingCallStorage } from "../memory-D1nGjzzH.js";
+export { MemoryPendingCallStorage, MemoryPendingCallStorageOptions };

package/dist/storage/memory.js

@@ -0,0 +1,6 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import { t as MemoryPendingCallStorage } from "../memory-Bqb3KEVr.js";
+
+export { MemoryPendingCallStorage };

package/dist/storage/sql.d.ts

@@ -0,0 +1,7 @@
+import "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+import "../interface-C4S-WCqW.js";
+import { i as SqlStorageCursor, n as SqlPendingCallStorageOptions, r as SqlStorage, t as SqlPendingCallStorage } from "../sql-DPmHOeZy.js";
+export { SqlPendingCallStorage, SqlPendingCallStorageOptions, SqlStorage, SqlStorageCursor };

package/dist/storage/sql.js

@@ -0,0 +1,6 @@
+import "../factory-3ziwTuZe.js";
+import "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+import { t as SqlPendingCallStorage } from "../sql-CCjc6Bid.js";
+
+export { SqlPendingCallStorage };

package/dist/types-Be-qmQu0.d.ts

@@ -0,0 +1,111 @@
+import { i as EventHandler, m as RpcSchema, p as Provider, r as EventEmitter } from "./schema-CN5HHHku.js";
+import { g as WireInput } from "./protocol-DA84zrc2.js";
+
+//#region src/types.d.ts
+
+/**
+ * WebSocket ready state constants type
+ */
+interface WebSocketReadyState {
+  CONNECTING: 0;
+  OPEN: 1;
+  CLOSING: 2;
+  CLOSED: 3;
+}
+/**
+ * WebSocket ready states
+ */
+declare const WebSocketReadyState: WebSocketReadyState;
+/**
+ * Minimal WebSocket interface for sending and receiving
+ */
+interface IMinWebSocket {
+  send(data: string | ArrayBuffer | Uint8Array): void;
+  close(code?: number, reason?: string): void;
+  readonly readyState: number;
+}
+/**
+ * Extended WebSocket interface with events
+ */
+interface IWebSocket extends IMinWebSocket {
+  send(data: string | ArrayBuffer): void;
+  addEventListener?(type: "open" | "close" | "message" | "error", listener: (event: unknown) => void): void;
+  removeEventListener?(type: "open" | "close" | "message" | "error", listener: (event: unknown) => void): void;
+  onopen?: ((event: unknown) => void) | null;
+  onclose?: ((event: unknown) => void) | null;
+  onmessage?: ((event: unknown) => void) | null;
+  onerror?: ((event: unknown) => void) | null;
+}
+/**
+ * WebSocket constructor options (Bun-compatible)
+ */
+interface WebSocketOptions {
+  protocols?: string | string[];
+  headers?: Record<string, string>;
+}
+/**
+ * Minimal WebSocket server interface
+ */
+interface IWebSocketServer {
+  on(event: "connection", listener: (ws: IWebSocket) => void): this;
+  on(event: "close", listener: () => void): this;
+  on(event: "error", listener: (error: Error) => void): this;
+  close(callback?: (err?: Error) => void): void;
+}
+/**
+ * WebSocket server constructor options
+ */
+interface WebSocketServerOptions {
+  port?: number;
+  host?: string;
+  path?: string;
+  server?: unknown;
+  noServer?: boolean;
+}
+/**
+ * Base RPC Options used across Peers and Adapters
+ */
+interface IRpcOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
+  /** Schema defining local methods we implement */
+  readonly localSchema: TLocalSchema;
+  /** Schema defining remote methods we can call */
+  readonly remoteSchema: TRemoteSchema;
+  /** Default timeout for RPC calls in ms */
+  readonly timeout?: number;
+}
+/**
+ * Interface for types that provide RPC method implementations
+ *
+ * @typeParam TLocalSchema - Schema defining local methods
+ */
+interface IMethodController<TLocalSchema extends RpcSchema> {
+  /** Implementation of local methods */
+  readonly provider: Provider<TLocalSchema>;
+}
+/**
+ * Interface for types that can emit and receive events
+ *
+ * @typeParam TLocalSchema - Schema defining local events we can emit
+ * @typeParam TRemoteSchema - Schema defining remote events we receive
+ * @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[] = []> {
+  /** Emit an event to the connected peer */
+  emit: EventEmitter<TLocalSchema, EmitArgs>;
+  /** Called when receiving an event from the connected peer */
+  onEvent?: EventHandler<TRemoteSchema, 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> {
+  /** Timeout for RPC calls in ms */
+  readonly timeout: number;
+  /** Handle an incoming WebSocket message */
+  handleMessage(data: WireInput): void;
+}
+//#endregion
+export { IRpcOptions as a, WebSocketOptions as c, IRpcConnection as i, WebSocketReadyState as l, IMethodController as n, IWebSocket as o, IMinWebSocket as r, IWebSocketServer as s, IEventController as t, WebSocketServerOptions as u };

package/dist/types-D_psiH09.js

@@ -0,0 +1,13 @@
+//#region src/types.ts
+/**
+* WebSocket ready states
+*/
+const WebSocketReadyState = {
+	CONNECTING: 0,
+	OPEN: 1,
+	CLOSING: 2,
+	CLOSED: 3
+};
+
+//#endregion
+export { WebSocketReadyState as t };

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import "./schema-CN5HHHku.js";
+import "./factory-C1v0AEHY.js";
+import "./json-54Z2bIIs.js";
+import "./index-Be7jjS77.js";
+import "./protocol-DA84zrc2.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-Be-qmQu0.js";
+export { IEventController, IMethodController, IMinWebSocket, IRpcConnection, IRpcOptions, IWebSocket, IWebSocketServer, WebSocketOptions, WebSocketReadyState, WebSocketServerOptions };

package/dist/types.js

@@ -0,0 +1,3 @@
+import { t as WebSocketReadyState } from "./types-D_psiH09.js";
+
+export { WebSocketReadyState };

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
+export { type ReconnectOptions, calculateReconnectDelay, defaultReconnectOptions };

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+import { n as defaultReconnectOptions, t as calculateReconnectDelay } from "../reconnect-CGAA_1Gf.js";
+
+export { calculateReconnectDelay, defaultReconnectOptions };