@igoforth/ws-rpc 1.0.0

package/dist/peers/index.js

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

package/dist/protocol-DA84zrc2.d.ts

@@ -0,0 +1,211 @@
+import { a as WireCodec } from "./factory-C1v0AEHY.js";
+import * as z from "zod";
+
+//#region src/protocol.d.ts
+
+/**
+ * RPC Request - sent when calling a remote method
+ */
+declare const RpcRequestSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rpc:request">;
+  id: z.ZodString;
+  method: z.ZodString;
+  params: z.ZodUnknown;
+}, z.core.$strip>;
+type RpcRequest = z.infer<typeof RpcRequestSchema>;
+/**
+ * RPC Response - sent as success response to a request
+ */
+declare const RpcResponseSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rpc:response">;
+  id: z.ZodString;
+  result: z.ZodUnknown;
+}, z.core.$strip>;
+type RpcResponse = z.infer<typeof RpcResponseSchema>;
+/**
+ * RPC Error - sent when a request fails
+ */
+declare const RpcErrorSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rpc:error">;
+  id: z.ZodString;
+  code: z.ZodNumber;
+  message: z.ZodString;
+  data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type RpcError = z.infer<typeof RpcErrorSchema>;
+/**
+ * RPC Event - fire-and-forget event (no response expected)
+ */
+declare const RpcEventSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rpc:event">;
+  event: z.ZodString;
+  data: z.ZodUnknown;
+}, z.core.$strip>;
+type RpcEvent = z.infer<typeof RpcEventSchema>;
+/**
+ * Union of all RPC message types
+ */
+declare const RpcMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodLiteral<"rpc:request">;
+  id: z.ZodString;
+  method: z.ZodString;
+  params: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:response">;
+  id: z.ZodString;
+  result: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:error">;
+  id: z.ZodString;
+  code: z.ZodNumber;
+  message: z.ZodString;
+  data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:event">;
+  event: z.ZodString;
+  data: z.ZodUnknown;
+}, z.core.$strip>]>;
+type RpcMessage = z.infer<typeof RpcMessageSchema>;
+/**
+ * Standard RPC error codes (JSON-RPC 2.0 compatible)
+ */
+declare const RpcErrorCodes: {
+  readonly PARSE_ERROR: -32700;
+  readonly INVALID_REQUEST: -32600;
+  readonly METHOD_NOT_FOUND: -32601;
+  readonly INVALID_PARAMS: -32602;
+  readonly INTERNAL_ERROR: -32603;
+  readonly TIMEOUT: -32000;
+  readonly CONNECTION_CLOSED: -32001;
+  readonly VALIDATION_ERROR: -32002;
+};
+/**
+ * Default JSON codec for RPC messages
+ *
+ * Encodes RPC messages to JSON strings with validation on decode.
+ *
+ * @example
+ * ```ts
+ * // Encode a message
+ * const json = RpcMessageCodec.encode(createRequest("1", "ping", {}));
+ *
+ * // Decode and validate
+ * const message = RpcMessageCodec.decode(json);
+ * ```
+ */
+declare const RpcMessageCodec: z.ZodCodec<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodLiteral<"rpc:request">;
+  id: z.ZodString;
+  method: z.ZodString;
+  params: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:response">;
+  id: z.ZodString;
+  result: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:error">;
+  id: z.ZodString;
+  code: z.ZodNumber;
+  message: z.ZodString;
+  data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:event">;
+  event: z.ZodString;
+  data: z.ZodUnknown;
+}, z.core.$strip>]>>;
+/**
+ * Type alias for RPC wire codecs
+ *
+ * Wire codecs can encode to string (text frames) or Uint8Array (binary frames).
+ */
+type RpcWireCodec = WireCodec<typeof RpcMessageSchema>;
+/**
+ * Wire data type - inferred from codec
+ */
+type WireDataOf<T extends RpcWireCodec> = T extends z.ZodCodec<infer A> ? A extends z.ZodType<infer V> ? V : never : never;
+/**
+ * Wire input types accepted by decode methods
+ *
+ * Includes Node.js ws library's RawData type (Buffer | ArrayBuffer | Buffer[])
+ * for seamless integration with the ws package.
+ */
+type WireInput = string | ArrayBuffer | Uint8Array | Uint8Array[];
+/**
+ * Protocol interface returned by createProtocol
+ */
+interface RpcProtocol<TWire extends RpcWireCodec = RpcWireCodec> {
+  /** The underlying codec */
+  readonly codec: TWire;
+  /** Create and encode an RPC request */
+  createRequest(id: string, method: string, params: unknown): WireDataOf<TWire>;
+  /** Create and encode an RPC response */
+  createResponse(id: string, result: unknown): WireDataOf<TWire>;
+  /** Create and encode an RPC error */
+  createError(id: string, code: number, message: string, data?: unknown): WireDataOf<TWire>;
+  /** Create and encode an RPC event */
+  createEvent(event: string, data: unknown): WireDataOf<TWire>;
+  /**
+   * Decode wire data to an RPC message (throws on invalid)
+   *
+   * Accepts string, ArrayBuffer, Uint8Array (including Node.js Buffer),
+   * or Uint8Array[] (for ws library's fragmented messages).
+   */
+  decodeMessage(data: WireInput): RpcMessage;
+  /**
+   * Safely decode wire data (returns null on invalid)
+   *
+   * Accepts string, ArrayBuffer, Uint8Array (including Node.js Buffer),
+   * or Uint8Array[] (for ws library's fragmented messages).
+   */
+  safeDecodeMessage(data: WireInput): RpcMessage | null;
+}
+/**
+ * Create a protocol instance with bound encode/decode functions
+ *
+ * @param codec - Wire codec for serialization (defaults to JSON)
+ * @returns Protocol object with pre-bound encode/decode methods
+ *
+ * @example
+ * ```ts
+ * // JSON protocol (default)
+ * const protocol = createProtocol();
+ *
+ * // MessagePack protocol
+ * import { createMsgpackCodec } from "@igoforth/ws-rpc/codecs/msgpack";
+ * const protocol = createProtocol(createMsgpackCodec(RpcMessageSchema));
+ *
+ * // Use in peer
+ * const wire = protocol.createRequest("1", "ping", {});
+ * ws.send(wire); // string or Uint8Array depending on codec
+ *
+ * const message = protocol.decodeMessage(event.data);
+ * ```
+ */
+declare function createProtocol<TWire extends RpcWireCodec = typeof RpcMessageCodec>(codec?: TWire): RpcProtocol<TWire>;
+/**
+ * Default JSON protocol instance
+ *
+ * Pre-configured with JSON codec for convenience.
+ */
+declare const JsonProtocol: RpcProtocol<z.ZodCodec<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodLiteral<"rpc:request">;
+  id: z.ZodString;
+  method: z.ZodString;
+  params: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:response">;
+  id: z.ZodString;
+  result: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:error">;
+  id: z.ZodString;
+  code: z.ZodNumber;
+  message: z.ZodString;
+  data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rpc:event">;
+  event: z.ZodString;
+  data: z.ZodUnknown;
+}, z.core.$strip>]>>>;
+//#endregion
+export { createProtocol as _, RpcEvent as a, RpcMessageCodec as c, RpcRequest as d, RpcRequestSchema as f, WireInput as g, RpcWireCodec as h, RpcErrorSchema as i, RpcMessageSchema as l, RpcResponseSchema as m, RpcError as n, RpcEventSchema as o, RpcResponse as p, RpcErrorCodes as r, RpcMessage as s, JsonProtocol as t, RpcProtocol as u };

package/dist/protocol-_mpoOPp6.js

@@ -0,0 +1,192 @@
+import { i as isStringCodec } from "./factory-3ziwTuZe.js";
+import { n as createJsonCodec } from "./json-Bshec-bZ.js";
+import * as z from "zod";
+
+//#region src/protocol.ts
+/**
+* Wire Protocol Definitions
+*
+* Defines the message format for bidirectional RPC over WebSocket.
+* Messages can be JSON-encoded (string) or binary-encoded (Uint8Array).
+*/
+/**
+* RPC Request - sent when calling a remote method
+*/
+const RpcRequestSchema = z.object({
+	type: z.literal("rpc:request"),
+	id: z.string(),
+	method: z.string(),
+	params: z.unknown()
+});
+/**
+* RPC Response - sent as success response to a request
+*/
+const RpcResponseSchema = z.object({
+	type: z.literal("rpc:response"),
+	id: z.string(),
+	result: z.unknown()
+});
+/**
+* RPC Error - sent when a request fails
+*/
+const RpcErrorSchema = z.object({
+	type: z.literal("rpc:error"),
+	id: z.string(),
+	code: z.number(),
+	message: z.string(),
+	data: z.unknown().optional()
+});
+/**
+* RPC Event - fire-and-forget event (no response expected)
+*/
+const RpcEventSchema = z.object({
+	type: z.literal("rpc:event"),
+	event: z.string(),
+	data: z.unknown()
+});
+/**
+* Union of all RPC message types
+*/
+const RpcMessageSchema = z.union([
+	RpcRequestSchema,
+	RpcResponseSchema,
+	RpcErrorSchema,
+	RpcEventSchema
+]);
+/**
+* Standard RPC error codes (JSON-RPC 2.0 compatible)
+*/
+const RpcErrorCodes = {
+	PARSE_ERROR: -32700,
+	INVALID_REQUEST: -32600,
+	METHOD_NOT_FOUND: -32601,
+	INVALID_PARAMS: -32602,
+	INTERNAL_ERROR: -32603,
+	TIMEOUT: -32e3,
+	CONNECTION_CLOSED: -32001,
+	VALIDATION_ERROR: -32002
+};
+/**
+* Default JSON codec for RPC messages
+*
+* Encodes RPC messages to JSON strings with validation on decode.
+*
+* @example
+* ```ts
+* // Encode a message
+* const json = RpcMessageCodec.encode(createRequest("1", "ping", {}));
+*
+* // Decode and validate
+* const message = RpcMessageCodec.decode(json);
+* ```
+*/
+const RpcMessageCodec = createJsonCodec(RpcMessageSchema);
+/**
+* Create a protocol instance with bound encode/decode functions
+*
+* @param codec - Wire codec for serialization (defaults to JSON)
+* @returns Protocol object with pre-bound encode/decode methods
+*
+* @example
+* ```ts
+* // JSON protocol (default)
+* const protocol = createProtocol();
+*
+* // MessagePack protocol
+* import { createMsgpackCodec } from "@igoforth/ws-rpc/codecs/msgpack";
+* const protocol = createProtocol(createMsgpackCodec(RpcMessageSchema));
+*
+* // Use in peer
+* const wire = protocol.createRequest("1", "ping", {});
+* ws.send(wire); // string or Uint8Array depending on codec
+*
+* const message = protocol.decodeMessage(event.data);
+* ```
+*/
+function createProtocol(codec = RpcMessageCodec) {
+	const isString = isStringCodec(codec);
+	const textDecoder = new TextDecoder();
+	const textEncoder = new TextEncoder();
+	/**
+	* Normalize input for the codec type.
+	* String codecs need string input (decode ArrayBuffer via TextDecoder).
+	* Binary codecs need Uint8Array input.
+	*
+	* Handles ws library's RawData (Buffer | ArrayBuffer | Buffer[]):
+	* - Buffer extends Uint8Array, so it's handled as Uint8Array
+	* - Buffer[] (fragmented messages) are concatenated
+	*/
+	const normalizeInput = (data) => {
+		if (Array.isArray(data)) {
+			const totalLength = data.reduce((sum, buf) => sum + buf.byteLength, 0);
+			const result = new Uint8Array(totalLength);
+			let offset = 0;
+			for (const buf of data) {
+				result.set(buf, offset);
+				offset += buf.byteLength;
+			}
+			return isString ? textDecoder.decode(result) : result;
+		}
+		if (isString) {
+			if (typeof data === "string") return data;
+			if (data instanceof ArrayBuffer) return textDecoder.decode(data);
+			return textDecoder.decode(data);
+		}
+		if (typeof data === "string") return textEncoder.encode(data);
+		if (data instanceof ArrayBuffer) return new Uint8Array(data);
+		return data;
+	};
+	return {
+		codec,
+		createRequest(id, method, params) {
+			return codec.encode({
+				type: "rpc:request",
+				id,
+				method,
+				params
+			});
+		},
+		createResponse(id, result) {
+			return codec.encode({
+				type: "rpc:response",
+				id,
+				result
+			});
+		},
+		createError(id, code, message, data) {
+			return codec.encode({
+				type: "rpc:error",
+				id,
+				code,
+				message,
+				data
+			});
+		},
+		createEvent(event, data) {
+			return codec.encode({
+				type: "rpc:event",
+				event,
+				data
+			});
+		},
+		decodeMessage(data) {
+			return codec.decode(normalizeInput(data));
+		},
+		safeDecodeMessage(data) {
+			try {
+				return codec.decode(normalizeInput(data));
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+/**
+* Default JSON protocol instance
+*
+* Pre-configured with JSON codec for convenience.
+*/
+const JsonProtocol = createProtocol(RpcMessageCodec);
+
+//#endregion
+export { RpcMessageCodec as a, RpcResponseSchema as c, RpcEventSchema as i, createProtocol as l, RpcErrorCodes as n, RpcMessageSchema as o, RpcErrorSchema as r, RpcRequestSchema as s, JsonProtocol as t };

package/dist/protocol.d.ts

@@ -0,0 +1,6 @@
+import "./schema-CN5HHHku.js";
+import "./factory-C1v0AEHY.js";
+import "./json-54Z2bIIs.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-DA84zrc2.js";
+export { JsonProtocol, RpcError, RpcErrorCodes, RpcErrorSchema, RpcEvent, RpcEventSchema, RpcMessage, RpcMessageCodec, RpcMessageSchema, RpcProtocol, RpcRequest, RpcRequestSchema, RpcResponse, RpcResponseSchema, RpcWireCodec, WireInput, createProtocol };

package/dist/protocol.js

@@ -0,0 +1,6 @@
+import "./factory-3ziwTuZe.js";
+import "./json-Bshec-bZ.js";
+import "./codecs-BmYG2d_U.js";
+import { a as RpcMessageCodec, c as RpcResponseSchema, i as RpcEventSchema, l as createProtocol, n as RpcErrorCodes, o as RpcMessageSchema, r as RpcErrorSchema, s as RpcRequestSchema, t as JsonProtocol } from "./protocol-_mpoOPp6.js";
+
+export { JsonProtocol, RpcErrorCodes, RpcErrorSchema, RpcEventSchema, RpcMessageCodec, RpcMessageSchema, RpcRequestSchema, RpcResponseSchema, createProtocol };

package/dist/reconnect-CGAA_1Gf.js

@@ -0,0 +1,26 @@
+//#region src/utils/reconnect.ts
+/**
+* Default reconnection options
+*/
+const defaultReconnectOptions = {
+	initialDelay: 1e3,
+	maxDelay: 3e4,
+	backoffMultiplier: 2,
+	maxAttempts: 0,
+	jitter: .1
+};
+/**
+* Calculate delay for reconnection attempt with exponential backoff
+*
+* @param attempt - Reconnection attempt number (0-indexed)
+* @param options - Reconnection options including backoff multiplier and max delay
+* @returns Delay in milliseconds before the next reconnection attempt
+*/
+function calculateReconnectDelay(attempt, options) {
+	const baseDelay = Math.min(options.initialDelay * Math.pow(options.backoffMultiplier, attempt), options.maxDelay);
+	const jitter = baseDelay * options.jitter * (Math.random() * 2 - 1);
+	return Math.max(0, baseDelay + jitter);
+}
+
+//#endregion
+export { defaultReconnectOptions as n, calculateReconnectDelay as t };

package/dist/reconnect-DbcN0R_1.d.ts

@@ -0,0 +1,35 @@
+//#region src/utils/reconnect.d.ts
+/**
+ * Reconnection Utilities
+ *
+ * Exponential backoff with jitter for client-side reconnection.
+ */
+/**
+ * Options for client-side reconnection
+ */
+interface ReconnectOptions {
+  /** Initial delay before first reconnect attempt (ms) */
+  initialDelay?: number;
+  /** Maximum delay between reconnect attempts (ms) */
+  maxDelay?: number;
+  /** Multiplier for exponential backoff */
+  backoffMultiplier?: number;
+  /** Maximum number of reconnect attempts (0 = unlimited) */
+  maxAttempts?: number;
+  /** Jitter factor (0-1) to randomize delays */
+  jitter?: number;
+}
+/**
+ * Default reconnection options
+ */
+declare const defaultReconnectOptions: Required<ReconnectOptions>;
+/**
+ * Calculate delay for reconnection attempt with exponential backoff
+ *
+ * @param attempt - Reconnection attempt number (0-indexed)
+ * @param options - Reconnection options including backoff multiplier and max delay
+ * @returns Delay in milliseconds before the next reconnection attempt
+ */
+declare function calculateReconnectDelay(attempt: number, options: Required<ReconnectOptions>): number;
+//#endregion
+export { calculateReconnectDelay as n, defaultReconnectOptions as r, ReconnectOptions as t };

package/dist/schema-CN5HHHku.d.ts

@@ -0,0 +1,108 @@
+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.infer<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.infer<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]>) => 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 };

package/dist/schema.d.ts

@@ -0,0 +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-CN5HHHku.js";
+export { Driver, EventDef, EventEmitter, EventHandler, InferEventData, InferEvents, InferInput, InferMethods, InferOutput, LiteralString, LiteralStringUnion, MethodDef, Provider, RpcSchema, StringKeys, event, method };

package/dist/schema.js

@@ -0,0 +1,43 @@
+//#region src/schema.ts
+/**
+* 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() }),
+* });
+* ```
+*/
+function method(def) {
+	return {
+		_type: "method",
+		...def
+	};
+}
+/**
+* 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() }),
+* });
+* ```
+*/
+function event(def) {
+	return {
+		_type: "event",
+		...def
+	};
+}
+
+//#endregion
+export { event, method };