@firtoz/websocket-do 10.0.0 → 13.0.0

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);
+	},
+});