@firtoz/websocket-do 9.0.0 → 12.0.0

package/README.md

@@ -11,7 +11,7 @@ Type-safe WebSocket session management for Cloudflare Durable Objects with Hono
 ## Features
 
 - 🔒 **Type-safe** - Full TypeScript support with generic types for messages and session data
-- ✨ **Zod Validation** - Runtime message validation with `ZodWebSocketClient` and `ZodSession`
+- ✨ **Standard Schema validation** - Runtime message validation with `StandardSchemaWebSocketClient` and `StandardSchemaSession` (Zod, Valibot, ArkType, …)
 - 🌐 **WebSocket Management** - Built on Cloudflare Durable Objects for stateful WebSocket connections
 - 🎯 **Session-based** - Abstract session class for easy implementation of custom WebSocket logic
 - 🔄 **State Persistence** - Automatic serialization/deserialization of session data
@@ -34,10 +34,7 @@ This package requires the following peer dependencies:
 bun add hono @firtoz/hono-fetcher
 ```
 
-**For Zod validation features** (ZodWebSocketClient, ZodSession):
-```bash
-bun add zod msgpackr
-```
+**For schemas:** use any [Standard Schema v1](https://standardschema.dev/) library (e.g. Zod, Valibot). **`msgpackr`** is a normal dependency of this package (buffer / msgpack mode); you do not add it separately unless your bundler needs it hoisted.
 
 For TypeScript support, use `wrangler types` to generate accurate types from your `wrangler.jsonc`:
 
@@ -101,8 +98,8 @@ const chatSessionHandlers: BaseSessionHandlers<
     // Handle binary messages if needed
   },
 
-  handleClose: async () => {
-    console.log('Session closed');
+  handleClose: async (session) => {
+    console.log('Session closed', session.data);
   },
 };
 
@@ -140,8 +137,8 @@ class ChatSession extends BaseSession<
       handleBufferMessage: async (message) => {
         // Handle binary messages if needed
       },
-      handleClose: async () => {
-        console.log(`Session closed for user ${this.data.userId}`);
+      handleClose: async (session) => {
+        console.log(`Session closed for user ${session.data.userId}`);
       },
     });
   }
@@ -214,13 +211,13 @@ export default {
 };
 ```
 
-## ZodWebSocketClient (Type-Safe Client)
+## StandardSchemaWebSocketClient (Type-Safe Client)
 
-`ZodWebSocketClient` provides a type-safe WebSocket client with automatic Zod validation for both incoming and outgoing messages.
+`StandardSchemaWebSocketClient` provides a type-safe WebSocket client with automatic validation (Standard Schema v1) for both incoming and outgoing messages.
 
 ### Features
 
-- ✅ **Automatic validation** - All messages validated with Zod schemas
+- ✅ **Automatic validation** - All messages validated with your Standard Schema–compatible schemas
 - 🎯 **Full type inference** - TypeScript types automatically inferred from schemas
 - 📦 **Dual mode** - Supports both JSON and msgpack (buffer) serialization
 - 🔗 **DO Integration** - Works seamlessly with `honoDoFetcher` WebSocket connections
@@ -229,7 +226,7 @@ export default {
 ### Basic Usage
 
 ```typescript
-import { ZodWebSocketClient } from '@firtoz/websocket-do';
+import { StandardSchemaWebSocketClient } from '@firtoz/websocket-do';
 import { z } from 'zod';
 
 // Define your message schemas
@@ -249,8 +246,8 @@ type ServerMessage = z.infer<typeof ServerMessageSchema>;
 // Create WebSocket connection (regular or via honoDoFetcher)
 const ws = new WebSocket('wss://example.com/chat');
 
-// Wrap with ZodWebSocketClient
-const client = new ZodWebSocketClient({
+// Wrap with StandardSchemaWebSocketClient
+const client = new StandardSchemaWebSocketClient({
   webSocket: ws, // Can also use 'url' instead
   clientSchema: ClientMessageSchema,
   serverSchema: ServerMessageSchema,
@@ -272,7 +269,7 @@ Perfect for connecting to Durable Objects:
 
 ```typescript
 import { honoDoFetcherWithName } from '@firtoz/hono-fetcher';
-import { ZodWebSocketClient } from '@firtoz/websocket-do';
+import { StandardSchemaWebSocketClient } from '@firtoz/websocket-do';
 
 // 1. Connect to DO via honoDoFetcher
 const api = honoDoFetcherWithName(env.CHAT_ROOM, 'room-1');
@@ -281,8 +278,8 @@ const wsResp = await api.websocket({
   config: { autoAccept: false }, // Let client control acceptance
 });
 
-// 2. Wrap with ZodWebSocketClient for type safety!
-const client = new ZodWebSocketClient({
+// 2. Wrap with StandardSchemaWebSocketClient for type safety!
+const client = new StandardSchemaWebSocketClient({
   webSocket: wsResp.webSocket,
   clientSchema: ClientMessageSchema,
   serverSchema: ServerMessageSchema,
@@ -307,7 +304,7 @@ client.send({ type: 'chat', text: 'Hello from typed client!' });
 For better performance and smaller payloads, use buffer mode with msgpack:
 
 ```typescript
-const client = new ZodWebSocketClient({
+const client = new StandardSchemaWebSocketClient({
   webSocket: ws,
   clientSchema: ClientMessageSchema,
   serverSchema: ServerMessageSchema,
@@ -327,14 +324,16 @@ client.send({ type: 'chat', text: 'Efficient binary message!' });
 #### Constructor Options
 
 ```typescript
-interface ZodWebSocketClientOptions<TClientMessage, TServerMessage> {
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+interface StandardSchemaWebSocketClientOptions<TClientMessage, TServerMessage> {
   // Connection (provide one)
   url?: string;                    // Create new WebSocket
   webSocket?: WebSocket;           // Use existing WebSocket (e.g., from honoDoFetcher)
   
   // Schemas (required)
-  clientSchema: z.ZodType<TClientMessage>;
-  serverSchema: z.ZodType<TServerMessage>;
+  clientSchema: StandardSchemaV1<unknown, TClientMessage>;
+  serverSchema: StandardSchemaV1<unknown, TServerMessage>;
   
   // Serialization
   enableBufferMessages?: boolean;  // Use msgpack instead of JSON (default: false)
@@ -350,18 +349,18 @@ interface ZodWebSocketClientOptions<TClientMessage, TServerMessage> {
 
 #### Methods
 
-- `send(message: TClientMessage): void` - Send a validated message
+- `send(message: TClientMessage): Promise<void>` - Send a validated message (async Standard Schema validation)
 - `close(code?: number, reason?: string): void` - Close the connection
 - `waitForOpen(): Promise<void>` - Wait for connection to open
 
-## ZodSession (Validated Sessions)
+## StandardSchemaSession (Validated Sessions)
 
-`ZodSession` extends `BaseSession` with automatic Zod validation for incoming messages.
+`StandardSchemaSession` extends `BaseSession` with automatic validation for incoming messages.
 
 ### Basic Usage
 
 ```typescript
-import { ZodSession } from '@firtoz/websocket-do';
+import { StandardSchemaSession } from '@firtoz/websocket-do';
 import { z } from 'zod';
 
 // Define schemas
@@ -384,7 +383,7 @@ interface SessionData {
 }
 
 // Implement validated session
-class ChatSession extends ZodSession<
+class ChatSession extends StandardSchemaSession<
   SessionData,
   ServerMessage,
   ClientMessage,
@@ -393,7 +392,7 @@ class ChatSession extends ZodSession<
   constructor(
     websocket: WebSocket,
     sessions: Map<WebSocket, ChatSession>,
-    options: ZodSessionOptions<ClientMessage, ServerMessage>
+    options: StandardSchemaSessionOptions<ClientMessage, ServerMessage>
   ) {
     super(websocket, sessions, options, {
       createData: (ctx) => ({ name: 'Anonymous' }),
@@ -417,18 +416,18 @@ class ChatSession extends ZodSession<
         }
       },
 
-      handleClose: async () => {
-        console.log(`${this.data.name} disconnected`);
+      handleClose: async (session) => {
+        console.log(`${session.data.name} disconnected`);
       },
     });
   }
 }
 ```
 
-### Buffer Mode with ZodSession
+### Buffer Mode with StandardSchemaSession
 
 ```typescript
-class ChatSession extends ZodSession<...> {
+class ChatSession extends StandardSchemaSession<...> {
   constructor(
     websocket: WebSocket,
     sessions: Map<WebSocket, ChatSession>
@@ -443,8 +442,8 @@ class ChatSession extends ZodSession<...> {
         // Messages automatically decoded from msgpack
         // Handle validated message
       },
-      handleClose: async () => {
-        console.log('Session closed');
+      handleClose: async (session) => {
+        console.log('Session closed', session.data);
       },
     });
   }
@@ -521,13 +520,17 @@ constructor(
 
 ```typescript
 type BaseSessionHandlers<TData, TServerMessage, TClientMessage, TEnv> = {
-  createData: (ctx: Context<{ Bindings: TEnv }>) => TData;
+  createData?: (ctx: Context<{ Bindings: TEnv }>) => TData;
   handleMessage: (message: TClientMessage) => Promise<void>;
   handleBufferMessage: (message: ArrayBuffer) => Promise<void>;
-  handleClose: () => Promise<void>;
+  handleClose: (
+    session: BaseSession<TData, TServerMessage, TClientMessage, TEnv>,
+  ) => Promise<void>;
 };
 ```
 
+If `createData` is omitted, `startFresh` sets `data` to `{}` (use an empty `TData` such as `Record<string, never>`).
+
 #### Methods
 
 - `send(message: TServerMessage): void`
@@ -537,7 +540,7 @@ type BaseSessionHandlers<TData, TServerMessage, TClientMessage, TEnv> = {
   - Send message to all connected sessions
 
 - `startFresh(ctx: Context): void`
-  - Initialize new session (called automatically)
+  - Initialize new session (called automatically). Uses `createData` when provided; otherwise `{}`.
 
 - `resume(): void`
   - Resume existing session after hibernation (called automatically)
@@ -635,8 +638,8 @@ class GameSession extends BaseSession<GameData, ServerMsg, ClientMsg, Env> {
         // Handle buffer messages if needed
       },
 
-      handleClose: async () => {
-        console.log('Game session closed');
+      handleClose: async (session) => {
+        console.log('Game session closed', session.data);
       },
     });
   }
@@ -678,8 +681,8 @@ class MySession extends BaseSession<...> {
         // Handle buffer messages
       },
 
-      handleClose: async () => {
-        console.log('Session closed');
+      handleClose: async (session) => {
+        console.log('Session closed', session.data);
       },
     });
   }
@@ -693,22 +696,22 @@ This package exports the following:
 ### Classes
 - `BaseWebSocketDO` - Base class for WebSocket Durable Objects (composition-based)
 - `BaseSession` - Concrete session class with handler injection
-- `ZodWebSocketClient` - Type-safe WebSocket client with Zod validation
-- `ZodSession` - Concrete session class with Zod validation and handler injection
-- `ZodWebSocketDO` - Base class for WebSocket DOs with Zod validation
+- `StandardSchemaWebSocketClient` - Type-safe WebSocket client with Standard Schema validation
+- `StandardSchemaSession` - Concrete session class with validation and handler injection
+- `StandardSchemaWebSocketDO` - Base class for WebSocket DOs with Standard Schema sessions
 - `WebsocketWrapper` - Low-level WebSocket wrapper with typed attachments
 
 ### Types
 - `BaseSessionHandlers` - Handler interface for `BaseSession`
 - `BaseWebSocketDOOptions` - Options interface for `BaseWebSocketDO`
-- `ZodSessionHandlers` - Handler interface for `ZodSession`
-- `ZodSessionOptions` - Options interface for `ZodSession`
-- `ZodSessionOptionsOrFactory` - Options or factory function for `ZodSession`
-- `ZodWebSocketDOOptions` - Options interface for `ZodWebSocketDO`
-- `ZodWebSocketClientOptions` - Options interface for `ZodWebSocketClient`
+- `StandardSchemaSessionHandlers` - Handler interface for `StandardSchemaSession`
+- `StandardSchemaSessionOptions` - Options interface for `StandardSchemaSession`
+- `StandardSchemaSessionOptionsOrFactory` - Options or factory function for `StandardSchemaSession`
+- `StandardSchemaWebSocketDOOptions` - Options interface for `StandardSchemaWebSocketDO`
+- `StandardSchemaWebSocketClientOptions` - Options interface for `StandardSchemaWebSocketClient`
 
 ### Utilities
-- `zodMsgpack` - Msgpack encode/decode with Zod validation
+- `standardSchemaMsgpack` - Msgpack encode/decode with Standard Schema validation
 
 ## Complete Example
 
@@ -734,7 +737,7 @@ export type ClientMessage = z.infer<typeof ClientMessageSchema>;
 export type ServerMessage = z.infer<typeof ServerMessageSchema>;
 
 // do.ts - Server-side (Durable Object)
-import { BaseWebSocketDO, ZodSession, type ZodSessionOptions } from '@firtoz/websocket-do';
+import { BaseWebSocketDO, StandardSchemaSession, type StandardSchemaSessionOptions } from '@firtoz/websocket-do';
 import { ClientMessageSchema, ServerMessageSchema } from './schemas';
 
 interface SessionData {
@@ -742,11 +745,11 @@ interface SessionData {
   joinedAt: number;
 }
 
-class ChatSession extends ZodSession<SessionData, ServerMessage, ClientMessage, Env> {
+class ChatSession extends StandardSchemaSession<SessionData, ServerMessage, ClientMessage, Env> {
   constructor(
     websocket: WebSocket,
     sessions: Map<WebSocket, ChatSession>,
-    options: ZodSessionOptions<ClientMessage, ServerMessage>
+    options: StandardSchemaSessionOptions<ClientMessage, ServerMessage>
   ) {
     super(websocket, sessions, options, {
       createData: () => ({
@@ -775,8 +778,8 @@ class ChatSession extends ZodSession<SessionData, ServerMessage, ClientMessage,
         }
       },
 
-      handleClose: async () => {
-        console.log(`${this.data.name} disconnected`);
+      handleClose: async (session) => {
+        console.log(`${session.data.name} disconnected`);
       },
     });
   }
@@ -806,7 +809,7 @@ export class ChatRoomDO extends BaseWebSocketDO<ChatSession, Env> {
 }
 
 // client.ts - Client-side
-import { ZodWebSocketClient } from '@firtoz/websocket-do';
+import { StandardSchemaWebSocketClient } from '@firtoz/websocket-do';
 import { honoDoFetcherWithName } from '@firtoz/hono-fetcher';
 import { ClientMessageSchema, ServerMessageSchema } from './schemas';
 
@@ -818,8 +821,8 @@ async function connectToChat(env: Env, roomName: string) {
     config: { autoAccept: false },
   });
 
-  // 2. Wrap with ZodWebSocketClient
-  const client = new ZodWebSocketClient({
+  // 2. Wrap with StandardSchemaWebSocketClient
+  const client = new StandardSchemaWebSocketClient({
     webSocket: wsResp.webSocket,
     clientSchema: ClientMessageSchema,
     serverSchema: ServerMessageSchema,
@@ -868,8 +871,8 @@ This package includes comprehensive integration tests in a separate test package
 - ✅ Real-time WebSocket message exchange
 - ✅ WebSocket session management
 - ✅ Type-safe DO client integration
-- ✅ Zod validation in both JSON and msgpack modes
-- ✅ Integration between honoDoFetcher and ZodWebSocketClient
+- ✅ Standard Schema validation in both JSON and msgpack modes
+- ✅ Integration between honoDoFetcher and StandardSchemaWebSocketClient
 
 For detailed information about testing capabilities, example implementations, comprehensive test coverage, and setup instructions, see the [websocket-do-test](../../tests/websocket-do-test/) package.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@firtoz/websocket-do",
-	"version": "9.0.0",
+	"version": "12.0.0",
 	"description": "Type-safe WebSocket session management for Cloudflare Durable Objects with Hono integration",
 	"main": "./src/index.ts",
 	"module": "./src/index.ts",
@@ -11,10 +11,20 @@
 			"import": "./src/index.ts",
 			"require": "./src/index.ts"
 		},
-		"./zod-client": {
-			"types": "./src/ZodWebSocketClient.ts",
-			"import": "./src/ZodWebSocketClient.ts",
-			"require": "./src/ZodWebSocketClient.ts"
+		"./schema-client": {
+			"types": "./src/StandardSchemaWebSocketClient.ts",
+			"import": "./src/StandardSchemaWebSocketClient.ts",
+			"require": "./src/StandardSchemaWebSocketClient.ts"
+		},
+		"./rpc": {
+			"types": "./src/standardSchemaRpc.ts",
+			"import": "./src/standardSchemaRpc.ts",
+			"require": "./src/standardSchemaRpc.ts"
+		},
+		"./rpc-react": {
+			"types": "./src/standardSchemaRpcReact.ts",
+			"import": "./src/standardSchemaRpcReact.ts",
+			"require": "./src/standardSchemaRpcReact.ts"
 		}
 	},
 	"files": [
@@ -51,13 +61,18 @@
 	},
 	"peerDependencies": {
 		"@cloudflare/workers-types": "^4.20260329.1",
-		"@firtoz/hono-fetcher": "^2.5.0",
-		"hono": "^4.12.9"
+		"@firtoz/hono-fetcher": "^2.6.0",
+		"hono": "^4.12.9",
+		"react": ">=18.0.0"
 	},
-	"optionalDependencies": {
-		"msgpackr": "^1.11.9",
-		"react": "^19.2.4",
-		"zod": "^4.3.6"
+	"peerDependenciesMeta": {
+		"react": {
+			"optional": true
+		}
+	},
+	"dependencies": {
+		"@standard-schema/spec": "^1.1.0",
+		"msgpackr": "^1.11.9"
 	},
 	"engines": {
 		"node": ">=18.0.0"
@@ -68,6 +83,7 @@
 	"devDependencies": {
 		"@types/react": "^19.2.14",
 		"bun-types": "^1.3.11",
-		"typescript": "^6.0.2"
+		"typescript": "^6.0.2",
+		"zod": "^4.3.6"
 	}
 }

package/src/BaseSession.ts

@@ -53,14 +53,21 @@ export type SessionEnv<
 
 export type BaseSessionHandlers<
 	TData,
-	_TServerMessage,
+	TServerMessage,
 	TClientMessage,
 	TEnv extends object = Cloudflare.Env,
 > = {
-	createData: (ctx: Context<{ Bindings: TEnv }>) => TData;
+	/**
+	 * Per-connection state. If omitted, `startFresh` initializes `data` as `{}`
+	 * (use empty `TData`, e.g. `Record<string, never>`).
+	 */
+	createData?: (ctx: Context<{ Bindings: TEnv }>) => TData;
 	handleMessage: (message: TClientMessage) => Promise<void>;
 	handleBufferMessage: (message: ArrayBuffer) => Promise<void>;
-	handleClose: () => Promise<void>;
+	/** Called when this connection closes; `session` is this {@link BaseSession} instance. */
+	handleClose: (
+		session: BaseSession<TData, TServerMessage, TClientMessage, TEnv>,
+	) => Promise<void>;
 };
 
 export class BaseSession<
@@ -100,7 +107,10 @@ export class BaseSession<
 	}
 
 	public startFresh(ctx: Context<{ Bindings: TEnv }>) {
-		this.data = this.handlers.createData(ctx);
+		this.data =
+			this.handlers.createData !== undefined
+				? this.handlers.createData(ctx)
+				: ({} as TData);
 		this.wrapper.serializeAttachment(this.data);
 	}
 
@@ -137,6 +147,6 @@ export class BaseSession<
 	}
 
 	async handleClose(): Promise<void> {
-		return this.handlers.handleClose();
+		return this.handlers.handleClose(this);
 	}
 }

package/src/{ZodSession.ts → StandardSchemaSession.ts}

@@ -1,11 +1,12 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { Context } from "hono";
-import type { ZodType } from "zod";
 import { BaseSession } from "./BaseSession";
-import { zodMsgpack } from "./zodMsgpack";
+import { parseStandardSchema } from "./parseStandardSchema";
+import { standardSchemaMsgpack } from "./standardSchemaMsgpack";
 
-export type ZodSessionOptions<TClientMessage, TServerMessage> = {
-	clientSchema: ZodType<TClientMessage>;
-	serverSchema: ZodType<TServerMessage>;
+export type StandardSchemaSessionOptions<TClientMessage, TServerMessage> = {
+	clientSchema: StandardSchemaV1<unknown, TClientMessage>;
+	serverSchema: StandardSchemaV1<unknown, TServerMessage>;
 	serializeJson?: (value: unknown) => string;
 	deserializeJson?: (raw: string) => unknown;
 	enableBufferMessages?: boolean;
@@ -15,9 +16,9 @@ export type ZodSessionOptions<TClientMessage, TServerMessage> = {
 	) => Promise<void>;
 };
 
-export type ZodSessionHandlers<
+export type StandardSchemaSessionHandlers<
 	TData,
-	_TServerMessage,
+	TServerMessage,
 	TClientMessage,
 	TEnv extends object,
 > = {
@@ -27,27 +28,36 @@ export type ZodSessionHandlers<
 		error: unknown,
 		originalMessage: unknown,
 	) => Promise<void>;
-	handleClose: () => Promise<void>;
+	handleClose: (
+		session: StandardSchemaSession<TData, TServerMessage, TClientMessage, TEnv>,
+	) => Promise<void>;
 };
 
-export class ZodSession<
+export class StandardSchemaSession<
 	TData,
 	TServerMessage,
 	TClientMessage,
 	TEnv extends object = Cloudflare.Env,
 > extends BaseSession<TData, TServerMessage, TClientMessage, TEnv> {
-	private readonly clientCodec: ReturnType<typeof zodMsgpack<TClientMessage>>;
-	private readonly serverCodec: ReturnType<typeof zodMsgpack<TServerMessage>>;
+	private readonly clientCodec: ReturnType<
+		typeof standardSchemaMsgpack<TClientMessage>
+	>;
+	private readonly serverCodec: ReturnType<
+		typeof standardSchemaMsgpack<TServerMessage>
+	>;
 	protected readonly enableBufferMessages: boolean;
 
 	constructor(
 		websocket: WebSocket,
 		sessions: Map<
 			WebSocket,
-			ZodSession<TData, TServerMessage, TClientMessage, TEnv>
+			StandardSchemaSession<TData, TServerMessage, TClientMessage, TEnv>
+		>,
+		private readonly options: StandardSchemaSessionOptions<
+			TClientMessage,
+			TServerMessage
 		>,
-		private readonly options: ZodSessionOptions<TClientMessage, TServerMessage>,
-		private readonly zodHandlers: ZodSessionHandlers<
+		private readonly schemaHandlers: StandardSchemaSessionHandlers<
 			TData,
 			TServerMessage,
 			TClientMessage,
@@ -55,25 +65,33 @@ export class ZodSession<
 		>,
 	) {
 		super(websocket, sessions, {
-			createData: zodHandlers.createData,
+			createData: schemaHandlers.createData,
 			handleMessage: async (message) => {
 				return this._internalHandleMessage(message);
 			},
 			handleBufferMessage: async (message) => {
 				return this._internalHandleBufferMessage(message);
 			},
-			handleClose: async () => {
-				return zodHandlers.handleClose();
+			handleClose: async (
+				session: BaseSession<TData, TServerMessage, TClientMessage, TEnv>,
+			) => {
+				return schemaHandlers.handleClose(
+					session as StandardSchemaSession<
+						TData,
+						TServerMessage,
+						TClientMessage,
+						TEnv
+					>,
+				);
 			},
 		});
 
-		this.clientCodec = zodMsgpack(options.clientSchema);
-		this.serverCodec = zodMsgpack(options.serverSchema);
+		this.clientCodec = standardSchemaMsgpack(options.clientSchema);
+		this.serverCodec = standardSchemaMsgpack(options.serverSchema);
 		this.enableBufferMessages = options.enableBufferMessages ?? false;
 	}
 
 	public async handleRawMessage(rawMessage: string): Promise<void> {
-		// If buffer messages are enabled, reject string messages
 		if (this.enableBufferMessages) {
 			console.error(
 				"String messages not allowed when buffer messages are enabled",
@@ -86,17 +104,18 @@ export class ZodSession<
 
 		try {
 			const parsed = this.deserializeJson(rawMessage);
-			const validatedMessage = this.options.clientSchema.parse(parsed);
-			await this.zodHandlers.handleValidatedMessage(validatedMessage);
+			const validatedMessage = await parseStandardSchema(
+				this.options.clientSchema,
+				parsed,
+			);
+			await this.schemaHandlers.handleValidatedMessage(validatedMessage);
 		} catch (error) {
 			console.error("Invalid client message received:", error);
 			await this._internalHandleValidationError(error, rawMessage);
 		}
 	}
 
-	// Internal method used by the base class handlers
 	private async _internalHandleMessage(message: TClientMessage): Promise<void> {
-		// If buffer messages are enabled, reject JSON messages
 		if (this.enableBufferMessages) {
 			console.error(
 				"String messages not allowed when buffer messages are enabled",
@@ -108,48 +127,44 @@ export class ZodSession<
 		}
 
 		try {
-			// Validate the message using the client schema
-			const validatedMessage = this.options.clientSchema.parse(message);
-			await this.zodHandlers.handleValidatedMessage(validatedMessage);
+			const validatedMessage = await parseStandardSchema(
+				this.options.clientSchema,
+				message,
+			);
+			await this.schemaHandlers.handleValidatedMessage(validatedMessage);
 		} catch (error) {
 			console.error("Invalid client message received:", error);
 			await this._internalHandleValidationError(error, message);
 		}
 	}
 
-	// Internal method used by the base class handlers
 	private async _internalHandleBufferMessage(
 		buffer: ArrayBuffer,
 	): Promise<void> {
-		// If buffer messages are disabled, reject buffer messages
 		if (!this.enableBufferMessages) {
 			console.error(
 				"Buffer messages not allowed when buffer messages are disabled",
 			);
-			// We can't use sendProtocolError here because it would send JSON
-			// Just close the connection or ignore
 			return;
 		}
 
 		try {
 			const bytes = new Uint8Array(buffer);
-			const decodedMessage = this.clientCodec.decode(bytes);
-			await this.zodHandlers.handleValidatedMessage(decodedMessage);
+			const decodedMessage = await this.clientCodec.decode(bytes);
+			await this.schemaHandlers.handleValidatedMessage(decodedMessage);
 		} catch (error) {
 			console.error("Failed to decode buffer message:", error);
 			await this._internalHandleValidationError(error, buffer);
 		}
 	}
 
-	// Internal validation error handler
 	private async _internalHandleValidationError(
 		error: unknown,
 		originalMessage: unknown,
 	): Promise<void> {
-		if (this.zodHandlers.handleValidationError) {
-			await this.zodHandlers.handleValidationError(error, originalMessage);
+		if (this.schemaHandlers.handleValidationError) {
+			await this.schemaHandlers.handleValidationError(error, originalMessage);
 		} else {
-			// Default implementation logs and continues
 			console.error(
 				"Validation error:",
 				error,
@@ -159,50 +174,38 @@ export class ZodSession<
 		}
 	}
 
-	// Type-safe send method that automatically uses the correct format
 	public send(message: TServerMessage): void {
 		if (this.enableBufferMessages) {
-			this.sendBuffer(message);
+			void this.sendBufferAsync(message).catch((error: unknown) => {
+				console.error("Failed to encode buffer message:", error);
+			});
 		} else {
-			this.sendJson(message);
+			void this.sendJsonAsync(message).catch((error: unknown) => {
+				console.error("Invalid server message to send:", error);
+			});
 		}
 	}
 
-	// Explicitly send as JSON
-	private sendJson(message: TServerMessage): void {
-		try {
-			// Validate the message using the server schema
-			const validatedMessage = this.options.serverSchema.parse(message);
-
-			if (this.websocket.readyState !== WebSocket.OPEN) return;
-
-			this.websocket.send(this.serializeJson(validatedMessage));
-		} catch (error) {
-			console.error("Invalid server message to send:", error);
-		}
+	private async sendJsonAsync(message: TServerMessage): Promise<void> {
+		const validatedMessage = await parseStandardSchema(
+			this.options.serverSchema,
+			message,
+		);
+		if (this.websocket.readyState !== WebSocket.OPEN) return;
+		this.websocket.send(this.serializeJson(validatedMessage));
 	}
 
-	// Explicitly send as buffer using msgpack
-	private sendBuffer(message: TServerMessage): void {
-		try {
-			const encodedMessage = this.serverCodec.encode(message);
-
-			if (this.websocket.readyState !== WebSocket.OPEN) return;
-
-			this.websocket.send(encodedMessage);
-		} catch (error) {
-			console.error("Failed to encode buffer message:", error);
-		}
+	private async sendBufferAsync(message: TServerMessage): Promise<void> {
+		const encodedMessage = await this.serverCodec.encode(message);
+		if (this.websocket.readyState !== WebSocket.OPEN) return;
+		this.websocket.send(encodedMessage);
 	}
 
-	// Send a protocol error message (always as JSON for compatibility by default)
 	private async sendProtocolError(errorMessage: string): Promise<void> {
 		try {
-			// Use custom handler if provided, otherwise use default
 			if (this.options.sendProtocolError) {
 				await this.options.sendProtocolError(this.websocket, errorMessage);
 			} else {
-				// Default implementation: send a simple error object - no schema validation needed
 				if (this.websocket.readyState !== WebSocket.OPEN) return;
 				this.websocket.send(this.serializeJson({ error: errorMessage }));
 			}
@@ -223,13 +226,11 @@ export class ZodSession<
 			: JSON.parse(raw);
 	}
 
-	// Type-safe broadcast that validates server messages
-	// Automatically uses the correct format based on session configuration
 	public broadcast(message: TServerMessage, excludeSelf = false): void {
 		for (const session of this.sessions.values()) {
 			if (excludeSelf && session === this) continue;
-			if (session instanceof ZodSession) {
-				session.send(message); // send() automatically uses correct format
+			if (session instanceof StandardSchemaSession) {
+				session.send(message);
 			}
 		}
 	}

package/src/{ZodWebSocketClient.ts → StandardSchemaWebSocketClient.ts}

@@ -1,7 +1,11 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { pack, unpack } from "msgpackr";
-import type { ZodType } from "zod";
+import { parseStandardSchema } from "./parseStandardSchema";
 
-export interface ZodWebSocketClientOptions<TClientMessage, TServerMessage> {
+export interface StandardSchemaWebSocketClientOptions<
+	TClientMessage,
+	TServerMessage,
+> {
 	/**
 	 * URL to connect to (required if webSocket not provided)
 	 */
@@ -11,8 +15,8 @@ export interface ZodWebSocketClientOptions<TClientMessage, TServerMessage> {
 	 * Useful when getting a WebSocket from honoDoFetcher
 	 */
 	webSocket?: WebSocket;
-	clientSchema: ZodType<TClientMessage>;
-	serverSchema: ZodType<TServerMessage>;
+	clientSchema: StandardSchemaV1<unknown, TClientMessage>;
+	serverSchema: StandardSchemaV1<unknown, TServerMessage>;
 	serializeJson?: (value: unknown) => string;
 	deserializeJson?: (raw: string) => unknown;
 	enableBufferMessages?: boolean;
@@ -23,10 +27,10 @@ export interface ZodWebSocketClientOptions<TClientMessage, TServerMessage> {
 	onValidationError?: (error: Error, rawMessage: unknown) => void;
 }
 
-export class ZodWebSocketClient<TClientMessage, TServerMessage> {
+export class StandardSchemaWebSocketClient<TClientMessage, TServerMessage> {
 	private ws: WebSocket;
-	private readonly clientSchema: ZodType<TClientMessage>;
-	private readonly serverSchema: ZodType<TServerMessage>;
+	private readonly clientSchema: StandardSchemaV1<unknown, TClientMessage>;
+	private readonly serverSchema: StandardSchemaV1<unknown, TServerMessage>;
 	private readonly serializeJson: (value: unknown) => string;
 	private readonly deserializeJson: (raw: string) => unknown;
 	private readonly enableBufferMessages: boolean;
@@ -37,7 +41,10 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 	) => void;
 
 	constructor(
-		options: ZodWebSocketClientOptions<TClientMessage, TServerMessage>,
+		options: StandardSchemaWebSocketClientOptions<
+			TClientMessage,
+			TServerMessage
+		>,
 	) {
 		this.clientSchema = options.clientSchema;
 		this.serverSchema = options.serverSchema;
@@ -47,29 +54,24 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 		this.onMessageCallback = options.onMessage;
 		this.onValidationError = options.onValidationError;
 
-		// Use provided WebSocket or create new one from URL
 		if (options.webSocket) {
-			// Use existing WebSocket (e.g., from honoDoFetcher)
 			this.ws = options.webSocket;
 		} else if (options.url) {
-			// Create new WebSocket from URL
 			this.ws = new WebSocket(options.url);
 		} else {
 			throw new Error("Either 'url' or 'webSocket' must be provided");
 		}
 
-		// Set binary type for buffer messages
 		if (this.enableBufferMessages) {
 			this.ws.binaryType = "arraybuffer";
 		}
 
-		// Setup event handlers
 		this.ws.addEventListener("open", (event) => {
 			options.onOpen?.(event);
 		});
 
 		this.ws.addEventListener("message", (event) => {
-			this.handleMessage(event);
+			void this.handleMessageEvent(event);
 		});
 
 		this.ws.addEventListener("close", (event) => {
@@ -81,12 +83,11 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 		});
 	}
 
-	private handleMessage(event: MessageEvent): void {
+	private async handleMessageEvent(event: MessageEvent): Promise<void> {
 		try {
 			let parsedMessage: TServerMessage;
 
 			if (this.enableBufferMessages) {
-				// Buffer mode: expect ArrayBuffer
 				if (!(event.data instanceof ArrayBuffer)) {
 					console.error(
 						"Expected ArrayBuffer but received:",
@@ -99,11 +100,9 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 					return;
 				}
 
-				// Unpack and validate
 				const unpacked = unpack(new Uint8Array(event.data));
-				parsedMessage = this.serverSchema.parse(unpacked);
+				parsedMessage = await parseStandardSchema(this.serverSchema, unpacked);
 			} else {
-				// JSON mode: expect string
 				if (typeof event.data !== "string") {
 					console.error("Expected string but received:", typeof event.data);
 					this.onValidationError?.(
@@ -113,12 +112,10 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 					return;
 				}
 
-				// Parse and validate
 				const parsed = this.deserializeJson(event.data);
-				parsedMessage = this.serverSchema.parse(parsed);
+				parsedMessage = await parseStandardSchema(this.serverSchema, parsed);
 			}
 
-			// Call message handler
 			this.onMessageCallback?.(parsedMessage);
 		} catch (error) {
 			console.error("Failed to process message:", error);
@@ -130,51 +127,34 @@ export class ZodWebSocketClient<TClientMessage, TServerMessage> {
 	}
 
 	/**
-	 * Send a message (automatically encodes based on mode)
+	 * Send a message (automatically encodes based on mode).
 	 */
-	send(message: TClientMessage): void {
-		try {
-			// Validate message
-			const validatedMessage = this.clientSchema.parse(message);
+	async send(message: TClientMessage): Promise<void> {
+		const validatedMessage = await parseStandardSchema(
+			this.clientSchema,
+			message,
+		);
 
-			if (this.enableBufferMessages) {
-				// Encode as msgpack (ensure ArrayBufferView for WebSocket.send)
-				const packed = pack(validatedMessage);
-				this.ws.send(new Uint8Array(packed));
-			} else {
-				// Encode as JSON
-				this.ws.send(this.serializeJson(validatedMessage));
-			}
-		} catch (error) {
-			console.error("Failed to send message:", error);
-			throw error;
+		if (this.enableBufferMessages) {
+			const packed = pack(validatedMessage);
+			this.ws.send(new Uint8Array(packed));
+		} else {
+			this.ws.send(this.serializeJson(validatedMessage));
 		}
 	}
 
-	/**
-	 * Close the WebSocket connection
-	 */
 	close(code?: number, reason?: string): void {
 		this.ws.close(code, reason);
 	}
 
-	/**
-	 * Get the current WebSocket ready state
-	 */
 	get readyState(): number {
 		return this.ws.readyState;
 	}
 
-	/**
-	 * Get the underlying WebSocket instance (use with caution)
-	 */
 	get socket(): WebSocket {
 		return this.ws;
 	}
 
-	/**
-	 * Wait for the connection to open
-	 */
 	async waitForOpen(): Promise<void> {
 		if (this.ws.readyState === WebSocket.OPEN) {
 			return;

package/src/{ZodWebSocketDO.ts → StandardSchemaWebSocketDO.ts}

@@ -5,62 +5,65 @@ import type {
 	SessionServerMessage,
 } from "./BaseSession";
 import { BaseWebSocketDO } from "./BaseWebSocketDO";
-import type { ZodSession, ZodSessionOptions } from "./ZodSession";
+import type {
+	StandardSchemaSession,
+	StandardSchemaSessionOptions,
+} from "./StandardSchemaSession";
 
-export type ZodSessionOptionsOrFactory<
+export type StandardSchemaSessionOptionsOrFactory<
 	TClientMessage,
 	TServerMessage,
 	TEnv extends Cloudflare.Env = Cloudflare.Env,
 > =
-	| ZodSessionOptions<TClientMessage, TServerMessage>
+	| StandardSchemaSessionOptions<TClientMessage, TServerMessage>
 	| ((
 			ctx: Context<{ Bindings: TEnv }> | undefined,
 			websocket: WebSocket,
-	  ) => ZodSessionOptions<TClientMessage, TServerMessage>);
+	  ) => StandardSchemaSessionOptions<TClientMessage, TServerMessage>);
 
-export type ZodWebSocketDOOptions<
+export type StandardSchemaWebSocketDOOptions<
 	// biome-ignore lint/suspicious/noExplicitAny: We are using any on purpose to allow any type of session.
-	TSession extends ZodSession<any, any, any, any>,
+	TSession extends StandardSchemaSession<any, any, any, any>,
 	TClientMessage,
 	TServerMessage,
 	TEnv extends SessionEnv<TSession>,
 > = {
-	zodSessionOptions: ZodSessionOptionsOrFactory<
+	standardSchemaSessionOptions: StandardSchemaSessionOptionsOrFactory<
 		TClientMessage,
 		TServerMessage,
 		TEnv
 	>;
-	createZodSession: (
+	createStandardSchemaSession: (
 		ctx: Context<{ Bindings: TEnv }> | undefined,
 		websocket: WebSocket,
-		options: ZodSessionOptions<TClientMessage, TServerMessage>,
+		options: StandardSchemaSessionOptions<TClientMessage, TServerMessage>,
 	) => TSession | Promise<TSession>;
 };
 
-export abstract class ZodWebSocketDO<
+export abstract class StandardSchemaWebSocketDO<
 	// biome-ignore lint/suspicious/noExplicitAny: We are using any on purpose to allow any type of session.
-	TSession extends ZodSession<any, any, any, any>,
+	TSession extends StandardSchemaSession<any, any, any, any>,
 	TClientMessage extends
 		SessionClientMessage<TSession> = SessionClientMessage<TSession>,
 	TServerMessage extends
 		SessionServerMessage<TSession> = SessionServerMessage<TSession>,
 	TEnv extends SessionEnv<TSession> = SessionEnv<TSession>,
 > extends BaseWebSocketDO<TSession, TEnv> {
-	protected readonly zodSessionOptions: ZodSessionOptionsOrFactory<
+	protected readonly standardSchemaSessionOptions: StandardSchemaSessionOptionsOrFactory<
 		TClientMessage,
 		TServerMessage,
 		TEnv
 	>;
-	protected readonly createZodSessionFn: (
+	protected readonly createStandardSchemaSessionFn: (
 		ctx: Context<{ Bindings: TEnv }> | undefined,
 		websocket: WebSocket,
-		options: ZodSessionOptions<TClientMessage, TServerMessage>,
+		options: StandardSchemaSessionOptions<TClientMessage, TServerMessage>,
 	) => TSession | Promise<TSession>;
 
 	constructor(
 		ctx: DurableObjectState,
 		env: TEnv,
-		options: ZodWebSocketDOOptions<
+		options: StandardSchemaWebSocketDOOptions<
 			TSession,
 			TClientMessage,
 			TServerMessage,
@@ -69,15 +72,19 @@ export abstract class ZodWebSocketDO<
 	) {
 		super(ctx, env, {
 			createSession: (ctx, websocket) => {
-				const zodOptions =
-					typeof options.zodSessionOptions === "function"
-						? options.zodSessionOptions(ctx, websocket)
-						: options.zodSessionOptions;
+				const schemaOptions =
+					typeof options.standardSchemaSessionOptions === "function"
+						? options.standardSchemaSessionOptions(ctx, websocket)
+						: options.standardSchemaSessionOptions;
 
-				return options.createZodSession(ctx, websocket, zodOptions);
+				return options.createStandardSchemaSession(
+					ctx,
+					websocket,
+					schemaOptions,
+				);
 			},
 		});
-		this.zodSessionOptions = options.zodSessionOptions;
-		this.createZodSessionFn = options.createZodSession;
+		this.standardSchemaSessionOptions = options.standardSchemaSessionOptions;
+		this.createStandardSchemaSessionFn = options.createStandardSchemaSession;
 	}
 }

package/src/index.ts

@@ -2,6 +2,8 @@ export {
 	BaseSession,
 	type BaseSessionHandlers,
 	type SessionClientMessage,
+	type SessionEnv,
+	type SessionServerMessage,
 } from "./BaseSession";
 export {
 	BaseWebSocketDO,
@@ -9,17 +11,18 @@ export {
 } from "./BaseWebSocketDO";
 export { WebsocketWrapper } from "./WebsocketWrapper";
 export {
-	ZodSession,
-	type ZodSessionHandlers,
-	type ZodSessionOptions,
-} from "./ZodSession";
+	StandardSchemaSession,
+	type StandardSchemaSessionHandlers,
+	type StandardSchemaSessionOptions,
+} from "./StandardSchemaSession";
 export {
-	ZodWebSocketClient,
-	type ZodWebSocketClientOptions,
-} from "./ZodWebSocketClient";
+	StandardSchemaWebSocketClient,
+	type StandardSchemaWebSocketClientOptions,
+} from "./StandardSchemaWebSocketClient";
 export {
-	type ZodSessionOptionsOrFactory,
-	ZodWebSocketDO,
-	type ZodWebSocketDOOptions,
-} from "./ZodWebSocketDO";
-export { zodMsgpack } from "./zodMsgpack";
+	type StandardSchemaSessionOptionsOrFactory,
+	StandardSchemaWebSocketDO,
+	type StandardSchemaWebSocketDOOptions,
+} from "./StandardSchemaWebSocketDO";
+export { parseStandardSchema } from "./parseStandardSchema";
+export { standardSchemaMsgpack } from "./standardSchemaMsgpack";

package/src/parseStandardSchema.ts

@@ -0,0 +1,17 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+/**
+ * Validates {@link value} with a Standard Schema v1 schema and returns the output,
+ * or throws an {@link Error} whose message aggregates issue messages.
+ */
+export async function parseStandardSchema<T>(
+	schema: StandardSchemaV1<unknown, T>,
+	value: unknown,
+): Promise<T> {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) {
+		const messages = result.issues.map((issue) => issue.message).join("; ");
+		throw new Error(messages || "Validation failed");
+	}
+	return result.value;
+}

package/src/standardSchemaMsgpack.ts

@@ -0,0 +1,17 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { pack, unpack } from "msgpackr";
+import { parseStandardSchema } from "./parseStandardSchema";
+
+export const standardSchemaMsgpack = <T>(
+	schema: StandardSchemaV1<unknown, T>,
+) => ({
+	async encode(value: T): Promise<Uint8Array> {
+		const validated = await parseStandardSchema(schema, value);
+		const packed = pack(validated);
+		return new Uint8Array(packed);
+	},
+	async decode(bytes: Uint8Array): Promise<T> {
+		const unpacked = unpack(bytes);
+		return parseStandardSchema(schema, unpacked);
+	},
+});

package/src/standardSchemaRpc.ts

@@ -0,0 +1,83 @@
+import {
+	type StandardSchemaWebSocketClientOptions,
+	StandardSchemaWebSocketClient,
+} from "./StandardSchemaWebSocketClient";
+
+export type StandardSchemaWebSocketRpcSessionConstructorOptions<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+> = Omit<
+	StandardSchemaWebSocketClientOptions<TClientMsg, TServerMsg>,
+	"onMessage"
+> & {
+	onMessage: (
+		message: TServerMsg,
+		session: StandardSchemaWebSocketRpcSession<
+			TClientMsg,
+			TServerMsg,
+			TPending
+		>,
+	) => void;
+};
+
+/**
+ * WebSocket client session with a pending map for request/response RPC and a
+ * monotonic id helper. Wire formats stay in your Standard Schema schemas; you dispatch
+ * {@link TServerMsg} in `onMessage` (typically with `switch` + `exhaustiveGuard`)
+ * and resolve/reject entries in {@link pending}.
+ */
+export class StandardSchemaWebSocketRpcSession<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+> {
+	readonly pending = new Map<string, TPending>();
+	readonly client: StandardSchemaWebSocketClient<TClientMsg, TServerMsg>;
+	private idSeq = 0;
+
+	constructor(
+		options: StandardSchemaWebSocketRpcSessionConstructorOptions<
+			TClientMsg,
+			TServerMsg,
+			TPending
+		>,
+	) {
+		const { onMessage, ...clientOptions } = options;
+		this.client = new StandardSchemaWebSocketClient({
+			...clientOptions,
+			onMessage: (message) => {
+				onMessage(message, this);
+			},
+		});
+	}
+
+	nextId(prefix: string): string {
+		return `${prefix}-${++this.idSeq}`;
+	}
+
+	rejectAllPending(reason: Error): void {
+		for (const [, pending] of this.pending) {
+			pending.reject(reason);
+		}
+		this.pending.clear();
+	}
+
+	close(code?: number, reason?: string): void {
+		this.client.close(code, reason);
+	}
+}
+
+export function createStandardSchemaWebSocketRpcSession<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+>(
+	options: StandardSchemaWebSocketRpcSessionConstructorOptions<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	>,
+): StandardSchemaWebSocketRpcSession<TClientMsg, TServerMsg, TPending> {
+	return new StandardSchemaWebSocketRpcSession(options);
+}

package/src/standardSchemaRpcReact.ts

@@ -0,0 +1,107 @@
+import type { DependencyList, RefObject } from "react";
+import { useEffect, useRef, useState } from "react";
+import {
+	type StandardSchemaWebSocketRpcSession,
+	type StandardSchemaWebSocketRpcSessionConstructorOptions,
+	createStandardSchemaWebSocketRpcSession,
+} from "./standardSchemaRpc";
+
+/** Options for {@link useStandardSchemaWebSocketRpc} (same as constructor options for {@link StandardSchemaWebSocketRpcSession}). */
+export type UseStandardSchemaWebSocketRpcOptions<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+> = StandardSchemaWebSocketRpcSessionConstructorOptions<
+	TClientMsg,
+	TServerMsg,
+	TPending
+>;
+
+/**
+ * Connects a {@link StandardSchemaWebSocketRpcSession} in an effect: rejects all pending
+ * RPCs and closes the socket on cleanup or when `deps` change.
+ *
+ * Callback refs keep the latest `onMessage` / `onOpen` / `onClose` without
+ * listing them in `deps`, so inline handlers do not reconnect every render.
+ *
+ * Pass `deps` as the second argument; keep it aligned with values used to
+ * build `url` / `webSocket`.
+ */
+export function useStandardSchemaWebSocketRpc<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+>(
+	options: UseStandardSchemaWebSocketRpcOptions<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	>,
+	deps: DependencyList,
+): {
+	ready: boolean;
+	sessionRef: RefObject<StandardSchemaWebSocketRpcSession<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	> | null>;
+} {
+	const { onMessage, onOpen, onClose, ...clientOptions } = options;
+
+	const onMessageRef = useRef(onMessage);
+	onMessageRef.current = onMessage;
+	const onOpenRef = useRef(onOpen);
+	onOpenRef.current = onOpen;
+	const onCloseRef = useRef(onClose);
+	onCloseRef.current = onClose;
+
+	const [ready, setReady] = useState(false);
+	const sessionRef = useRef<StandardSchemaWebSocketRpcSession<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	> | null>(null);
+
+	useEffect(() => {
+		let cancelled = false;
+		setReady(false);
+
+		const session = createStandardSchemaWebSocketRpcSession<
+			TClientMsg,
+			TServerMsg,
+			TPending
+		>({
+			...clientOptions,
+			onMessage: (msg, s) => {
+				onMessageRef.current(msg, s);
+			},
+			onOpen: (event) => {
+				if (!cancelled) {
+					setReady(true);
+				}
+				onOpenRef.current?.(event);
+			},
+			onClose: (event) => {
+				if (!cancelled) {
+					setReady(false);
+				}
+				onCloseRef.current?.(event);
+			},
+		});
+
+		sessionRef.current = session;
+		if (session.client.socket.readyState === WebSocket.OPEN) {
+			setReady(true);
+		}
+
+		return () => {
+			cancelled = true;
+			sessionRef.current = null;
+			session.rejectAllPending(new Error("WebSocket closed"));
+			session.close();
+		};
+		// biome-ignore lint/correctness/useExhaustiveDependencies: deps is the explicit contract
+	}, deps);
+
+	return { ready, sessionRef };
+}

package/src/zodMsgpack.ts

@@ -1,13 +0,0 @@
-import { pack, unpack } from "msgpackr";
-import type { ZodType } from "zod";
-
-export const zodMsgpack = <T>(schema: ZodType<T>) => ({
-	encode(value: T): Uint8Array {
-		const validated = schema.parse(value);
-		const packed = pack(validated);
-		return new Uint8Array(packed);
-	},
-	decode(bytes: Uint8Array): T {
-		return schema.parse(unpack(bytes));
-	},
-});