@lovrozagar/honey 0.6.8 → 0.7.1

package/src/types.ts

@@ -136,10 +136,13 @@ export const codeToStatusKey: Record<number, StatusKey> = Object.fromEntries(
 /** Framework error keys — centralized to prevent typo-induced silent failures */
 export const EK = {
 	bad_gateway: "bad_gateway",
+	bad_request: "bad_request",
 	content_too_large: "content_too_large",
 	forbidden: "forbidden",
 	gateway_timeout: "gateway_timeout",
 	internal_server_error: "internal_server_error",
+	/** a request body the declared parser cannot read (bad JSON, broken multipart) — 400 */
+	malformed_body: "malformed_body",
 	method_not_allowed: "method_not_allowed",
 	not_found: "not_found",
 	output_content_type_mismatch: "output_content_type_mismatch",
@@ -726,6 +729,11 @@ export type InferBasePath<T> = T extends { readonly $basePath: infer P } ? P : n
 /** Merge two path segments — "/" is identity */
 export type MergePath<A extends string, B extends string> = A extends "/" ? B : B extends "/" ? A : `${A}${B}`
 
+/** The routes of a mounted sub-app, moved under the mounting handle's basePath. */
+export type PrefixRoutes<TBase extends string, TRoutes> = TBase extends "/"
+	? TRoutes
+	: { [P in keyof TRoutes & string as MergePath<TBase, P>]: TRoutes[P] }
+
 /* ── Tap types ── */
 
 /** Queued side-effect emitted by c.tap() inside a handler */

package/src/validation.ts

@@ -1,4 +1,7 @@
 import { HoneyError } from "./error.ts"
+import { parseCookieHeader } from "./cookie.ts"
+import { dict } from "./dict.ts"
+import { bodyParserFor, type BodyParser } from "./media-type.ts"
 import type {
 	FieldError,
 	InputSchemaEntry,
@@ -36,20 +39,33 @@ export function mapNormalizedCode(code: string): string {
 	return CODE_MAP[code] ?? "field_invalid"
 }
 
+/** `bodyParserFor` with both form encodings folded into `"form"`. */
 export function selectParser(contentType: string | null): "form" | "json" | null {
-	if (contentType === null) return null
-	if (contentType.startsWith("application/json")) return "json"
-	if (contentType.startsWith("multipart/form-data")) return "form"
-	if (contentType.startsWith("application/x-www-form-urlencoded")) return "form"
-	return null
+	const parser = bodyParserFor(contentType)
+	return parser === null ? null : parser === "json" ? "json" : "form"
 }
 
-/* Content-Type vs declared json/form — no body read */
+/**
+ * Throws when a route for `method` declares a `json` or `form` schema it can never receive:
+ * GET and HEAD requests cannot carry a body (Fetch forbids one). Every other method, DELETE and
+ * OPTIONS included, has its declared body validated on every request.
+ */
+export function assertBodySchemaAllowed(iv: InputSchemasDef | null, method: string, path: string): void {
+	if (iv === null || (iv.json === undefined && iv.form === undefined)) return
+	if (method !== "GET" && method !== "HEAD") return
+	const kind = iv.json !== undefined ? "json" : "form"
+	throw new Error(
+		`${method} ${path} declares a ${kind} body schema, but ${method} requests have no body. ` +
+			`Validate query data with \`search\`, or register the route for a method that carries a body.`,
+	)
+}
+
+/* Content-Type vs declared json/form — no body read. Applies to every method: a declared body
+ * is required, so a GET reaching an `all()` route with a body schema is a 415 too. */
 export function assertRequestContentType(iv: InputSchemasDef, req: Request): void {
-	const hasBody = req.method !== "DELETE" && req.method !== "GET" && req.method !== "HEAD" && req.method !== "OPTIONS"
-	if (hasBody && (iv.json || iv.form)) {
-		const parser = selectParser(req.headers.get("content-type"))
-		const ok = (iv.json && parser === "json") || (iv.form && parser === "form")
+	if (iv.json || iv.form) {
+		const parser = bodyParserFor(req.headers.get("content-type"))
+		const ok = (iv.json && parser === "json") || (iv.form && (parser === "multipart" || parser === "urlencoded"))
 		if (!ok) {
 			throw new HoneyError({
 				errorKey: EK.unsupported_media_type,
@@ -59,33 +75,8 @@ export function assertRequestContentType(iv: InputSchemasDef, req: Request): voi
 	}
 }
 
-function tryDecodeCookieValue(value: string): string {
-	try {
-		return decodeURIComponent(value)
-	} catch {
-		return value
-	}
-}
-
-export function parseCookies(header: string): Record<string, string> {
-	const result: Record<string, string> = {}
-	if (header.length === 0) return result
-	for (const pair of header.split(";")) {
-		const trimmed = pair.trim()
-		const eqIdx = trimmed.indexOf("=")
-		if (eqIdx === -1) continue
-		const name = trimmed.slice(0, eqIdx)
-		if (DANGEROUS_KEYS.has(name)) continue
-		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) {
-			value = value.slice(1, -1)
-		}
-		result[name] = value
-	}
-	return result
-}
+/** Cookie parsing lives with the serializer so the two round-trip; see `cookie.ts`. */
+export const parseCookies: (header: string) => Record<string, string> = parseCookieHeader
 
 function toPropertyKey(segment: PropertyKey | { readonly key: PropertyKey }): PropertyKey {
 	if (typeof segment === "object" && segment !== null && "key" in segment) {
@@ -122,7 +113,8 @@ export function normalizeIssues(issues: ReadonlyArray<StandardSchemaIssue>, vend
 }
 
 export function issuesToFieldErrors(issues: NormalizedIssue[], prefix: string): Record<string, FieldError[]> {
-	const fields: Record<string, FieldError[]> = {}
+	/* field names come from the request (record keys): `toString` must not find a prototype method */
+	const fields = dict<FieldError[]>()
 	for (const issue of issues) {
 		const fieldName = issue.path.at(-1)?.toString() ?? "unknown"
 		const fullPath = `${prefix}.${issue.path.map(String).join(".")}`
@@ -139,38 +131,162 @@ export function issuesToFieldErrors(issues: NormalizedIssue[], prefix: string):
 	return fields
 }
 
-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)
-		const fields = issuesToFieldErrors(normalized, prefix)
-		throw new HoneyError({
-			errorKey: EK.validation_failed,
-			fields,
-			status: SK.bad_request,
-		})
+function failValidation(schema: StandardSchemaLike, issues: ReadonlyArray<StandardSchemaIssue>, prefix: string): never {
+	const normalized = normalizeIssues(issues, schema["~standard"].vendor)
+	throw new HoneyError({
+		errorKey: EK.validation_failed,
+		fields: issuesToFieldErrors(normalized, prefix),
+		status: SK.bad_request,
+	})
+}
+
+type StandardResult = { issues?: ReadonlyArray<StandardSchemaIssue>; value?: unknown }
+
+/* Most validators answer synchronously; only a schema that returns a promise costs an await. */
+function runSchema(schema: StandardSchemaLike, data: unknown, prefix: string): unknown {
+	const result = schema["~standard"].validate(data) as StandardResult | Promise<StandardResult>
+	if (result instanceof Promise) {
+		return result.then((r) => (r.issues ? failValidation(schema, r.issues, prefix) : r.value))
 	}
-	return result.value
+	return result.issues ? failValidation(schema, result.issues, prefix) : result.value
+}
+
+/*
+ * Duplicate keys in search and form data. One policy for both:
+ *
+ * - A property the schema types as an array always gets an array, even for a single value
+ *   (`?tag=a` → `["a"]`, one uploaded file → `[File]`).
+ * - A property the schema types as a scalar gets the FIRST value, like `ctx.search` and
+ *   cookies (`role=user&role=admin` → `"user"`), so every layer that reads the key agrees.
+ * - Anything else (a union of scalar and array, an untyped or unknown key, or a schema that
+ *   cannot describe itself) gets a scalar for one value and an array for repeated values.
+ *
+ * Shapes come from the schema's Standard JSON Schema (`~standard.jsonSchema`, zod ≥ 4.2 and
+ * arktype); validators without it (valibot, yup, effect) get the last rule for every key.
+ * Cookies are always first-wins (RFC 6265 sends the most specific cookie first); headers are
+ * joined with `, ` as Fetch does.
+ */
+type KeyShape = "array" | "natural" | "scalar"
+type Shape = Map<string, KeyShape>
+
+const shapeCache = new WeakMap<object, Shape | null>()
+
+type JsonSchemaNode = {
+	$ref?: string
+	allOf?: JsonSchemaNode[]
+	anyOf?: JsonSchemaNode[]
+	oneOf?: JsonSchemaNode[]
+	properties?: Record<string, JsonSchemaNode>
+	type?: string | string[]
+	$defs?: Record<string, JsonSchemaNode>
+	definitions?: Record<string, JsonSchemaNode>
+}
+
+function deref(node: JsonSchemaNode, root: JsonSchemaNode): JsonSchemaNode {
+	const ref = node.$ref
+	if (typeof ref !== "string") return node
+	const m = /^#\/(\$defs|definitions)\/(.+)$/.exec(ref)
+	if (m === null) return node
+	const defs = m[1] === "$defs" ? root.$defs : root.definitions
+	const target = defs !== undefined && Object.hasOwn(defs, m[2]!) ? defs[m[2]!] : undefined
+	return target ?? node
 }
 
-function parseSearchParams(url: string): Record<string, string | string[]> {
-	const searchParams = new URL(url).searchParams
-	const result: Record<string, string | string[]> = {}
-	for (const [key, value] of searchParams) {
-		const existing = result[key]
-		if (existing === undefined) {
-			result[key] = value
-		} else if (Array.isArray(existing)) {
-			existing.push(value)
-		} else {
-			result[key] = [existing, value]
+function classify(node: JsonSchemaNode, root: JsonSchemaNode, depth = 0): KeyShape {
+	if (depth > 8) return "natural"
+	const n = deref(node, root)
+	const t = n.type
+	if (typeof t === "string") return t === "array" ? "array" : "scalar"
+	if (Array.isArray(t)) {
+		const nonNull = t.filter((x) => x !== "null")
+		if (nonNull.length === 0) return "natural"
+		if (nonNull.every((x) => x === "array")) return "array"
+		return nonNull.includes("array") ? "natural" : "scalar"
+	}
+	const branches = n.anyOf ?? n.oneOf
+	if (branches !== undefined && branches.length > 0) {
+		const kinds = branches.filter((b) => deref(b, root).type !== "null").map((b) => classify(b, root, depth + 1))
+		if (kinds.length === 0) return "natural"
+		if (kinds.every((k) => k === "array")) return "array"
+		if (kinds.every((k) => k === "scalar")) return "scalar"
+		return "natural"
+	}
+	if (n.allOf !== undefined && n.allOf.length > 0) {
+		const kinds = n.allOf.map((b) => classify(b, root, depth + 1))
+		if (kinds.includes("array")) return "array"
+		if (kinds.includes("scalar")) return "scalar"
+	}
+	return "natural"
+}
+
+function collectProperties(node: JsonSchemaNode, root: JsonSchemaNode, out: Shape, depth = 0): void {
+	if (depth > 8) return
+	const n = deref(node, root)
+	if (n.properties !== undefined) {
+		for (const key of Object.keys(n.properties)) {
+			if (!out.has(key)) out.set(key, classify(n.properties[key]!, root))
 		}
 	}
-	return result
+	for (const part of n.allOf ?? []) collectProperties(part, root, out, depth + 1)
+}
+
+type StandardJsonSchemaLike = {
+	input?: (opts: { libraryOptions?: Record<string, unknown>; target: string }) => unknown
+}
+
+function shapeOf(schema: StandardSchemaLike): Shape | null {
+	const cached = shapeCache.get(schema)
+	if (cached !== undefined) return cached
+	let shape: Shape | null = null
+	const js = (schema["~standard"] as { jsonSchema?: StandardJsonSchemaLike }).jsonSchema
+	if (js !== undefined && typeof js.input === "function") {
+		try {
+			const root = js.input({ libraryOptions: { unrepresentable: "any" }, target: "draft-2020-12" }) as JsonSchemaNode
+			if (root !== null && typeof root === "object") {
+				shape = new Map()
+				collectProperties(root, root, shape)
+			}
+		} catch {
+			/* a schema that cannot describe itself falls back to the natural shape */
+			shape = null
+		}
+	}
+	shapeCache.set(schema, shape)
+	return shape
+}
+
+/** Applies the duplicate-key policy to `key → values` collected in request order. */
+function shapeRecord<T>(all: Map<string, T[]>, shape: Shape | null): Record<string, T | T[]> {
+	const out = dict<T | T[]>()
+	for (const [key, values] of all) {
+		const kind = shape?.get(key) ?? "natural"
+		out[key] = kind === "array" ? values : kind === "scalar" || values.length === 1 ? values[0]! : values
+	}
+	return out
+}
+
+function collect<T>(entries: Iterable<[string, T]>, skipDangerous: boolean): Map<string, T[]> {
+	const all = new Map<string, T[]>()
+	for (const [key, value] of entries) {
+		if (skipDangerous && DANGEROUS_KEYS.has(key)) continue
+		const list = all.get(key)
+		if (list === undefined) all.set(key, [value])
+		else list.push(value)
+	}
+	return all
+}
+
+function searchEntries(req: Request, searchAll: Record<string, string[]> | undefined): Iterable<[string, string]> {
+	if (searchAll === undefined) return new URL(req.url).searchParams
+	const entries: [string, string][] = []
+	for (const key of Object.keys(searchAll)) {
+		for (const value of searchAll[key]!) entries.push([key, value])
+	}
+	return entries
 }
 
 function headersToRecord(headers: Headers): Record<string, string> {
-	const result: Record<string, string> = {}
+	const result = dict<string>()
 	headers.forEach((value, key) => {
 		result[key] = value
 	})
@@ -192,29 +308,43 @@ function resolveSchema(entry: InputSchemaEntry): ResolvedSchema {
 	return { mode: "standard", schema: entry }
 }
 
-function formDataToRecord(formData: FormData): Record<string, unknown> {
-	const record: Record<string, unknown> = {}
-	formData.forEach((value, key) => {
-		if (DANGEROUS_KEYS.has(key)) return
-		record[key] = value
-	})
-	return record
+/* A body the declared parser cannot read is the client's fault: 400 `malformed_body`, never a
+ * 500 through `onError`. Errors from reading the stream itself (a `bodyLimit` 413, a client
+ * abort) are not parse errors and pass through unchanged. */
+function malformedBody(format: BodyParser, cause: unknown): HoneyError {
+	return new HoneyError({ cause, errorKey: EK.malformed_body, status: SK.bad_request, vars: { format } })
 }
 
-function urlEncodedToRecord(body: string): Record<string, string> {
-	const params = new URLSearchParams(body)
-	const record: Record<string, string> = {}
-	params.forEach((value, key) => {
-		if (DANGEROUS_KEYS.has(key)) return
-		record[key] = value
-	})
-	return record
+async function readJson(req: Request): Promise<unknown> {
+	const text = await req.text()
+	try {
+		return JSON.parse(text) as unknown
+	} catch (err) {
+		throw malformedBody("json", err)
+	}
+}
+
+async function readForm(req: Request, parser: "multipart" | "urlencoded"): Promise<Iterable<[string, unknown]>> {
+	if (parser === "urlencoded") return new URLSearchParams(await req.text())
+	const bytes = await req.arrayBuffer()
+	try {
+		const contentType = req.headers.get("content-type") ?? ""
+		return (await new Response(bytes, { headers: { "content-type": contentType } }).formData()) as unknown as Iterable<
+			[string, unknown]
+		>
+	} catch (err) {
+		throw malformedBody("multipart", err)
+	}
 }
 
+/** What validation reads from the request context when it has one; `ctx.searchAll` is cached. */
+type ValidationSource = { readonly searchAll?: Record<string, string[]> }
+
 export async function validateInput(
 	schemas: InputSchemasDef,
 	req: Request,
 	params: Record<string, string>,
+	source?: ValidationSource,
 ): Promise<ValidatedInput> {
 	const result: ValidatedInput = {}
 
@@ -227,7 +357,8 @@ export async function validateInput(
 	/* search */
 	if (schemas.search) {
 		const { mode, schema } = resolveSchema(schemas.search)
-		const parsed = parseSearchParams(req.url)
+		const all = collect(searchEntries(req, source?.searchAll), false)
+		const parsed = shapeRecord(all, mode === "readableStream" ? null : shapeOf(schema))
 		result.search = mode === "readableStream" ? parsed : await runSchema(schema, parsed, "search")
 	}
 
@@ -246,29 +377,23 @@ export async function validateInput(
 		result.cookies = mode === "readableStream" ? parsed : await runSchema(schema, parsed, "cookies")
 	}
 
-	/* body-based: json or form — skip for methods without a request body */
-	assertRequestContentType(schemas, req)
-	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)
+	/* body: json or form, for every method that reaches here (GET/HEAD body schemas are
+	 * rejected at registration) */
+	if (schemas.json || schemas.form) {
+		assertRequestContentType(schemas, req)
+		const parser = bodyParserFor(req.headers.get("content-type"))
 
 		if (schemas.json && parser === "json") {
 			const { mode, schema } = resolveSchema(schemas.json)
-			if (mode === "readableStream") {
-				/* body untouched — handler reads ctx.req.body directly */
-			} else {
-				const body: unknown = await req.json()
-				result.json = await runSchema(schema, body, "json")
+			if (mode !== "readableStream") {
+				result.json = await runSchema(schema, await readJson(req), "json")
 			}
-		} else if (schemas.form && parser === "form") {
+			/* readableStream: body untouched — the handler reads ctx.req.body directly */
+		} else if (schemas.form && (parser === "multipart" || parser === "urlencoded")) {
 			const { mode, schema } = resolveSchema(schemas.form)
-			if (mode === "readableStream") {
-				/* body untouched — handler reads ctx.req.body directly */
-			} else if (contentType?.startsWith("multipart/form-data")) {
-				result.form = await runSchema(schema, formDataToRecord(await req.formData()), "form")
-			} else {
-				result.form = await runSchema(schema, urlEncodedToRecord(await req.text()), "form")
+			if (mode !== "readableStream") {
+				const record = shapeRecord(collect(await readForm(req, parser), true), shapeOf(schema))
+				result.form = await runSchema(schema, record, "form")
 			}
 		}
 	}

package/src/with-headers.ts

@@ -0,0 +1,45 @@
+import { isHoneyResponse } from "./honey-response.ts"
+
+/**
+ * Apply header edits to a response a middleware got back from `next()`.
+ *
+ * - `101 Switching Protocols` passes through untouched. Upgrade responses are
+ *   adapter sentinels (Node and Bun fake the status, Workers carry `webSocket`),
+ *   and rebuilding one throws or drops the socket.
+ * - Honey's own responses and `new Response()` objects are edited in place.
+ * - Responses with immutable headers (`fetch()`, `Response.redirect()`,
+ *   `cache.match()`) are copied first: same body stream, status, status text
+ *   and headers, then edited.
+ *
+ * `edit` must not read the body.
+ */
+export function withHeaders(response: Response, edit: (headers: Headers) => void): Response {
+	if (response.status === 101) return response
+	if (isHoneyResponse(response)) {
+		edit(response.headers as unknown as Headers)
+		return response
+	}
+	if (!headersAreImmutable(response)) {
+		edit(response.headers)
+		return response
+	}
+	const copy = new Response(response.body, {
+		headers: new Headers(response.headers),
+		status: response.status,
+		statusText: response.statusText,
+	})
+	edit(copy.headers)
+	return copy
+}
+
+/** Probe with a header name no one sends: immutable Headers throw on any write. */
+const PROBE = "x-honey-mutability-probe"
+
+function headersAreImmutable(response: Response): boolean {
+	try {
+		response.headers.delete(PROBE)
+		return false
+	} catch {
+		return true
+	}
+}

package/src/ws/bun.ts

@@ -1,11 +1,20 @@
-export { type RawSocket, type WSAdapter, type WSContext, WSContextImpl, type WSHandler } from "./cloudflare.ts"
+export {
+	type RawSocket,
+	type WSAdapter,
+	type WSAdapterOptions,
+	type WSContext,
+	WSContextImpl,
+	type WSHandler,
+} from "./cloudflare.ts"
 
 import type { WSAdapter, WSContext, WSHandler } from "./cloudflare.ts"
-import { WSContextImpl } from "./cloudflare.ts"
+import { fireHandler, WSContextImpl } from "./cloudflare.ts"
+import { resolveWSOptions, selectProtocol, toArrayBuffer, type WSAdapterOptions } from "./shared.ts"
 
 type BunRawSocket = {
 	close(code?: number, reason?: string): void
 	data: BunWSData
+	getBufferedAmount?(): number
 	readyState: number
 	send(data: ArrayBufferLike | ArrayBufferView | string, compress?: boolean): number
 }
@@ -16,12 +25,17 @@ type BunWSData = {
 }
 
 type BunServer = {
-	upgrade<T>(req: Request, opts?: { data?: T }): boolean
+	upgrade<T>(req: Request, opts?: { data?: T; headers?: HeadersInit }): boolean
 }
 
 export type BunWSAdapter = WSAdapter & {
+	/** Pass to `Bun.serve({ websocket })`; honey's `serve()` does. */
 	websocket: {
+		backpressureLimit: number
 		close(ws: BunRawSocket, code: number, reason: string): void
+		closeOnBackpressureLimit: boolean
+		idleTimeout: number
+		maxPayloadLength: number
 		message(ws: BunRawSocket, data: ArrayBufferView | string): void
 		open(ws: BunRawSocket): void
 	}
@@ -30,12 +44,27 @@ export type BunWSAdapter = WSAdapter & {
 /**
  * Bun WebSocket adapter.
  * Returns adapter + websocket handler object for Bun.serve().
- * Bun has no onError callback (noted limitation).
- * Keepalive is not supported — Bun's WS API lacks ping/pong control.
- * Use nodeWebSocket() for keepalive support.
+ * Bun has no onError callback (noted limitation). Bun pings idle sockets itself
+ * (`idleTimeout`, whole seconds, at most 960); there is no `keepalive` option.
  */
-export function bunWebSocket(): BunWSAdapter {
+export function bunWebSocket(opts?: WSAdapterOptions): BunWSAdapter {
+	const options = resolveWSOptions(opts)
+	const open = new Set<BunRawSocket>()
+	const socketOf = (ws: BunRawSocket): WSContext => {
+		if (!ws.data.socket) ws.data.socket = new WSContextImpl(ws, options)
+		return ws.data.socket
+	}
 	return {
+		closeAll(code: number, reason: string) {
+			for (const ws of open) {
+				try {
+					ws.close(code, reason)
+				} catch {
+					/* already closing */
+				}
+			}
+		},
+		options,
 		upgrade(req: Request, env: unknown, handler: WSHandler<unknown>) {
 			const server = (env as Record<string, unknown>).server as BunServer
 			/*
@@ -43,8 +72,10 @@ export function bunWebSocket(): BunWSAdapter {
 			 * WSContext cast is safe: actual socket is assigned in open/message/close
 			 * before any user code accesses it.
 			 */
+			const protocol = selectProtocol(req, options)
 			const success = server.upgrade<BunWSData>(req, {
 				data: { handler, socket: undefined as unknown as WSContext },
+				headers: protocol === null ? undefined : { "sec-websocket-protocol": protocol },
 			})
 			if (!success) {
 				return {
@@ -63,19 +94,26 @@ export function bunWebSocket(): BunWSAdapter {
 		},
 
 		websocket: {
+			/* honey applies its own policy on send (WSContext); Bun's limit only bounds its queue */
+			backpressureLimit: Math.max(options.backpressureLimit, 1),
 			close(ws: BunRawSocket, code: number, reason: string) {
-				if (!ws.data.socket) ws.data.socket = new WSContextImpl(ws)
-				ws.data.handler.onClose?.(undefined, ws.data.socket, code, reason)
+				open.delete(ws)
+				const socket = socketOf(ws)
+				fireHandler("close", () => ws.data.handler.onClose?.(undefined, socket, code, reason))
 			},
+			closeOnBackpressureLimit: false,
+			idleTimeout: options.idleTimeout === 0 ? 0 : Math.min(Math.max(Math.ceil(options.idleTimeout / 1000), 1), 960),
+			maxPayloadLength: options.maxPayload,
 			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)
-				ws.data.handler.onMessage?.(undefined, ws.data.socket, normalized)
+				const socket = socketOf(ws)
+				/* Bun passes a Buffer for binary frames: hand over exactly its bytes, as an ArrayBuffer */
+				const normalized = typeof data === "string" ? data : toArrayBuffer(data)
+				fireHandler("message", () => ws.data.handler.onMessage?.(undefined, socket, normalized))
 			},
 			open(ws: BunRawSocket) {
-				if (!ws.data.socket) ws.data.socket = new WSContextImpl(ws)
-				ws.data.handler.onOpen?.(undefined, ws.data.socket)
+				open.add(ws)
+				const socket = socketOf(ws)
+				fireHandler("open", () => ws.data.handler.onOpen?.(undefined, socket))
 			},
 		},
 	}