@firtoz/websocket-do 10.0.0 → 13.0.0

package/README.md

@@ -4,14 +4,18 @@
 [![npm downloads](https://img.shields.io/npm/dm/%40firtoz%2Fwebsocket-do.svg)](https://www.npmjs.com/package/@firtoz/websocket-do)
 [![license](https://img.shields.io/npm/l/%40firtoz%2Fwebsocket-do.svg)](https://github.com/firtoz/fullstack-toolkit/blob/main/LICENSE)
 
-Type-safe WebSocket session management for Cloudflare Durable Objects with Hono integration.
+[![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Cloudflare](https://img.shields.io/badge/Cloudflare-Durable_Objects-F38020?logo=cloudflare&logoColor=white)](https://developers.cloudflare.com/durable-objects/)
+[![Hono](https://img.shields.io/badge/Hono-E36002?logo=hono&logoColor=white)](https://hono.dev)
+
+**WebSocket sessions on Durable Objects** — Standard Schema message validation, broadcasting, and Hono integration.
 
 > **⚠️ Early WIP Notice:** This package is in very early development and is **not production-ready**. It is TypeScript-only and may have breaking changes. While I (the maintainer) have limited time, I'm open to PRs for features, bug fixes, or additional support (like JS builds). Please feel free to try it out and contribute! See [CONTRIBUTING.md](../../CONTRIBUTING.md) for details.
 
 ## 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 +38,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 +102,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 +141,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 +215,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 +230,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 +250,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 +273,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 +282,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 +308,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 +328,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 +353,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 +387,7 @@ interface SessionData {
 }
 
 // Implement validated session
-class ChatSession extends ZodSession<
+class ChatSession extends StandardSchemaSession<
   SessionData,
   ServerMessage,
   ClientMessage,
@@ -393,7 +396,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 +420,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 +446,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 +524,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 +544,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 +642,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 +685,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 +700,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 +741,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 +749,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 +782,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 +813,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 +825,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 +875,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/dist/BaseSession.d.ts

@@ -0,0 +1,41 @@
+import { Context } from 'hono';
+
+type SessionData<TSession extends BaseSession<any, any, any, any>> = TSession extends BaseSession<infer TData, infer _TServerMessage, infer _TClientMessage, infer _TEnv> ? TData : never;
+type SessionClientMessage<TSession extends BaseSession<any, any, any, any>> = TSession extends BaseSession<infer _TData, infer _TServerMessage, infer TClientMessage, infer _TEnv> ? TClientMessage : never;
+type SessionServerMessage<TSession extends BaseSession<any, any, any, any>> = TSession extends BaseSession<infer _TData, infer TServerMessage, infer _TClientMessage, infer _TEnv> ? TServerMessage : never;
+type SessionEnv<TSession extends BaseSession<any, any, any, any>> = TSession extends BaseSession<infer _TData, infer _TServerMessage, infer _TClientMessage, infer TEnv extends Cloudflare.Env> ? TEnv : never;
+type BaseSessionHandlers<TData, TServerMessage, TClientMessage, TEnv extends object = Cloudflare.Env> = {
+    /**
+     * 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>;
+    /** Called when this connection closes; `session` is this {@link BaseSession} instance. */
+    handleClose: (session: BaseSession<TData, TServerMessage, TClientMessage, TEnv>) => Promise<void>;
+};
+declare class BaseSession<TData, TServerMessage, TClientMessage, TEnv extends object = Cloudflare.Env> {
+    websocket: WebSocket;
+    protected sessions: Map<WebSocket, BaseSession<TData, TServerMessage, TClientMessage, TEnv>>;
+    private _data;
+    get data(): TData;
+    private set data(value);
+    private readonly wrapper;
+    protected readonly handlers: BaseSessionHandlers<TData, TServerMessage, TClientMessage, TEnv>;
+    constructor(websocket: WebSocket, sessions: Map<WebSocket, BaseSession<TData, TServerMessage, TClientMessage, TEnv>>, handlers: BaseSessionHandlers<TData, TServerMessage, TClientMessage, TEnv>);
+    startFresh(ctx: Context<{
+        Bindings: TEnv;
+    }>): void;
+    resume(): void;
+    update(): void;
+    broadcast(message: TServerMessage, excludeSelf?: boolean): void;
+    send(message: TServerMessage): void;
+    handleMessage(message: TClientMessage): Promise<void>;
+    handleBufferMessage(message: ArrayBuffer): Promise<void>;
+    handleClose(): Promise<void>;
+}
+
+export { BaseSession, type BaseSessionHandlers, type SessionClientMessage, type SessionData, type SessionEnv, type SessionServerMessage };

package/dist/BaseSession.js

@@ -0,0 +1,5 @@
+export { BaseSession } from './chunk-3C77OSOD.js';
+import './chunk-KCPOB32E.js';
+import './chunk-NOUFNU2O.js';
+//# sourceMappingURL=BaseSession.js.map
+//# sourceMappingURL=BaseSession.js.map

package/dist/BaseSession.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"BaseSession.js"}

package/dist/BaseWebSocketDO.d.ts

@@ -0,0 +1,42 @@
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { DurableObject } from 'cloudflare:workers';
+import { DOWithHonoApp } from '@firtoz/hono-fetcher/honoDoFetcher';
+import { Context, Hono } from 'hono';
+import { BaseSession, SessionEnv } from './BaseSession.js';
+
+type BaseWebSocketDOOptions<TSession extends BaseSession<any, any, any, any>, TEnv extends SessionEnv<TSession>> = {
+    createSession: (ctx: Context<{
+        Bindings: TEnv;
+    }> | undefined, websocket: WebSocket) => TSession | Promise<TSession>;
+};
+declare abstract class BaseWebSocketDO<TSession extends BaseSession<any, any, any, any> = BaseSession<any, any, any, any>, TEnv extends SessionEnv<TSession> = SessionEnv<TSession>> extends DurableObject<TEnv> implements DOWithHonoApp {
+    #private;
+    private readonly options;
+    protected readonly sessions: Map<WebSocket, TSession>;
+    abstract readonly app: Hono<{
+        Bindings: TEnv;
+    }>;
+    constructor(ctx: DurableObjectState, env: TEnv, options: BaseWebSocketDOOptions<TSession, TEnv>);
+    protected getBaseApp(): hono_hono_base.HonoBase<{
+        Bindings: TEnv;
+    }, {
+        "/websocket": {
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: hono_utils_http_status.StatusCode;
+            };
+        };
+    }, "/", "/websocket">;
+    handleSession(ctx: Context<{
+        Bindings: TEnv;
+    }>, ws: WebSocket): Promise<void>;
+    webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    webSocketClose(ws: WebSocket, _code: number, _reason: string, _wasClean: boolean): Promise<void>;
+    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+    fetch(request: Request): Response | Promise<Response>;
+}
+
+export { BaseWebSocketDO, type BaseWebSocketDOOptions };

package/dist/BaseWebSocketDO.js

@@ -0,0 +1,4 @@
+export { BaseWebSocketDO } from './chunk-XFB6C3NZ.js';
+import './chunk-NOUFNU2O.js';
+//# sourceMappingURL=BaseWebSocketDO.js.map
+//# sourceMappingURL=BaseWebSocketDO.js.map

package/dist/BaseWebSocketDO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"BaseWebSocketDO.js"}

package/dist/StandardSchemaSession.d.ts

@@ -0,0 +1,41 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Context } from 'hono';
+import { BaseSession } from './BaseSession.js';
+
+type StandardSchemaSessionOptions<TClientMessage, TServerMessage> = {
+    clientSchema: StandardSchemaV1<unknown, TClientMessage>;
+    serverSchema: StandardSchemaV1<unknown, TServerMessage>;
+    serializeJson?: (value: unknown) => string;
+    deserializeJson?: (raw: string) => unknown;
+    enableBufferMessages?: boolean;
+    sendProtocolError?: (websocket: WebSocket, errorMessage: string) => Promise<void>;
+};
+type StandardSchemaSessionHandlers<TData, TServerMessage, TClientMessage, TEnv extends object> = {
+    createData: (ctx: Context<{
+        Bindings: TEnv;
+    }>) => TData;
+    handleValidatedMessage: (message: TClientMessage) => Promise<void>;
+    handleValidationError?: (error: unknown, originalMessage: unknown) => Promise<void>;
+    handleClose: (session: StandardSchemaSession<TData, TServerMessage, TClientMessage, TEnv>) => Promise<void>;
+};
+declare class StandardSchemaSession<TData, TServerMessage, TClientMessage, TEnv extends object = Cloudflare.Env> extends BaseSession<TData, TServerMessage, TClientMessage, TEnv> {
+    private readonly options;
+    private readonly schemaHandlers;
+    private readonly clientCodec;
+    private readonly serverCodec;
+    protected readonly enableBufferMessages: boolean;
+    constructor(websocket: WebSocket, sessions: Map<WebSocket, StandardSchemaSession<TData, TServerMessage, TClientMessage, TEnv>>, options: StandardSchemaSessionOptions<TClientMessage, TServerMessage>, schemaHandlers: StandardSchemaSessionHandlers<TData, TServerMessage, TClientMessage, TEnv>);
+    handleRawMessage(rawMessage: string): Promise<void>;
+    private _internalHandleMessage;
+    private _internalHandleBufferMessage;
+    private _internalHandleValidationError;
+    send(message: TServerMessage): void;
+    private sendJsonAsync;
+    private sendBufferAsync;
+    private sendProtocolError;
+    private serializeJson;
+    private deserializeJson;
+    broadcast(message: TServerMessage, excludeSelf?: boolean): void;
+}
+
+export { StandardSchemaSession, type StandardSchemaSessionHandlers, type StandardSchemaSessionOptions };

package/dist/StandardSchemaSession.js

@@ -0,0 +1,8 @@
+export { StandardSchemaSession } from './chunk-53MFRNQS.js';
+import './chunk-QMGIRIHJ.js';
+import './chunk-3C77OSOD.js';
+import './chunk-KCPOB32E.js';
+import './chunk-CAX4POIL.js';
+import './chunk-NOUFNU2O.js';
+//# sourceMappingURL=StandardSchemaSession.js.map
+//# sourceMappingURL=StandardSchemaSession.js.map

package/dist/StandardSchemaSession.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"StandardSchemaSession.js"}

package/dist/StandardSchemaWebSocketClient.d.ts

@@ -0,0 +1,45 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+interface StandardSchemaWebSocketClientOptions<TClientMessage, TServerMessage> {
+    /**
+     * URL to connect to (required if webSocket not provided)
+     */
+    url?: string;
+    /**
+     * Existing WebSocket to wrap (alternative to url)
+     * Useful when getting a WebSocket from honoDoFetcher
+     */
+    webSocket?: WebSocket;
+    clientSchema: StandardSchemaV1<unknown, TClientMessage>;
+    serverSchema: StandardSchemaV1<unknown, TServerMessage>;
+    serializeJson?: (value: unknown) => string;
+    deserializeJson?: (raw: string) => unknown;
+    enableBufferMessages?: boolean;
+    onMessage?: (message: TServerMessage) => void;
+    onOpen?: (event: Event) => void;
+    onClose?: (event: CloseEvent) => void;
+    onError?: (event: Event) => void;
+    onValidationError?: (error: Error, rawMessage: unknown) => void;
+}
+declare class StandardSchemaWebSocketClient<TClientMessage, TServerMessage> {
+    private ws;
+    private readonly clientSchema;
+    private readonly serverSchema;
+    private readonly serializeJson;
+    private readonly deserializeJson;
+    private readonly enableBufferMessages;
+    private readonly onMessageCallback?;
+    private readonly onValidationError?;
+    constructor(options: StandardSchemaWebSocketClientOptions<TClientMessage, TServerMessage>);
+    private handleMessageEvent;
+    /**
+     * Send a message (automatically encodes based on mode).
+     */
+    send(message: TClientMessage): Promise<void>;
+    close(code?: number, reason?: string): void;
+    get readyState(): number;
+    get socket(): WebSocket;
+    waitForOpen(): Promise<void>;
+}
+
+export { StandardSchemaWebSocketClient, type StandardSchemaWebSocketClientOptions };

package/dist/StandardSchemaWebSocketClient.js

@@ -0,0 +1,5 @@
+export { StandardSchemaWebSocketClient } from './chunk-3LWVEY3R.js';
+import './chunk-CAX4POIL.js';
+import './chunk-NOUFNU2O.js';
+//# sourceMappingURL=StandardSchemaWebSocketClient.js.map
+//# sourceMappingURL=StandardSchemaWebSocketClient.js.map

package/dist/StandardSchemaWebSocketClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"StandardSchemaWebSocketClient.js"}

package/dist/StandardSchemaWebSocketDO.d.ts

@@ -0,0 +1,28 @@
+import { Context } from 'hono';
+import { SessionEnv, SessionClientMessage, SessionServerMessage } from './BaseSession.js';
+import { BaseWebSocketDO } from './BaseWebSocketDO.js';
+import { StandardSchemaSessionOptions, StandardSchemaSession } from './StandardSchemaSession.js';
+import 'hono/hono-base';
+import 'hono/utils/http-status';
+import 'cloudflare:workers';
+import '@firtoz/hono-fetcher/honoDoFetcher';
+import '@standard-schema/spec';
+
+type StandardSchemaSessionOptionsOrFactory<TClientMessage, TServerMessage, TEnv extends Cloudflare.Env = Cloudflare.Env> = StandardSchemaSessionOptions<TClientMessage, TServerMessage> | ((ctx: Context<{
+    Bindings: TEnv;
+}> | undefined, websocket: WebSocket) => StandardSchemaSessionOptions<TClientMessage, TServerMessage>);
+type StandardSchemaWebSocketDOOptions<TSession extends StandardSchemaSession<any, any, any, any>, TClientMessage, TServerMessage, TEnv extends SessionEnv<TSession>> = {
+    standardSchemaSessionOptions: StandardSchemaSessionOptionsOrFactory<TClientMessage, TServerMessage, TEnv>;
+    createStandardSchemaSession: (ctx: Context<{
+        Bindings: TEnv;
+    }> | undefined, websocket: WebSocket, options: StandardSchemaSessionOptions<TClientMessage, TServerMessage>) => TSession | Promise<TSession>;
+};
+declare abstract class StandardSchemaWebSocketDO<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 standardSchemaSessionOptions: StandardSchemaSessionOptionsOrFactory<TClientMessage, TServerMessage, TEnv>;
+    protected readonly createStandardSchemaSessionFn: (ctx: Context<{
+        Bindings: TEnv;
+    }> | undefined, websocket: WebSocket, options: StandardSchemaSessionOptions<TClientMessage, TServerMessage>) => TSession | Promise<TSession>;
+    constructor(ctx: DurableObjectState, env: TEnv, options: StandardSchemaWebSocketDOOptions<TSession, TClientMessage, TServerMessage, TEnv>);
+}
+
+export { type StandardSchemaSessionOptionsOrFactory, StandardSchemaWebSocketDO, type StandardSchemaWebSocketDOOptions };

package/dist/StandardSchemaWebSocketDO.js

@@ -0,0 +1,5 @@
+export { StandardSchemaWebSocketDO } from './chunk-ULGH6X42.js';
+import './chunk-XFB6C3NZ.js';
+import './chunk-NOUFNU2O.js';
+//# sourceMappingURL=StandardSchemaWebSocketDO.js.map
+//# sourceMappingURL=StandardSchemaWebSocketDO.js.map

package/dist/StandardSchemaWebSocketDO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"StandardSchemaWebSocketDO.js"}

package/dist/WebsocketWrapper.d.ts

@@ -0,0 +1,9 @@
+declare class WebsocketWrapper<TAttachment, TMessage> {
+    webSocket: WebSocket;
+    constructor(webSocket: WebSocket);
+    send(message: TMessage): void;
+    deserializeAttachment(): TAttachment;
+    serializeAttachment(attachment: TAttachment): void;
+}
+
+export { WebsocketWrapper };

package/dist/WebsocketWrapper.js

@@ -0,0 +1,4 @@
+export { WebsocketWrapper } from './chunk-KCPOB32E.js';
+import './chunk-NOUFNU2O.js';
+//# sourceMappingURL=WebsocketWrapper.js.map
+//# sourceMappingURL=WebsocketWrapper.js.map

package/dist/WebsocketWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"WebsocketWrapper.js"}