@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/src/ws/cloudflare.ts

@@ -1,192 +0,0 @@
-import "./session.ts"
-import { invokeUser } from "../invoke-user.ts"
-import { truncateUtf8 } from "../realtime/route.ts"
-import type { WSReadyState } from "../types.ts"
-import {
-	bufferedAmountOf,
-	CLOSE_TOO_BIG,
-	CLOSE_TRY_AGAIN,
-	exceedsPayload,
-	MAX_CLOSE_REASON,
-	type ResolvedWSOptions,
-	resolveWSOptions,
-	selectProtocol,
-	sendableCloseCode,
-	type WSAdapterOptions,
-} from "./shared.ts"
-
-export type { WSAdapterOptions } from "./shared.ts"
-
-export const WS_SEND_BUFFER_MAX = 32
-
-export type WSContext<T = unknown> = {
-	/** Outbound bytes the runtime holds unsent, when it reports them (0 otherwise). Adapters' sockets have it; a hand-written stub may not. */
-	readonly bufferedAmount?: number
-	/** Close the connection. A reason longer than 123 UTF-8 bytes is cut to fit. */
-	close(code?: number, reason?: string): void
-	raw: T
-	readyState: WSReadyState
-	/**
-	 * Send a message; objects are sent as JSON. While the socket is still opening, up to 32
-	 * messages wait for it; after it closed they are dropped. Over the adapter's backpressure
-	 * limit the adapter's policy applies (close with 1013, or drop).
-	 */
-	send(data: ArrayBuffer | Uint8Array | object | string): void
-}
-
-export type WSHandler<TCtx = unknown> = {
-	onClose?(ctx: TCtx, ws: WSContext, code: number, reason: string): Promise<void> | void
-	onError?(ctx: TCtx, ws: WSContext, error: unknown): Promise<void> | void
-	onMessage?(ctx: TCtx, ws: WSContext, data: ArrayBuffer | string): Promise<void> | void
-	onOpen?(ctx: TCtx, ws: WSContext): Promise<void> | void
-	onReconnect?(ctx: TCtx, ws: WSContext, token: string): Promise<void> | void
-}
-
-export type WSPreUpgrade = {
-	response: Response
-	socket: WSContext
-	/** Run `fn` now if the socket is already open, otherwise on the next open. */
-	whenOpen(fn: () => void): void
-}
-
-export type WSAdapter = {
-	upgrade(
-		req: Request,
-		env: unknown,
-		handler: WSHandler<unknown>,
-	): Promise<{ response: Response; socket: WSContext }> | { response: Response; socket: WSContext }
-	/**
-	 * Deno requires `Deno.upgradeWebSocket` in the same turn as the serve
-	 * callback. When present, Honey calls this synchronously from `fetch`
-	 * and returns `response` before any middleware Promise.
-	 */
-	preUpgrade?(req: Request): WSPreUpgrade | undefined
-	/** Close every open connection (graceful shutdown). */
-	closeAll?(code: number, reason: string): void
-	/** The adapter's resolved options. */
-	readonly options?: ResolvedWSOptions
-}
-
-export type RawSocket = {
-	close(code?: number, reason?: string): void
-	readyState: number
-	send(data: ArrayBuffer | Uint8Array | string): void
-}
-
-export class WSContextImpl<T extends RawSocket = RawSocket> implements WSContext<T> {
-	raw: T
-	private sendBuffer: Array<ArrayBuffer | Uint8Array | string> = []
-	private readonly limits: Pick<ResolvedWSOptions, "backpressureLimit" | "backpressurePolicy"> | null
-
-	constructor(raw: T, opts?: Pick<ResolvedWSOptions, "backpressureLimit" | "backpressurePolicy">) {
-		this.raw = raw
-		this.limits = opts ?? null
-		const target = raw as T & { addEventListener?(type: string, listener: () => void): void }
-		if (raw.readyState !== 1 && typeof target.addEventListener === "function") {
-			target.addEventListener("open", () => this.flush())
-		}
-	}
-
-	get bufferedAmount(): number {
-		return bufferedAmountOf(this.raw)
-	}
-
-	get readyState(): WSReadyState {
-		return this.raw.readyState as WSReadyState
-	}
-
-	/** Send what was queued while the socket was opening (adapters without an `open` event call this). */
-	flush(): void {
-		const queued = this.sendBuffer
-		this.sendBuffer = []
-		for (const msg of queued) this.send(msg)
-	}
-
-	close(code?: number, reason?: string): void {
-		this.sendBuffer = []
-		this.raw.close(code, reason === undefined ? undefined : truncateUtf8(reason, MAX_CLOSE_REASON))
-	}
-
-	send(data: ArrayBuffer | Uint8Array | object | string): void {
-		const payload =
-			typeof data === "string" || data instanceof ArrayBuffer || data instanceof Uint8Array
-				? data
-				: JSON.stringify(data)
-		const state = this.raw.readyState
-		if (state === 1) {
-			const limits = this.limits
-			if (limits !== null && limits.backpressureLimit > 0 && this.bufferedAmount > limits.backpressureLimit) {
-				if (limits.backpressurePolicy === "close") this.close(CLOSE_TRY_AGAIN, "slow consumer")
-				return
-			}
-			this.raw.send(payload)
-			return
-		}
-		/* closing or closed: nothing will ever send it */
-		if (state !== 0) return
-		if (this.sendBuffer.length >= WS_SEND_BUFFER_MAX) this.sendBuffer.shift()
-		this.sendBuffer.push(payload)
-	}
-}
-
-/** Call an adapter event on the handler; whatever it throws is logged, never thrown into the runtime. */
-export function fireHandler(phase: string, fn: () => unknown): void {
-	void invokeUser(fn, { phase: `websocket ${phase}` })
-}
-
-/**
- * Cloudflare Workers WebSocket adapter.
- * Uses WebSocketPair + server.accept() + addEventListener. `idleTimeout` is not enforced:
- * Workers has no ping API and evicts idle sockets itself.
- */
-export function cfWebSocket(opts?: WSAdapterOptions): WSAdapter {
-	const options = resolveWSOptions(opts)
-	return {
-		options,
-		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, options)
-
-			const raw = server as unknown as EventTarget & RawSocket
-			if ("addEventListener" in raw) {
-				raw.addEventListener("message", (evt: Event) => {
-					const data = (evt as MessageEvent).data as ArrayBuffer | string
-					if (exceedsPayload(data, options.maxPayload)) {
-						socket.close(CLOSE_TOO_BIG, "message too big")
-						return
-					}
-					fireHandler("message", () => handler.onMessage?.(undefined, socket, data))
-				})
-				raw.addEventListener("close", (evt: Event) => {
-					const closeEvt = evt as CloseEvent
-					fireHandler("close", () => handler.onClose?.(undefined, socket, closeEvt.code, closeEvt.reason))
-					/* echo the close frame so the client's handshake completes; 1005 and 1006 are never sent */
-					try {
-						server.close(sendableCloseCode(closeEvt.code), closeEvt.reason)
-					} catch {
-						/* already closed */
-					}
-				})
-				raw.addEventListener("error", (evt: Event) => {
-					fireHandler("error", () => handler.onError?.(undefined, socket, evt))
-				})
-			}
-			fireHandler("open", () => handler.onOpen?.(undefined, socket))
-
-			const headers: Record<string, string> = { upgrade: "websocket" }
-			const protocol = selectProtocol(req, options)
-			if (protocol !== null) headers["sec-websocket-protocol"] = protocol
-			return {
-				response: new Response(null, {
-					headers,
-					status: 101,
-					webSocket: client,
-				} as unknown as ResponseInit),
-				socket,
-			}
-		},
-	}
-}

package/src/ws/deno.ts

@@ -1,188 +0,0 @@
-export {
-	type RawSocket,
-	type WSAdapter,
-	type WSAdapterOptions,
-	type WSContext,
-	type WSPreUpgrade,
-	WSContextImpl,
-	type WSHandler,
-} from "./cloudflare.ts"
-
-import type { WSAdapter, WSHandler, WSPreUpgrade } from "./cloudflare.ts"
-import { fireHandler, WSContextImpl } from "./cloudflare.ts"
-import {
-	CLOSE_POLICY,
-	CLOSE_TOO_BIG,
-	exceedsPayload,
-	type ResolvedWSOptions,
-	resolveWSOptions,
-	selectProtocol,
-	type WSAdapterOptions,
-} from "./shared.ts"
-
-type DenoUpgradeOptions = { idleTimeout?: number; protocol?: string }
-
-type DenoNs = {
-	Deno: {
-		upgradeWebSocket(
-			req: Request,
-			opts?: DenoUpgradeOptions,
-		): {
-			response: Response
-			socket: DenoSocket
-		}
-	}
-}
-
-type DenoRawSocket = {
-	binaryType: string
-	bufferedAmount: number
-	close(code?: number, reason?: string): void
-	readyState: number
-	send(data: ArrayBuffer | Uint8Array | string): void
-}
-
-type DenoSocket = {
-	addEventListener(type: string, listener: (...args: never[]) => void): void
-} & DenoRawSocket
-
-/** Events that arrive before the route's handler is bound (the `preUpgrade` path). */
-const EARLY_EVENTS_MAX = 64
-
-type DenoEvent =
-	| { data: ArrayBuffer | string; type: "message" }
-	| { code: number; reason: string; type: "close" }
-	| { error: unknown; type: "error" }
-	| { type: "open" }
-
-/**
- * Listen on a Deno socket right away and deliver events to a handler bound later. Until then up
- * to 64 events wait (frames the client sends between the 101 and the end of the middleware
- * chain); more close the connection with 1008.
- */
-function listen(raw: DenoSocket, socket: WSContextImpl<DenoRawSocket>, options: ResolvedWSOptions) {
-	let handler: WSHandler<unknown> | null = null
-	let early: DenoEvent[] | null = []
-
-	const deliver = (evt: DenoEvent, h: WSHandler<unknown>): void => {
-		switch (evt.type) {
-			case "open":
-				fireHandler("open", () => h.onOpen?.(undefined, socket))
-				return
-			case "message":
-				fireHandler("message", () => h.onMessage?.(undefined, socket, evt.data))
-				return
-			case "close":
-				fireHandler("close", () => h.onClose?.(undefined, socket, evt.code, evt.reason))
-				return
-			case "error":
-				fireHandler("error", () => h.onError?.(undefined, socket, evt.error))
-		}
-	}
-
-	const push = (evt: DenoEvent): void => {
-		if (handler !== null) {
-			deliver(evt, handler)
-			return
-		}
-		if (early === null) return
-		if (early.length >= EARLY_EVENTS_MAX && evt.type === "message") {
-			early = null
-			socket.close(CLOSE_POLICY, "too many messages before the handler was ready")
-			return
-		}
-		early.push(evt)
-	}
-
-	raw.addEventListener("open", () => push({ type: "open" }))
-	raw.addEventListener("message", (evt: { data: ArrayBuffer | string }) => {
-		if (exceedsPayload(evt.data, options.maxPayload)) {
-			socket.close(CLOSE_TOO_BIG, "message too big")
-			return
-		}
-		push({ data: evt.data, type: "message" })
-	})
-	raw.addEventListener("close", (evt: { code: number; reason: string }) =>
-		push({ code: evt.code, reason: evt.reason, type: "close" }),
-	)
-	raw.addEventListener("error", (evt: unknown) => push({ error: evt, type: "error" }))
-
-	return {
-		bind(h: WSHandler<unknown>): void {
-			handler = h
-			const queued = early ?? []
-			early = null
-			for (const evt of queued) deliver(evt, h)
-		},
-	}
-}
-
-/**
- * Deno WebSocket adapter.
- * Uses Deno.upgradeWebSocket() and addEventListener for event binding.
- * Deno pings idle sockets itself (`idleTimeout`, whole seconds); there is no `keepalive` option.
- *
- * `preUpgrade` calls `Deno.upgradeWebSocket` in the same turn as the serve
- * callback (Deno rejects upgrades performed after the first await).
- */
-export function denoWebSocket(opts?: WSAdapterOptions): WSAdapter {
-	const options = resolveWSOptions(opts)
-	const pending = new WeakMap<Request, { bind(h: WSHandler<unknown>): void; pre: WSPreUpgrade }>()
-	const open = new Set<WSContextImpl<DenoRawSocket>>()
-
-	const start = (req: Request) => {
-		const denoNs = globalThis as unknown as DenoNs
-		const protocol = selectProtocol(req, options)
-		const upgradeOpts: DenoUpgradeOptions = {}
-		if (protocol !== null) upgradeOpts.protocol = protocol
-		if (options.idleTimeout > 0) upgradeOpts.idleTimeout = Math.max(Math.ceil(options.idleTimeout / 1000), 1)
-		const { response, socket: rawSocket } = denoNs.Deno.upgradeWebSocket(req, upgradeOpts)
-		/* binary frames arrive as ArrayBuffer, as on every other runtime (Deno's default is Blob) */
-		rawSocket.binaryType = "arraybuffer"
-		const socket = new WSContextImpl(rawSocket as DenoRawSocket, options)
-		open.add(socket)
-		rawSocket.addEventListener("close", () => open.delete(socket))
-		const listener = listen(rawSocket, socket, options)
-		return { listener, rawSocket, response, socket }
-	}
-
-	return {
-		closeAll(code: number, reason: string) {
-			for (const socket of open) {
-				try {
-					socket.close(code, reason)
-				} catch {
-					/* already closing */
-				}
-			}
-		},
-		options,
-		preUpgrade(req: Request): WSPreUpgrade {
-			const { listener, rawSocket, response, socket } = start(req)
-			const pre: WSPreUpgrade = {
-				response,
-				socket,
-				whenOpen(fn: () => void) {
-					if (rawSocket.readyState === 1) {
-						fn()
-						return
-					}
-					rawSocket.addEventListener("open", () => fn())
-				},
-			}
-			pending.set(req, { bind: listener.bind, pre })
-			return pre
-		},
-		upgrade(req: Request, _env: unknown, handler: WSHandler<unknown>) {
-			const held = pending.get(req)
-			if (held) {
-				pending.delete(req)
-				held.bind(handler)
-				return held.pre
-			}
-			const { listener, response, socket } = start(req)
-			listener.bind(handler)
-			return { response, socket }
-		},
-	}
-}

package/src/ws/node.ts

@@ -1,240 +0,0 @@
-export {
-	type RawSocket,
-	type WSAdapter,
-	type WSAdapterOptions,
-	type WSContext,
-	WSContextImpl,
-	type WSHandler,
-} from "./cloudflare.ts"
-
-import type { WSAdapter, WSHandler } from "./cloudflare.ts"
-import { fireHandler, WSContextImpl } from "./cloudflare.ts"
-import {
-	type ResolvedWSOptions,
-	resolveWSOptions,
-	selectProtocol,
-	toArrayBuffer,
-	type WSAdapterOptions,
-} from "./shared.ts"
-
-type WebSocketServerOptions = {
-	handleProtocols?: (protocols: Set<string>, req: unknown) => string | false
-	maxPayload: number
-	noServer: true
-	perMessageDeflate: boolean
-}
-
-type WsModule = {
-	WebSocketServer: new (opts: WebSocketServerOptions) => WssInstance
-}
-
-type NodeWS = {
-	binaryType: string
-	bufferedAmount: number
-	close(code?: number, reason?: string): void
-	on(event: "close", cb: (code: number, reason: Buffer) => void): void
-	on(event: "error", cb: (err: unknown) => void): void
-	on(event: "message", cb: (data: ArrayBuffer | Buffer | Buffer[], isBinary: boolean) => void): void
-	on(event: "pong" | "ping", cb: () => void): void
-	ping(): void
-	readyState: number
-	send(data: ArrayBuffer | Buffer | Uint8Array | string): void
-	terminate(): void
-}
-
-/**
- * What the Node adapter (`serve()`) puts on `env.__nodeUpgrade`. `upgraded` turns true once the
- * 101 is written: from then on the socket belongs to `ws`, and the adapter must not write to it.
- */
-export type NodeUpgradeData = {
-	head: Buffer
-	req: unknown
-	socket: unknown
-	upgraded: boolean
-}
-
-type WssInstance = {
-	handleUpgrade(req: unknown, socket: unknown, head: unknown, cb: (ws: NodeWS) => void): void
-}
-
-type KeepaliveConfig = {
-	interval: number
-	timeout: number
-}
-
-export type NodeWebSocketOptions = WSAdapterOptions & {
-	/** Ping every `interval` ms; a pong missing after `timeout` ms terminates the connection. */
-	keepalive?: KeepaliveConfig
-}
-
-const WS_MISSING =
-	'WebSocket routes on Node need the "ws" package, which is an optional peer dependency of honey. Install it: npm install ws'
-
-/**
- * Node.js WebSocket adapter, on the `ws` package (an optional peer dependency). It reads
- * `env.__nodeUpgrade`, which honey's `serve()` puts there for an upgrade request.
- */
-export function nodeWebSocket(opts?: NodeWebSocketOptions): WSAdapter {
-	const options: ResolvedWSOptions = resolveWSOptions(opts)
-	const keepalive = opts?.keepalive
-	if (keepalive !== undefined && !(keepalive.interval > 0 && keepalive.timeout > 0)) {
-		throw new TypeError("nodeWebSocket: keepalive.interval and keepalive.timeout must be positive")
-	}
-	let wss: WssInstance | null = null
-	let wssReady: Promise<WssInstance> | null = null
-	const open = new Set<NodeWS>()
-	/* the Request being upgraded, for the protocol callback (ws hands it the IncomingMessage) */
-	let upgrading: Request | null = null
-
-	const ensureWss = (): Promise<WssInstance> => {
-		if (wss) return Promise.resolve(wss)
-		if (!wssReady) {
-			wssReady = import("ws").then(
-				(mod) => {
-					const wsModule = mod as unknown as WsModule
-					wss = new wsModule.WebSocketServer({
-						handleProtocols: (protocols) => {
-							if (protocols.size === 0 || upgrading === null) return false
-							return selectProtocol(upgrading, options) ?? false
-						},
-						maxPayload: options.maxPayload,
-						noServer: true,
-						perMessageDeflate: false,
-					})
-					return wss
-				},
-				(err: unknown) => {
-					/* not cached: installing ws later works without a restart */
-					wssReady = null
-					throw new Error(WS_MISSING, { cause: err })
-				},
-			)
-		}
-		return wssReady
-	}
-
-	const watch = (ws: NodeWS): void => {
-		let pingTimer: ReturnType<typeof setInterval> | undefined
-		let pongTimeout: ReturnType<typeof setTimeout> | undefined
-		let idleTimer: ReturnType<typeof setInterval> | undefined
-		let lastSeen = Date.now()
-		const seen = (): void => {
-			lastSeen = Date.now()
-		}
-
-		ws.on("pong", () => {
-			seen()
-			if (pongTimeout !== undefined) {
-				clearTimeout(pongTimeout)
-				pongTimeout = undefined
-			}
-		})
-		ws.on("ping", seen)
-
-		if (keepalive) {
-			pingTimer = setInterval(() => {
-				if (ws.readyState !== 1) return
-				/* one pong outstanding at a time: a slow pong must not stack timers */
-				if (pongTimeout !== undefined) return
-				ws.ping()
-				pongTimeout = setTimeout(() => ws.terminate(), keepalive.timeout)
-			}, keepalive.interval)
-		}
-
-		const idle = options.idleTimeout
-		if (idle > 0) {
-			const tick = Math.max(Math.floor(idle / 2), 1)
-			idleTimer = setInterval(() => {
-				if (ws.readyState !== 1) return
-				const quiet = Date.now() - lastSeen
-				if (quiet >= idle) ws.terminate()
-				else if (quiet >= tick) ws.ping()
-			}, tick)
-		}
-
-		const stop = (): void => {
-			if (pingTimer !== undefined) clearInterval(pingTimer)
-			if (pongTimeout !== undefined) clearTimeout(pongTimeout)
-			if (idleTimer !== undefined) clearInterval(idleTimer)
-			pingTimer = pongTimeout = idleTimer = undefined
-		}
-		ws.on("close", stop)
-		ws.on("error", stop)
-	}
-
-	return {
-		closeAll(code: number, reason: string) {
-			for (const ws of open) {
-				try {
-					ws.close(code, reason)
-				} catch {
-					ws.terminate()
-				}
-			}
-		},
-		options,
-		async upgrade(req: Request, env: unknown, handler: WSHandler<unknown>) {
-			const server = await ensureWss()
-			const upgrade = (env as Record<string, unknown>).__nodeUpgrade as NodeUpgradeData | undefined
-			if (upgrade === undefined) {
-				throw new Error("nodeWebSocket: no upgrade socket; serve the app with honey's serve() on Node")
-			}
-
-			return new Promise((resolve, reject) => {
-				/* ws answers a malformed handshake itself and never calls back: fail instead of hanging */
-				const sock = upgrade.socket as { once?(event: "close", cb: () => void): void }
-				sock.once?.("close", () => {
-					if (!upgrade.upgraded) reject(new Error("WebSocket handshake failed"))
-				})
-				upgrading = req
-				try {
-					server.handleUpgrade(upgrade.req, upgrade.socket, upgrade.head, (ws: NodeWS) => {
-						upgrade.upgraded = true
-						ws.binaryType = "arraybuffer"
-						open.add(ws)
-						const socket = new WSContextImpl(ws, options)
-
-						ws.on("message", (data: ArrayBuffer | Buffer | Buffer[], isBinary: boolean) => {
-							let payload: ArrayBuffer | string
-							if (!isBinary) {
-								/* text frame: a string, as on every other runtime */
-								payload = Buffer.isBuffer(data)
-									? data.toString("utf-8")
-									: data instanceof ArrayBuffer
-										? Buffer.from(data).toString("utf-8")
-										: Buffer.concat(data).toString("utf-8")
-							} else if (data instanceof ArrayBuffer) {
-								payload = data
-							} else {
-								payload = toArrayBuffer(Array.isArray(data) ? Buffer.concat(data) : data)
-							}
-							fireHandler("message", () => handler.onMessage?.(undefined, socket, payload))
-						})
-						watch(ws)
-
-						ws.on("close", (code: number, reason: Buffer) => {
-							open.delete(ws)
-							fireHandler("close", () => handler.onClose?.(undefined, socket, code, reason.toString()))
-						})
-
-						ws.on("error", (err: unknown) => {
-							fireHandler("error", () => handler.onError?.(undefined, socket, err))
-						})
-
-						fireHandler("open", () => handler.onOpen?.(undefined, socket))
-
-						/* Node's Response rejects status 101 (Fetch spec: 200-599 only).
-						   Create a valid Response and override status for the sentinel check. */
-						const resp = new Response(null)
-						Object.defineProperty(resp, "status", { value: 101 })
-						resolve({ response: resp, socket })
-					})
-				} catch (err) {
-					reject(err)
-				} finally {
-					upgrading = null
-				}
-			})
-		},
-	}
-}

package/src/ws/session.ts

@@ -1,73 +0,0 @@
-/**
- * The server side of one websocket route connection: the user's callbacks run on one ordered
- * queue (open, then messages, then close), each contained, with a cap on waiting messages.
- * Every honey adapter imports this module, which registers it, so the core never bundles it
- * for an app without websockets.
- */
-import { registerFeature } from "../feature-slots.ts"
-import { createEventQueue, invokeUser, type InvokeLogger } from "../invoke-user.ts"
-import { originAllowed } from "../ws-origin.ts"
-import type { WSContext, WSHandler } from "./cloudflare.ts"
-
-/** Messages one websocket connection may have waiting for its handler; more close it with 1008. */
-const WS_PENDING_MAX = 1024
-
-/** `callbacks` are the route's own; each receives the route's request context `ctx` first. */
-export function createWsSession(opts: {
-	callbacks: WSHandler<unknown>
-	ctx: unknown
-	log: InvokeLogger | null
-	reconnectToken: string | null
-	route: string
-}): WSHandler<unknown> {
-	const { callbacks, ctx, log, reconnectToken, route } = opts
-	const { onClose, onError, onMessage, onOpen, onReconnect } = callbacks
-	const queue = createEventQueue()
-	let pending = 0
-
-	const run = (phase: string, ws: WSContext, fn: () => unknown): Promise<unknown> =>
-		invokeUser(fn, {
-			fields: { route },
-			log,
-			onError: onError ? (err) => onError(ctx, ws, err) : null,
-			phase: `websocket ${phase}`,
-		})
-
-	return {
-		onClose: (_ctx, ws, code, reason) => {
-			if (onClose) void queue.push(() => run("close", ws, () => onClose(ctx, ws, code, reason)))
-		},
-		/* a transport error: tell onError once; if onError throws, that is logged */
-		onError: (_ctx, ws, error) => {
-			void queue.push(() =>
-				invokeUser(() => (onError ? onError(ctx, ws, error) : Promise.reject(error)), {
-					fields: { route },
-					log,
-					phase: "websocket error",
-				}),
-			)
-		},
-		onMessage: (_ctx, ws, data) => {
-			if (!onMessage) return
-			if (pending >= WS_PENDING_MAX) {
-				ws.close(1008, "too many pending messages")
-				return
-			}
-			pending++
-			void queue.push(() =>
-				run("message", ws, () => onMessage(ctx, ws, data)).finally(() => {
-					pending--
-				}),
-			)
-		},
-		onOpen: (_ctx, ws) => {
-			if (reconnectToken && onReconnect) {
-				void queue.push(() => run("open", ws, () => onReconnect(ctx, ws, reconnectToken)))
-			} else if (onOpen) {
-				void queue.push(() => run("open", ws, () => onOpen(ctx, ws)))
-			}
-		},
-	}
-}
-
-registerFeature("ws", { createWsSession, originAllowed })