@lovrozagar/honey 0.1.0 → 0.2.0

package/src/types.ts

@@ -171,10 +171,7 @@ export type FieldError = {
 }
 
 /* shared frozen empty objects — avoid per-call {} allocations */
-export const EMPTY_OBJ: Record<string, never> = Object.freeze(Object.create(null)) as Record<
-	string,
-	never
->
+export const EMPTY_OBJ: Record<string, never> = Object.freeze(Object.create(null)) as Record<string, never>
 export const EMPTY_FIELDS: Record<string, FieldError[]> = EMPTY_OBJ as Record<string, FieldError[]>
 
 export type NormalizedIssue = {
@@ -233,9 +230,7 @@ export type InferOutput<T> = T extends {
 
 /** Map input schema definitions to their inferred output types, dropping undefined keys */
 export type InferInputMap<T> = {
-	[K in keyof T as T[K] extends undefined | null ? never : K]-?: InferOutput<
-		UnwrapInputSchema<NonNullable<T[K]>>
-	>
+	[K in keyof T as T[K] extends undefined | null ? never : K]-?: InferOutput<UnwrapInputSchema<NonNullable<T[K]>>>
 }
 
 /**
@@ -326,7 +321,7 @@ export type OutputSchemaDef = {
 	"application/octet-stream"?: StatusSchemaMap
 	"application/pdf"?: StatusSchemaMap
 	"application/xml"?: StatusSchemaMap
-	"redirect"?: RedirectSchemaMap
+	redirect?: RedirectSchemaMap
 	"text/csv"?: StatusSchemaMap
 	"text/event-stream"?: StatusSchemaMap
 	"text/html"?: StatusSchemaMap
@@ -372,6 +367,8 @@ export type OpenApiMeta = {
 	internal?: boolean
 	deprecated?: boolean
 	description?: string
+	/** Escape hatch — emitted verbatim at the highest precedence. Prefer a `.metaSpec()` entry. */
+	extensions?: Record<`x-${string}`, unknown>
 	invalidate?: readonly string[] | null
 	mcp?: boolean
 	operationId?: string
@@ -380,20 +377,156 @@ export type OpenApiMeta = {
 	tags?: string | string[]
 }
 
+/* ---- Meta spec (codegen-time policy: meta → OpenAPI operation) ---- */
+
+/** Which operation kinds a policy entry applies to */
+export type MetaSpecTarget = "both" | "http" | "ws"
+
+/** Where a schema-derived policy entry reads its source key from */
+export type MetaSpecSchemaSource =
+	| "input.cookies"
+	| "input.form"
+	| "input.headers"
+	| "input.json"
+	| "input.search"
+	| "output"
+
+/** Passed to a policy entry's `map` / `expand` */
+export type MetaSpecContext = {
+	meta: Record<string, unknown>
+	method: string
+	path: string
+	profile: string
+	/** Where the source value came from — `"meta"`, or the schema source for schema entries */
+	source: "meta" | MetaSpecSchemaSource
+}
+
+type MetaSpecEntryBase = {
+	/** Which operation kinds this entry applies to. Default `"both"` */
+	on?: MetaSpecTarget
+	/** Restrict this entry to named profiles. Default: every profile */
+	profiles?: readonly string[]
+	/** Validates the produced value at codegen time. A failure is a build error */
+	schema?: StandardSchemaLike
+}
+
+/** Policy entry writing one operation key */
+export type MetaSpecSingle<TValue = unknown> = MetaSpecEntryBase & {
+	/** Target operation key — an `x-*` extension or an allowed standard field */
+	key: string
+	/** Transform the source value. Returning `undefined` omits the key for that operation */
+	map?: (value: TValue, ctx: MetaSpecContext) => unknown
+}
+
+/** Policy entry fanning one source value out to several operation keys */
+export type MetaSpecExpand<TValue = unknown> = MetaSpecEntryBase & {
+	/** Returns operation keys → values. `undefined` (returned or per key) omits */
+	expand: (value: TValue, ctx: MetaSpecContext) => Record<string, unknown> | undefined
+}
+
+/** One policy entry: hidden (`false`), verbatim (`"x-foo"`), single target, or fan-out */
+export type MetaSpecEntry<TValue = unknown> = false | MetaSpecExpand<TValue> | MetaSpecSingle<TValue> | string
+
+/**
+ * How deeply to look for a schema-metadata key.
+ * `"root"` reads the schema root, reading through one level of `items` for a bare array output.
+ * `"deep"` walks the schema (properties, items, composition members) and takes the shallowest
+ * match — for envelope shapes like `{ articles: [Article], nextCursor, count }`.
+ */
+export type MetaSpecSchemaSearch = "deep" | "root"
+
+/** Refuse a descriptor whose publisher contract version is newer than this policy understands */
+export type MetaSpecVersionGuard = {
+	/** Field carrying the contract version. Default `"v"` */
+	field?: string
+	/** Highest version this entry's `map`/`expand` was written against */
+	max: number
+}
+
+/**
+ * Policy entry reading its source key off a route schema instead of route meta.
+ *
+ * The object key names the entry; `read` says which schema-metadata key it reads, so several
+ * entries can read one reserved key — the shape a publisher takes when it stamps a
+ * discriminated union under a single key.
+ */
+export type MetaSpecSchemaEntry<TValue = unknown> = (MetaSpecExpand<TValue> | MetaSpecSingle<TValue>) & {
+	/** Schema sources to search, in order. First one carrying a matching descriptor wins */
+	from?: readonly MetaSpecSchemaSource[]
+	/**
+	 * Shallow subset the descriptor must satisfy for this entry to claim it — the discriminant
+	 * of a union, e.g. `{ kind: "entity" }`. A descriptor found under `read` that satisfies no
+	 * entry's `match` is a build error, never a silently missing tag.
+	 */
+	match?: Record<string, unknown>
+	/** Schema-metadata key to read. Defaults to this entry's own name */
+	read?: string
+	/** Where in the schema to look. Default `"root"` */
+	search?: MetaSpecSchemaSearch
+	/** Fail the build on a descriptor from a newer publisher contract than this entry handles */
+	version?: MetaSpecVersionGuard
+}
+
+/** Per-document filter over emitted operation keys */
+export type MetaSpecProfile = {
+	/** Denylist of emitted keys */
+	exclude?: readonly string[]
+	/** Allowlist of emitted `x-*` keys — standard fields are always kept unless excluded */
+	include?: readonly string[]
+}
+
+/** How an unmapped meta key is reported at codegen time */
+export type MetaSpecStrictness = "error" | "off" | "warn"
+
+type MetaSpecSections<TMetaSection> = {
+	/** Route-meta entries, keyed by meta key */
+	meta?: TMetaSection
+	/** Named per-document filters. `"default"` filters nothing */
+	profiles?: Record<string, MetaSpecProfile>
+	/** Schema-derived entries, keyed by the key read off the schema's metadata */
+	schema?: Record<string, MetaSpecSchemaEntry<never>>
+	/** How to report a meta key with no entry. Default `"error"` */
+	strict?: MetaSpecStrictness
+}
+
+/** Built-in meta keys ship with a default policy — overriding them is optional */
+type MetaSpecOptionalKeys<TMeta> = {
+	[K in Extract<keyof TMeta, keyof OpenApiMeta>]?: MetaSpecEntry<Exclude<TMeta[K], undefined>>
+}
+
+/** Every app-defined meta key must have an entry — a missing key is a type error */
+type MetaSpecRequiredKeys<TMeta> = {
+	[K in Exclude<keyof TMeta, keyof OpenApiMeta>]-?: MetaSpecEntry<Exclude<TMeta[K], undefined>>
+}
+
+/** Declarative policy for what flows from route meta and route schemas into the document */
+export type HoneyMetaSpec<TMeta = unknown> = [TMeta] extends [never]
+	? MetaSpecSections<Record<string, MetaSpecEntry>>
+	: TMeta extends Record<string, unknown>
+		? MetaSpecSections<MetaSpecOptionalKeys<TMeta> & MetaSpecRequiredKeys<TMeta>>
+		: MetaSpecSections<Record<string, MetaSpecEntry>>
+
+/** Erased runtime shape of a resolved policy — what codegen consumes */
+export type MetaSpecConfig = {
+	meta?: Record<string, MetaSpecEntry>
+	profiles?: Record<string, MetaSpecProfile>
+	schema?: Record<string, MetaSpecSchemaEntry>
+	strict?: MetaSpecStrictness
+}
+
 /** Built-in meta shape — always available on .meta() */
 export type DefaultMeta = OpenApiMeta
 
 /** Augmented by generated code per-app to narrow invalidate selectors */
 export interface HoneyCodegen {}
 
-type ResolveSelector = HoneyCodegen extends { routeSelector: infer R }
-	? R extends string ? R : string
-	: string
+type ResolveSelector = HoneyCodegen extends { routeSelector: infer R } ? (R extends string ? R : string) : string
 
 /** Utility: merges built-in meta, custom meta T, and type-safe invalidate from codegen */
-export type HoneyMeta<T = {}> = DefaultMeta & T & {
-	invalidate?: readonly ResolveSelector[] | null
-}
+export type HoneyMeta<T = {}> = DefaultMeta &
+	T & {
+		invalidate?: readonly ResolveSelector[] | null
+	}
 
 /** Accumulated route schema entry for RPC client generation */
 export type RouteRecord<
@@ -450,17 +583,15 @@ export type InferCtx<T> = T extends { readonly $ctx: infer TCtx } ? Omit<TCtx, "
 export type InferEnv<T> = T extends { readonly $env: infer TEnv } ? TEnv : never
 
 /** All HTTP methods used across all routes */
-export type InferMethods<T> =
-	InferRoutes<T> extends infer R ? { [P in keyof R]: keyof R[P] & string }[keyof R] : never
+export type InferMethods<T> = InferRoutes<T> extends infer R ? { [P in keyof R]: keyof R[P] & string }[keyof R] : never
 
 /** Available route paths registered on a Honey instance */
 export type InferRoutePaths<T> = keyof InferRoutes<T> & string
 
 /** Available methods for a given path ("get", "post", etc.) */
-export type InferRouteMethods<
-	T,
-	TPath extends InferRoutePaths<T>,
-> = InferRoutes<T>[TPath] extends infer M ? keyof M & string : never
+export type InferRouteMethods<T, TPath extends InferRoutePaths<T>> = InferRoutes<T>[TPath] extends infer M
+	? keyof M & string
+	: never
 
 /** Lookup a specific route's record from the accumulated route map */
 type RouteLookup<T, TPath extends string, TMethod extends string> =
@@ -478,39 +609,24 @@ type RouteLookup<T, TPath extends string, TMethod extends string> =
 export type InferMeta<T> = T extends { readonly $meta: infer M } ? M : never
 
 /** Extract the full handler context type for a specific route */
-export type InferRouteCtx<
-	T,
-	TPath extends InferRoutePaths<T>,
-	TMethod extends InferRouteMethods<T, TPath>,
-> = RouteLookup<T, TPath, TMethod> extends { ctx: infer C } ? C : never
+export type InferRouteCtx<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> =
+	RouteLookup<T, TPath, TMethod> extends { ctx: infer C } ? C : never
 
 /** Extract input type for a specific route */
-export type InferRouteInput<
-	T,
-	TPath extends InferRoutePaths<T>,
-	TMethod extends InferRouteMethods<T, TPath>,
-> = RouteLookup<T, TPath, TMethod> extends { input: infer I } ? I : never
+export type InferRouteInput<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> =
+	RouteLookup<T, TPath, TMethod> extends { input: infer I } ? I : never
 
 /** Extract meta type for a specific route */
-export type InferRouteMeta<
-	T,
-	TPath extends InferRoutePaths<T>,
-	TMethod extends InferRouteMethods<T, TPath>,
-> = RouteLookup<T, TPath, TMethod> extends { meta: infer M } ? M : never
+export type InferRouteMeta<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> =
+	RouteLookup<T, TPath, TMethod> extends { meta: infer M } ? M : never
 
 /** Extract output type for a specific route */
-export type InferRouteOutput<
-	T,
-	TPath extends InferRoutePaths<T>,
-	TMethod extends InferRouteMethods<T, TPath>,
-> = RouteLookup<T, TPath, TMethod> extends { output: infer O } ? O : never
+export type InferRouteOutput<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> =
+	RouteLookup<T, TPath, TMethod> extends { output: infer O } ? O : never
 
 /** Extract error keys for a specific route */
-export type InferRouteErrors<
-	T,
-	TPath extends InferRoutePaths<T>,
-	TMethod extends InferRouteMethods<T, TPath>,
-> = RouteLookup<T, TPath, TMethod> extends { errors: infer E } ? E : never
+export type InferRouteErrors<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> =
+	RouteLookup<T, TPath, TMethod> extends { errors: infer E } ? E : never
 
 /** Extract the error factory type from a Honey instance */
 export type InferErrorFactory<T> = T extends { readonly $errorFactory: infer F } ? F : never
@@ -519,26 +635,17 @@ export type InferErrorFactory<T> = T extends { readonly $errorFactory: infer F }
  * Compute errorsByStatus from error factory + declared error keys.
  * Maps status codes to body shapes for client-side discrimination.
  */
-export type ComputeErrorsByStatus<
-	TFactory,
-	TErrorKeys extends string,
-	TMetaSymbol extends symbol,
-> = TFactory extends { readonly [K in TMetaSymbol]: infer TMeta }
+export type ComputeErrorsByStatus<TFactory, TErrorKeys extends string, TMetaSymbol extends symbol> = TFactory extends {
+	readonly [K in TMetaSymbol]: infer TMeta
+}
 	? TMeta extends Record<string, { schema: infer _S; statusKey: infer _SK }>
 		? _BuildByStatus<TMeta, TErrorKeys>
 		: never
 	: never
 
 /** Internal: build { [statusCode]: bodyShape } from meta + error keys */
-type _BuildByStatus<
-	TMeta extends Record<string, { schema: unknown; statusKey: unknown }>,
-	TKeys extends string,
-> = {
-	[SK in _UsedStatusKeys<TMeta, TKeys> & StatusKey as StatusKeyToCodeType<SK>]: _ShapesForStatus<
-		TMeta,
-		TKeys,
-		SK
-	>
+type _BuildByStatus<TMeta extends Record<string, { schema: unknown; statusKey: unknown }>, TKeys extends string> = {
+	[SK in _UsedStatusKeys<TMeta, TKeys> & StatusKey as StatusKeyToCodeType<SK>]: _ShapesForStatus<TMeta, TKeys, SK>
 }
 
 /** Internal: collect all statusKeys used by the declared error keys */
@@ -607,11 +714,7 @@ type StatusKeyToCodeType<SK extends StatusKey> = SK extends "ok"
 export type InferBasePath<T> = T extends { readonly $basePath: infer P } ? P : never
 
 /** Merge two path segments — "/" is identity */
-export type MergePath<A extends string, B extends string> = A extends "/"
-	? B
-	: B extends "/"
-		? A
-		: `${A}${B}`
+export type MergePath<A extends string, B extends string> = A extends "/" ? B : B extends "/" ? A : `${A}${B}`
 
 /* ── Tap types ── */
 
@@ -619,10 +722,7 @@ export type MergePath<A extends string, B extends string> = A extends "/"
 export type PendingTap = { key: string; payload: unknown }
 
 /** Handler registered via app.tap(key, handler) — receives context + payload */
-export type TapHandler<TEnv = unknown> = (
-	ctx: TapContext<TEnv>,
-	payload: unknown,
-) => void | Promise<void>
+export type TapHandler<TEnv = unknown> = (ctx: TapContext<TEnv>, payload: unknown) => void | Promise<void>
 
 /** Subset of HoneyContext exposed to tap handlers — no res, no recursive tap */
 export type TapContext<TEnv = unknown> = {

package/src/validation.ts

@@ -64,11 +64,7 @@ export function parseCookies(header: string): Record<string, string> {
 		let value = trimmed.slice(eqIdx + 1)
 		if (value.indexOf("%") !== -1) value = tryDecodeCookieValue(value)
 		/* RFC 6265: strip surrounding double quotes */
-		if (
-			value.length >= 2 &&
-			value.charCodeAt(0) === 34 &&
-			value.charCodeAt(value.length - 1) === 34
-		) {
+		if (value.length >= 2 && value.charCodeAt(0) === 34 && value.charCodeAt(value.length - 1) === 34) {
 			value = value.slice(1, -1)
 		}
 		result[name] = value
@@ -96,10 +92,7 @@ function extractVendorCode(issue: StandardSchemaIssue, vendor: string): string {
 	return "unknown"
 }
 
-export function normalizeIssues(
-	issues: ReadonlyArray<StandardSchemaIssue>,
-	vendor: string,
-): NormalizedIssue[] {
+export function normalizeIssues(issues: ReadonlyArray<StandardSchemaIssue>, vendor: string): NormalizedIssue[] {
 	return issues.map((issue) => {
 		const path = issue.path ? issue.path.map(toPropertyKey) : []
 		return {
@@ -113,10 +106,7 @@ export function normalizeIssues(
 	})
 }
 
-export function issuesToFieldErrors(
-	issues: NormalizedIssue[],
-	prefix: string,
-): Record<string, FieldError[]> {
+export function issuesToFieldErrors(issues: NormalizedIssue[], prefix: string): Record<string, FieldError[]> {
 	const fields: Record<string, FieldError[]> = {}
 	for (const issue of issues) {
 		const fieldName = issue.path.at(-1)?.toString() ?? "unknown"
@@ -134,11 +124,7 @@ export function issuesToFieldErrors(
 	return fields
 }
 
-async function runSchema(
-	schema: StandardSchemaLike,
-	data: unknown,
-	prefix: string,
-): Promise<unknown> {
+async function runSchema(schema: StandardSchemaLike, data: unknown, prefix: string): Promise<unknown> {
 	const result = await schema["~standard"].validate(data)
 	if (result.issues) {
 		const normalized = normalizeIssues(result.issues, schema["~standard"].vendor)
@@ -234,8 +220,7 @@ export async function validateInput(
 	if (schemas.headers) {
 		const { mode, schema } = resolveSchema(schemas.headers)
 		const headerRecord = headersToRecord(req.headers)
-		result.headers =
-			mode === "readableStream" ? headerRecord : await runSchema(schema, headerRecord, "headers")
+		result.headers = mode === "readableStream" ? headerRecord : await runSchema(schema, headerRecord, "headers")
 	}
 
 	/* cookies */
@@ -247,11 +232,7 @@ export async function validateInput(
 	}
 
 	/* body-based: json or form — skip for methods without a request body */
-	const hasBody =
-		req.method !== "DELETE" &&
-		req.method !== "GET" &&
-		req.method !== "HEAD" &&
-		req.method !== "OPTIONS"
+	const hasBody = req.method !== "DELETE" && req.method !== "GET" && req.method !== "HEAD" && req.method !== "OPTIONS"
 	if (hasBody && (schemas.json || schemas.form)) {
 		const contentType = req.headers.get("content-type")
 		const parser = selectParser(contentType)
@@ -284,11 +265,7 @@ export async function validateInput(
 	return result
 }
 
-export async function validateOutput(
-	schema: StandardSchemaLike,
-	statusKey: string,
-	data: unknown,
-): Promise<void> {
+export async function validateOutput(schema: StandardSchemaLike, statusKey: string, data: unknown): Promise<void> {
 	const result = await schema["~standard"].validate(data)
 	if (result.issues) {
 		throw new HoneyError({

package/src/ws/bun.ts

@@ -1,10 +1,4 @@
-export {
-	type RawSocket,
-	type WSAdapter,
-	type WSContext,
-	WSContextImpl,
-	type WSHandler,
-} from "./cloudflare.ts"
+export { type RawSocket, type WSAdapter, type WSContext, WSContextImpl, type WSHandler } from "./cloudflare.ts"
 
 import type { WSAdapter, WSContext, WSHandler } from "./cloudflare.ts"
 import { WSContextImpl } from "./cloudflare.ts"
@@ -76,8 +70,7 @@ export function bunWebSocket(): BunWSAdapter {
 			message(ws: BunRawSocket, data: ArrayBufferView | string) {
 				if (!ws.data.socket) ws.data.socket = new WSContextImpl(ws)
 				/* Bun passes Buffer (Uint8Array) for binary — normalize to ArrayBuffer for WSHandler */
-				const normalized =
-					typeof data === "string" ? data : ((data as Uint8Array).buffer as ArrayBuffer)
+				const normalized = typeof data === "string" ? data : ((data as Uint8Array).buffer as ArrayBuffer)
 				ws.data.handler.onMessage?.(undefined, ws.data.socket, normalized)
 			},
 			open(ws: BunRawSocket) {

package/src/ws/cloudflare.ts

@@ -87,13 +87,10 @@ export class WSContextImpl<T extends RawSocket = RawSocket> implements WSContext
  * Uses WebSocketPair + server.accept() + addEventListener.
  */
 export function cfWebSocket(): WSAdapter {
-		return {
-			upgrade(_req: Request, _env: unknown, handler: WSHandler<unknown>) {
-				type CFWebSocket = RawSocket & { accept(): void }
-				const Ctor = (globalThis as Record<string, unknown>)["WebSocketPair"] as new () => [
-					CFWebSocket,
-					CFWebSocket,
-				]
+	return {
+		upgrade(_req: Request, _env: unknown, handler: WSHandler<unknown>) {
+			type CFWebSocket = RawSocket & { accept(): void }
+			const Ctor = (globalThis as Record<string, unknown>)["WebSocketPair"] as new () => [CFWebSocket, CFWebSocket]
 			const [client, server] = new Ctor()
 			server.accept()
 			const socket = new WSContextImpl(server)
@@ -120,14 +117,14 @@ export function cfWebSocket(): WSAdapter {
 			}
 			handler.onOpen?.(undefined, socket)
 
-				return {
-					response: new Response(null, {
-						headers: { upgrade: "websocket" },
-						status: 101,
-						webSocket: client,
-					} as unknown as ResponseInit),
-					socket,
-				}
-			},
+			return {
+				response: new Response(null, {
+					headers: { upgrade: "websocket" },
+					status: 101,
+					webSocket: client,
+				} as unknown as ResponseInit),
+				socket,
+			}
+		},
 	}
 }

package/src/ws/deno.ts

@@ -5,30 +5,27 @@ export {
 	type WSPreUpgrade,
 	WSContextImpl,
 	type WSHandler,
-} from "./cloudflare.ts";
+} from "./cloudflare.ts"
 
-import type { WSAdapter, WSHandler, WSPreUpgrade } from "./cloudflare.ts";
-import { WSContextImpl } from "./cloudflare.ts";
+import type { WSAdapter, WSHandler, WSPreUpgrade } from "./cloudflare.ts"
+import { WSContextImpl } from "./cloudflare.ts"
 
 type DenoNs = {
 	Deno: {
 		upgradeWebSocket(req: Request): {
-			response: Response;
+			response: Response
 			socket: {
-				addEventListener(
-					type: string,
-					listener: (...args: never[]) => void,
-				): void;
-			} & DenoRawSocket;
-		};
-	};
-};
+				addEventListener(type: string, listener: (...args: never[]) => void): void
+			} & DenoRawSocket
+		}
+	}
+}
 
 type DenoRawSocket = {
-	close(code?: number, reason?: string): void;
-	readyState: number;
-	send(data: ArrayBuffer | Uint8Array | string): void;
-};
+	close(code?: number, reason?: string): void
+	readyState: number
+	send(data: ArrayBuffer | Uint8Array | string): void
+}
 
 type DenoSocket = {
 	addEventListener(type: string, listener: (...args: never[]) => void): void
@@ -36,23 +33,17 @@ type DenoSocket = {
 
 function bindHandlers(rawSocket: DenoSocket, socket: WSContextImpl<DenoRawSocket>, handler: WSHandler<unknown>): void {
 	rawSocket.addEventListener("open", () => {
-		handler.onOpen?.(undefined, socket);
-	});
-	rawSocket.addEventListener(
-		"message",
-		(evt: { data: ArrayBuffer | string }) => {
-			handler.onMessage?.(undefined, socket, evt.data);
-		},
-	);
-	rawSocket.addEventListener(
-		"close",
-		(evt: { code: number; reason: string }) => {
-			handler.onClose?.(undefined, socket, evt.code, evt.reason);
-		},
-	);
+		handler.onOpen?.(undefined, socket)
+	})
+	rawSocket.addEventListener("message", (evt: { data: ArrayBuffer | string }) => {
+		handler.onMessage?.(undefined, socket, evt.data)
+	})
+	rawSocket.addEventListener("close", (evt: { code: number; reason: string }) => {
+		handler.onClose?.(undefined, socket, evt.code, evt.reason)
+	})
 	rawSocket.addEventListener("error", (evt: unknown) => {
-		handler.onError?.(undefined, socket, evt);
-	});
+		handler.onError?.(undefined, socket, evt)
+	})
 }
 
 /**
@@ -69,9 +60,9 @@ export function denoWebSocket(): WSAdapter {
 
 	return {
 		preUpgrade(req: Request): WSPreUpgrade {
-			const denoNs = globalThis as unknown as DenoNs;
-			const { response, socket: rawSocket } = denoNs.Deno.upgradeWebSocket(req);
-			const socket = new WSContextImpl(rawSocket as DenoRawSocket);
+			const denoNs = globalThis as unknown as DenoNs
+			const { response, socket: rawSocket } = denoNs.Deno.upgradeWebSocket(req)
+			const socket = new WSContextImpl(rawSocket as DenoRawSocket)
 			const pre: WSPreUpgrade = {
 				response,
 				socket,
@@ -99,11 +90,11 @@ export function denoWebSocket(): WSAdapter {
 			}
 
 			/* globalThis cast: Deno namespace only exists at runtime on Deno — no way to type it statically */
-			const denoNs = globalThis as unknown as DenoNs;
-			const { response, socket: rawSocket } = denoNs.Deno.upgradeWebSocket(req);
-			const socket = new WSContextImpl(rawSocket as DenoRawSocket);
+			const denoNs = globalThis as unknown as DenoNs
+			const { response, socket: rawSocket } = denoNs.Deno.upgradeWebSocket(req)
+			const socket = new WSContextImpl(rawSocket as DenoRawSocket)
 			bindHandlers(rawSocket, socket, handler)
-			return { response, socket };
+			return { response, socket }
 		},
-	};
+	}
 }

package/src/ws/node.ts

@@ -1,19 +1,10 @@
-export {
-	type RawSocket,
-	type WSAdapter,
-	type WSContext,
-	WSContextImpl,
-	type WSHandler,
-} from "./cloudflare.ts"
+export { type RawSocket, type WSAdapter, type WSContext, WSContextImpl, type WSHandler } from "./cloudflare.ts"
 
 import type { WSAdapter, WSHandler } from "./cloudflare.ts"
 import { WSContextImpl } from "./cloudflare.ts"
 
 type WsModule = {
-	WebSocketServer: new (opts: {
-		noServer: true
-		perMessageDeflate: boolean
-	}) => {
+	WebSocketServer: new (opts: { noServer: true; perMessageDeflate: boolean }) => {
 		handleUpgrade(req: unknown, socket: unknown, head: unknown, cb: (ws: NodeWS) => void): void
 	}
 }
@@ -88,20 +79,14 @@ export function nodeWebSocket(opts?: { keepalive?: KeepaliveConfig }): WSAdapter
 								handler.onMessage?.(
 									undefined,
 									socket,
-									data.buffer.slice(
-										data.byteOffset,
-										data.byteOffset + data.byteLength,
-									) as ArrayBuffer,
+									data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer,
 								)
 							} else if (Array.isArray(data)) {
 								const merged = Buffer.concat(data)
 								handler.onMessage?.(
 									undefined,
 									socket,
-									merged.buffer.slice(
-										merged.byteOffset,
-										merged.byteOffset + merged.byteLength,
-									) as ArrayBuffer,
+									merged.buffer.slice(merged.byteOffset, merged.byteOffset + merged.byteLength) as ArrayBuffer,
 								)
 							} else {
 								handler.onMessage?.(undefined, socket, data)