runtime/src/index.ts - Setu-TS documentation

Classes

Bun HTTP adapter implementation.

close(handle: ServerHandle): Promise<void>
Stops the server gracefully.
fetch(request: Request): Response | Promise<Response>
The universal web-standard entry point. Accepts a web Request and returns a web Response. May be called without listen (e.g. Cloudflare Workers where export default { fetch: app.fetch } is the deploy path).
listen(
port: number,
hostname?: string
): Promise<ServerHandle>
Binds the adapter's fetch to a real TCP socket.
setHandler(handler: (request: IRequest) => IResponse | Promise<IResponse>): void
Installs the framework request handler. Called once at start() time, after the middleware pipeline compiles and before any fetch or listen.
setRpcHandler(handler: RpcFetchHandler): void
Installs a gRPC/Connect fetch handler.
setUpgradeRouter(router: WebSocketUpgradeRouter): void
Installs a WebSocket upgrade router. The adapter stores the router but does not consult it: since M70a the kernel's terminal handler resolves IWebSocketService and calls routeUpgrade itself, after the middleware pipeline has run without short-circuiting and before route matching — so an application catch-all cannot shadow an upgrade. What the adapter needs from this setter is the bare fact that a router was installed: Node attaches its raw upgrade listener only then.

CloudflareWorkersHttpAdapter(

wsHost?: CloudflareWebSocketHost,

options?: HttpAdapterOptions

)

Cloudflare Workers HTTP adapter implementation.

close(_handle: ServerHandle): Promise<void>
Stops the server gracefully.
fetch(request: Request): Response | Promise<Response>
The universal web-standard entry point. Accepts a web Request and returns a web Response. May be called without listen (e.g. Cloudflare Workers where export default { fetch: app.fetch } is the deploy path).
listen(
_port: number,
_hostname?: string
): Promise<ServerHandle>
Binds the adapter's fetch to a real TCP socket.
setHandler(handler: (request: IRequest) => IResponse | Promise<IResponse>): void
Installs the framework request handler. Called once at start() time, after the middleware pipeline compiles and before any fetch or listen.
setRpcHandler(handler: RpcFetchHandler): void
Installs a gRPC/Connect fetch handler.
setUpgradeRouter(router: WebSocketUpgradeRouter): void
Installs a WebSocket upgrade router. The adapter stores the router but does not consult it: since M70a the kernel's terminal handler resolves IWebSocketService and calls routeUpgrade itself, after the middleware pipeline has run without short-circuiting and before route matching — so an application catch-all cannot shadow an upgrade. What the adapter needs from this setter is the bare fact that a router was installed: Node attaches its raw upgrade listener only then.

DenoHttpAdapter(

host?: DenoServeHost,

options?: HttpAdapterOptions

)

Deno HTTP adapter implementation.

close(handle: ServerHandle): Promise<void>
Stops the server gracefully.
fetch(request: Request): Response | Promise<Response>
The universal web-standard entry point. Accepts a web Request and returns a web Response. May be called without listen (e.g. Cloudflare Workers where export default { fetch: app.fetch } is the deploy path).
listen(
port: number,
hostname?: string
): Promise<ServerHandle>
Binds the adapter's fetch to a real TCP socket.
setHandler(handler: (request: IRequest) => IResponse | Promise<IResponse>): void
Installs the framework request handler. Called once at start() time, after the middleware pipeline compiles and before any fetch or listen.
setRpcHandler(handler: RpcFetchHandler): void
Installs a gRPC/Connect fetch handler.
setUpgradeRouter(router: WebSocketUpgradeRouter): void
Installs a WebSocket upgrade router. The adapter stores the router but does not consult it: since M70a the kernel's terminal handler resolves IWebSocketService and calls routeUpgrade itself, after the middleware pipeline has run without short-circuiting and before route matching — so an application catch-all cannot shadow an upgrade. What the adapter needs from this setter is the bare fact that a router was installed: Node attaches its raw upgrade listener only then.

NodeHttpAdapter(

host?: NodeServeHost,

wsModule?: WsModuleLike,

options?: HttpAdapterOptions

)

Node HTTP adapter implementation.

close(handle: ServerHandle): Promise<void>
Stops the server gracefully.
fetch(request: Request): Response | Promise<Response>
The universal web-standard entry point. Accepts a web Request and returns a web Response. May be called without listen (e.g. Cloudflare Workers where export default { fetch: app.fetch } is the deploy path).
listen(
port: number,
hostname?: string
): Promise<ServerHandle>
Binds the adapter's fetch to a real TCP socket.
setHandler(handler: (request: IRequest) => IResponse | Promise<IResponse>): void
Installs the framework request handler. Called once at start() time, after the middleware pipeline compiles and before any fetch or listen.
setRpcHandler(handler: RpcFetchHandler): void
Installs a gRPC/Connect fetch handler.
setUpgradeRouter(router: WebSocketUpgradeRouter): void
Installs a WebSocket upgrade router. The adapter stores the router but does not consult it: since M70a the kernel's terminal handler resolves IWebSocketService and calls routeUpgrade itself, after the middleware pipeline has run without short-circuiting and before route matching — so an application catch-all cannot shadow an upgrade. What the adapter needs from this setter is the bare fact that a router was installed: Node attaches its raw upgrade listener only then.

NodeUpgradeCoordinator(module?: WsModuleLike)

Owns the ws server for one Node HTTP adapter and performs the handshake.

close(): void
Shuts down the ws server, when one was ever created.
handshake(
incoming: NodeIncomingMessage,
socket: unknown,
head: unknown,
sink: WebSocketEventSink,
protocol?: string
): Promise<void>
Completes the RFC 6455 handshake over an already-accepted TCP connection and binds the resulting socket to the decision's sink.
hasServer(): boolean
Whether a ws server has been created yet.

RequestBodyTooLargeError(maxBodyBytes: number)

Raised when a request body exceeds the configured RuntimeOptions.maxBodyBytes cap.

maxBodyBytes: number
The configured cap, in bytes.

RpcInterceptorStore

Stores an adapter's RPC interceptor and consults it safely.

consult(request: Request): Promise<Response | null>
Calls the installed handler. Returns the handler's response if it returns a Response, otherwise returns null.
set(handler: RpcFetchHandler): void
Installs the handler. A later call replaces the previous one.

Functions

adaptWsModule(module: unknown): WsModuleLike

Narrows an already-imported module to WsModuleLike.

asUpgradeEmitter(server: unknown): UpgradeEmitter | null

Probes a server handle for the raw upgrade event.

bindCloudflareSocketToSink(

socket: CloudflareServerSocket,

sink: WebSocketEventSink

): void

Binds a Workers server socket's events to a sink.

bindDenoSocketToSink(

socket: DenoWebSocketLike,

sink: WebSocketEventSink

): void

Binds a Deno socket's event handlers to a sink.

bindWsSocketToSink(

socket: WsSocketLike,

sink: WebSocketEventSink

): void

Binds a ws socket's events to a sink.

buildBunHost(mods?: BunModules): BunHost

Builds the default BunHost from node: built-ins, which Bun implements.

buildNodeHost(mods?: NodeModules): NodeHost

Builds the default NodeHost from node: built-ins, which Deno and Bun also implement.

createBunRuntimeServices(

host?: BunHost,

workers?: IWorkerHost,

dns?: IDnsResolver

): IRuntimeServices

Creates IRuntimeServices backed by Bun APIs.

createBunWebSocketHandlers(): BunWebSocketHandlers

Builds the serve-time handler object that routes every Bun socket event to the sink stored on that socket's data.

createCloudflareRuntimeServices(options?: CloudflareRuntimeOptions): IRuntimeServices

Creates IRuntimeServices for Cloudflare Workers.

createDefaultCloudflareWebSocketHost(): CloudflareWebSocketHost

Builds the default host from the real Workers globals.

createDenoDnsResolver(host: DenoDnsHost): IDnsResolver

Creates an IDnsResolver backed by Deno.resolveDns.

createDenoRuntimeServices(

host?: DenoHost,

workers?: IWorkerHost,

dns?: IDnsResolver

): IRuntimeServices

Creates IRuntimeServices backed by Deno APIs.

createNodeDnsResolver(dns?: NodeDnsModule): IDnsResolver

Creates an IDnsResolver backed by node:dns/promises.

createNodeRuntimeServices(

host?: NodeHost,

workers?: IWorkerHost,

dns?: IDnsResolver

): IRuntimeServices

Creates IRuntimeServices backed by Node.js APIs.

createNodeWorkerHost(mods?: NodeWorkerModules): IWorkerHost

Creates an IWorkerHost backed by node:worker_threads.

createRuntimeServices(options?: CreateRuntimeServicesOptions): IRuntimeServices

Creates runtime services for the current platform.

createUpgradeRequest(incoming: NodeIncomingMessage): Request

Reconstructs a web-standard Request from Node's upgrade event arguments, so the upgrade router sees the same shape on every runtime.

createWebSocketTransport(socket: WebSocketLike): IWebSocketTransport

Wraps a web-API socket as an IWebSocketTransport.

createWebWorkerHost(

globals?: WebWorkerGlobals,

options?: WebWorkerHostOptions

): IWorkerHost

Creates an IWorkerHost backed by the web-standard Worker API (Deno and Bun).

createWsTransport(socket: WsSocketLike): IWebSocketTransport

Wraps a ws socket as an IWebSocketTransport.

detectRuntime(globals?: GlobalScope): RuntimePlatform

Detects the current runtime platform.

isWebSocketUpgradeRequest(headers: Headers): boolean

Reports whether a set of request headers describes an RFC 6455 WebSocket upgrade.

loadWsModule(): Promise<WsModuleLike>

Lazily imports ws and narrows it.

normalizeFrame(data: unknown): string | Uint8Array

Normalizes an inbound frame payload to the framework's string | Uint8Array.

rejectRawUpgrade(

socket: RawUpgradeSocket,

status: number

): void

Refuses an upgrade on the raw socket, since there is no Response object to return on Node's upgrade path.

RuntimePlugin(options?: RuntimeOptions): IPlugin

Creates the RuntimePlugin that provides runtime-agnostic services and HTTP adapter.

toReadyState(state: number): WebSocketReadyState

Maps the web WebSocket API's numeric readyState to the framework's named WebSocketReadyState.

toTransportError(value: unknown): Error

Coerces an error-event payload into a real Error.

toWsReadyState(state: number): WebSocketReadyState

Maps a ws numeric ready state to the framework's named state.

Interfaces

BunFileInfo

File info returned by BunHost.stat().

BunHost

Minimal interface covering the Bun-specific operations used by this adapter. Inject this interface to test the adapter without real Bun.

createReadStream: (
path: string,
options?: { start?: number; end?: number; }
) => NodeJS.ReadableStream | null
Create a read stream for a file. Returns null if the file cannot be opened.
env: { [key: string]: string | undefined; }
Environment variable map.
exit: (code?: number) => never
Exit the process.
hostname: string
Returns the host name.
mkdir: (
path: string,
options?: { recursive?: boolean; }
) => boolean
Create a directory.
onSignal: (
signal: RuntimeSignal,
handler: () => void
) => void
Registers a process-termination signal listener.
readFile: (path: string) => Uint8Array | null
Read file as bytes.
readdir: (path: string) => readonly string[] | null
List directory entries.
realPath: (path: string) => string | null
Resolve a path to its canonical absolute form (null when it cannot be resolved).
rm: (
path: string,
options?: { recursive?: boolean; }
) => boolean
Remove a file or directory.
stat: (path: string) => BunFileInfo | null
Get file/directory info.
version: string
Bun version string.
writeFile: (
path: string,
data: Uint8Array
) => void
Write bytes to a file.

BunModules

The built-ins buildBunHost needs, injectable so every wrapper is unit-testable without real file-system access. Shapes match node:fs (sync), node:os, and node:process, all of which Bun implements.

bunGlobal: { version?: string; } | undefined
The Bun global when running on Bun, undefined elsewhere — read only for its version string. Required (rather than optional) so callers and tests state it explicitly and every version-resolution arm stays reachable.
fs: { createReadStream?: (
path: string,
options?: { start?: number; end?: number; }
) => NodeJS.ReadableStream | null; readFileSync(path: string): Uint8Array; realpathSync(path: string): string; writeFileSync(
path: string,
data: Uint8Array
): void; statSync(path: string): { size: number; mtime: Date; isFile(): boolean; isDirectory(): boolean; }; readdirSync(path: string): string[]; mkdirSync(
path: string,
options?: { recursive?: boolean; }
): string | undefined; rmSync(
path: string,
options?: { recursive?: boolean; }
): void; }
Synchronous file-system operations (compatible with node:fs).
hostname: () => string
Hostname function (from node:os).
proc: { version: string; versions: Record<string, string | undefined>; env: Record<string, string | undefined>; exit: (code?: number) => never; on: (
event: RuntimeSignal,
listener: () => void
) => void; }
Process object (version, env, exit, signal listening).

BunServeHost

Minimal interface covering the Bun-specific HTTP operations used by this adapter. Inject this interface to test the adapter without real Bun.

serve(options: { port: number; hostname?: string; fetch: (
request: Request,
server: BunServer
) => Response | undefined | Promise<Response | undefined>; websocket?: BunWebSocketHandlers; }): BunServer
Starts an HTTP server.

BunServer

Bun server handle (from Bun.serve).

stop(): void
Stops the server gracefully.
upgrade(
request: Request,
options: { data: BunSocketData; headers?: Headers; }
): boolean
Upgrades an inbound request to a WebSocket.

BunServerWebSocket

A Bun ServerWebSocket, narrowed to what this adapter drives.

data: BunSocketData
The data bag supplied to server.upgrade().

BunSocketData

The per-socket data Bun carries from server.upgrade() through to every socket handler.

sink: WebSocketEventSink
The sink this socket's events are routed to.

BunWebSocketHandlers

The serve-time socket handler object Bun expects under Bun.serve's websocket option.

close(
ws: BunServerWebSocket,
code: number,
reason: string
): void
Called once on close.
error(
ws: BunServerWebSocket,
error: unknown
): void
Called on transport error.
message(
ws: BunServerWebSocket,
message: string | Uint8Array
): void
Called per inbound frame.
open(ws: BunServerWebSocket): void
Called once the socket is live.

CloudflareEnv

Injectable environment seam for Cloudflare Workers bindings. Defaults to an empty record so the adapter is testable without Workers globals.

CloudflareRuntimeOptions

Options for createCloudflareRuntimeServices.

env: CloudflareEnv
Injectable env source for reading Workers bindings. Defaults to an empty record.

CloudflareServerSocket

The server half of a Workers WebSocketPair. Workers sockets are driven with addEventListener after an explicit accept(), not with on* properties.

accept(): void
Puts the server socket into the accepted state so it can send and receive.
addEventListener(
type: string,
listener: (event: never) => void
): void
Subscribes to a socket event.

CloudflareWebSocketHost

Injectable seam covering the two Workers-only globals this upgrader needs.

createPair(): CloudflareWebSocketPair
Creates a linked client/server socket pair.
createUpgradeResponse(
client: unknown,
protocol?: string
): Response
Builds the 101 response that hands the client half back to the peer.

CloudflareWebSocketPair

A created WebSocketPair: the client half travels back in the 101 response, the server half stays here.

client: unknown
The half handed to the client in the response.
server: CloudflareServerSocket
The half the server keeps.

CreateRuntimeServicesOptions

Options for createRuntimeServices.

adapters: RuntimeAdapterFactories
Replace the built-in platform → factory map.
env: Readonly<Record<string, unknown>>
The Cloudflare Workers env record, which is the only way bindings and variables reach a Worker — there is no ambient process.env on the edge.
platform: RuntimePlatform
Build services for this platform instead of auto-detecting.

DenoDirEntry

Directory entry returned by DenoHost.readdir().

name: string

DenoDnsHost

The Deno.resolveDns surface this resolver needs.

resolveDns(
query: string,
recordType: "SRV"
): Promise<DenoSrvRecord[]>
Resolves SRV records.

DenoFileInfo

File info returned by DenoHost.stat().

DenoHost

Minimal interface covering the Deno-specific operations used by this adapter. Inject this interface to test the adapter without real Deno.

addSignalListener(
signal: RuntimeSignal,
handler: () => void
): void
Registers a signal listener.
build: { os: string; }
Build metadata. Read for os alone, to decide whether signal listening is available — see createDenoRuntimeServices.
env: { toObject(): Record<string, string>; }
Environment variable map.
exit(code?: number): never
Exit the process.
hostname(): string
Returns the host name.
mkdir(
path: string,
options?: { recursive?: boolean; }
): Promise<void>
Create a directory.
open(path: string): Promise<Deno.FsFile>
Open a file for reading.
readDir(path: string): AsyncIterable<DenoDirEntry>
Lists directory entries. Named and shaped after the real API this host defaults to: Deno.readDir (capital D) returns an async iterable, so it must be consumed with for await.
readFile(path: string): Promise<Uint8Array>
Read file as bytes.
realPath(path: string): Promise<string>
Resolve a path to its canonical absolute form, following symlinks.
remove(
path: string,
options?: { recursive?: boolean; }
): Promise<void>
Remove a file or directory.
resolveDns(
query: string,
recordType: "SRV"
): Promise<DenoSrvRecord[]>
Resolves SRV records.
stat(path: string): Promise<DenoFileInfo>
Get file/directory info.
version: { deno: string; }
Current runtime version string.
writeFile(
path: string,
data: Uint8Array
): Promise<void>
Write bytes to a file.

DenoServeHost

Minimal interface covering the Deno operations this adapter needs. Inject this interface to test the adapter without real Deno.

serve(options: { port: number; hostname?: string; fetch: (request: Request) => Response | Promise<Response>; }): DenoServer
Starts an HTTP server.
upgradeWebSocket(
request: Request,
options?: { protocol?: string; }
): DenoWebSocketUpgrade
Performs an RFC 6455 handshake on an inbound request.

DenoServer

Deno HTTP server handle (from Deno.serve).

shutdown(): Promise<void>
Shuts down the server.

DenoSrvRecord

One SRV record as Deno.resolveDns returns it.

port: number
TCP port.
priority: number
RFC 2782 priority.
target: string
Target hostname.
weight: number
RFC 2782 weight.

DenoWebSocketLike

A web-API socket that exposes the on* handler properties, as Deno's upgradeWebSocket socket does.

onclose: ((event: { code: number; reason: string; }) => void) | null
Fires once on close.
onerror: ((event: unknown) => void) | null
Fires on transport error.
onmessage: ((event: { data: unknown; }) => void) | null
Fires per inbound frame.
onopen: ((event: unknown) => void) | null
Fires once the socket is writable.

DenoWebSocketUpgrade

The result shape of Deno.upgradeWebSocket.

response: Response
The 101 response that must be returned from the fetch handler.
socket: DenoWebSocketLike
The server-side socket.

GlobalScope

Minimal global scope shape needed for detection. Allows injecting a fake global for testing without as casts in test code.

HttpAdapterFactories

Map of platform → HTTP adapter factory. Used internally for dependency injection.

HttpAdapterOptions

Options every IHttpAdapter implementation in this package accepts, supplied by RuntimePlugin when it constructs one.

maxBodyBytes: number
Maximum request-body size, in bytes, enforced where the body is actually read. Omitted, the read is unbounded — the released behaviour.

NodeDnsModule

The node:dns/promises surface this resolver needs, injectable so every branch is unit-testable without real DNS or network permission.

resolve4(hostname: string): Promise<string[]>
Resolves IPv4 addresses.
resolve6(hostname: string): Promise<string[]>
Resolves IPv6 addresses.
resolveSrv(hostname: string): Promise<
{ name: string; port: number; priority: number; weight: number; }[]
>
Resolves SRV records.

NodeFsInfo

File info returned by NodeHost.stat().

NodeHost

Minimal interface covering the Node-specific operations used by this adapter. Inject this interface to test the adapter without real Node.js.

createReadStream: (
path: string,
options?: { start?: number; end?: number; }
) => NodeJS.ReadableStream | null
Create a read stream for a file. Returns null if the file cannot be opened.
env: Record<string, string | undefined>
Environment variable map.
exit: (code?: number) => never
Exit the process.
hostname: string
Host name string.
mkdir: (
path: string,
options?: { recursive?: boolean; }
) => Promise<void>
Create a directory.
nodeVersion: string
Node.js version string (e.g. "v18.19.0").
onSignal: (
signal: RuntimeSignal,
handler: () => void
) => void
Registers a process-termination signal listener.
readFile: (path: string) => Promise<Uint8Array>
Read file as bytes.
readdir: (path: string) => Promise<readonly string[]>
List directory entries.
realPath: (path: string) => Promise<string>
Resolve a path to its canonical absolute form, following symlinks.
rm: (
path: string,
options?: { recursive?: boolean; }
) => Promise<void>
Remove a file or directory.
stat: (path: string) => Promise<NodeFsInfo>
Get file/directory info.
writeFile: (
path: string,
data: Uint8Array
) => Promise<void>
Write bytes to a file.

NodeIncomingMessage

A Node IncomingMessage, narrowed to what building an upgrade Request needs.

headers: Record<string, string | string[] | undefined>
Raw headers, as Node's lowercase-keyed object.
method: string | undefined
The HTTP method.
url: string | undefined
The request target (path plus query), as Node reports it.

NodeModules

fs: NodeFsOperations
File-system operations (compatible with node:fs/promises).
hostname: () => string
Hostname function (from node:os).
proc: { version: string; env: Record<string, string | undefined>; exit: (code?: number) => never; on: (
event: RuntimeSignal,
listener: () => void
) => void; }
Process object (version, env, exit, signal listening).

NodeServeHost

Minimal interface covering the @hono/node-server serve() operation. Inject this interface to test the adapter without a real Node server.

serve(options: { fetch: (request: Request) => Response | Promise<Response>; port: number; hostname?: string; overrideGlobalObjects?: boolean; }): Promise<NodeServer>
Starts an HTTP server.

NodeServer

Node.js HTTP server handle (returned by @hono/node-server serve()).

close(): void
Stops the server gracefully.

NodeWorkerLike

Minimal shape of a node:worker_threads Worker as used by this host.

on(
event: "message" | "error" | "exit",
listener: (arg: unknown) => void
): unknown
Registers an event listener ('message' payloads arrive unwrapped; 'exit' receives the numeric exit code).
postMessage(value: unknown): void
Posts a structured-clonable message to the worker.
terminate(): Promise<number>
Terminates the worker; resolves with the exit code.

NodeWorkerModules

The Node built-ins this host needs. Inject fakes to test without real threads.

Worker: new (specifier: string | URL) => NodeWorkerLike
The worker_threads.Worker constructor.
availableParallelism: () => number
os.availableParallelism.

RawUpgradeSocket

The raw socket handed to a Node upgrade listener, narrowed to what a refusal needs.

destroy(): void
Closes the socket.
write(data: string): void
Writes bytes to the socket.

RuntimeAdapterFactories

Map of platform → runtime adapter factory.

bun: () => IRuntimeServices
Factory for Bun.
cloudflare-workers: () => IRuntimeServices
Factory for Cloudflare Workers.
deno: () => IRuntimeServices
Factory for Deno.
node: () => IRuntimeServices
Factory for Node.js.

RuntimeOptions

Options for RuntimePlugin.

adapters: RuntimeAdapterFactories
Override runtime adapter factories for testing. When provided, the plugin uses these instead of the real adapter factories, allowing unit tests to run without OS permissions or real runtime globals.
env: Readonly<Record<string, unknown>>
The Cloudflare Workers env record. There is no ambient environment on the edge, so without this runtime.env is empty on Workers and ConfigPlugin reads nothing.
httpAdapters: HttpAdapterFactories
Override HTTP adapter factories for testing. When provided, the plugin uses these instead of the default HTTP adapters, allowing unit tests to inject fake HTTP adapters.
maxBodyBytes: number
Maximum request-body size, in bytes, enforced where the body is read. Omitted, the read is unbounded — the released behaviour, byte for byte.
platform: RuntimePlatform
Force a specific platform instead of auto-detecting. Useful for testing or when running in an environment where detection might be ambiguous.

UpgradeEmitter

An event emitter that can report raw HTTP upgrades — the one capability this adapter needs from the node:http server that serve() returns.

on(
event: "upgrade",
listener: (...args: never[]) => void
): unknown
Subscribes to the raw upgrade event.

WebSocketLike

The subset of the web WebSocket API the runtime adapters drive. Declared structurally so no module depends on a platform's global types and a fake can stand in during unit tests.

close(
code?: number,
reason?: string
): void
Closes the socket.
readyState: number
Numeric ready state, per the web WebSocket API.
send(data: string | Uint8Array): void
Sends a text or binary frame.

WebWorkerGlobals

The web globals this host needs. Inject fakes to test without spawning real workers.

Worker: new (
specifier: string,
options: { type: "module"; }
) => WebWorkerLike
The Worker constructor; absent on runtimes without web workers.
hardwareConcurrency: number
Reported hardware concurrency (navigator.hardwareConcurrency).

WebWorkerHostOptions

Host-construction options that vary between the runtimes sharing this implementation.

exitEventName: string
Name of the non-standard event this runtime emits when a worker's thread ends. Bun emits 'close'; Deno emits nothing at all, so it passes nothing and the handles this host produces omit onExit entirely.

WebWorkerLike

Minimal shape of a web Worker instance as used by this host.

addEventListener(
type: string,
listener: (event: unknown) => void
): void
Registers an event listener. Only used for the runtime-specific worker-ended event named by WebWorkerHostOptions.exitEventName, which is not part of the web Worker standard and therefore has no handler slot.
onerror: ((event: unknown) => void) | null
Error handler slot; events carry a message when available.
onmessage: ((event: { data: unknown; }) => void) | null
Message handler slot; events carry the payload in data.
postMessage(message: unknown): void
Posts a structured-clonable message to the worker.
terminate(): void
Terminates the worker.

WsModuleLike

The shape of the ws module this adapter uses.

WebSocketServer: new (options: { noServer: boolean; handleProtocols?: (protocols: Set<string>) => string | false; }) => WsServerLike
The WebSocketServer constructor.

WsServerLike

A ws WebSocketServer in noServer mode, narrowed to what this adapter drives.

close(): void
Shuts the server down.
handleUpgrade(
request: unknown,
socket: unknown,
head: unknown,
callback: (ws: WsSocketLike) => void
): void
Completes the handshake over an already-accepted TCP connection.

WsSocketLike

A ws socket, narrowed to what this adapter drives. Declared structurally so the package never takes a type dependency on @types/ws.

close(
code?: number,
reason?: string
): void
Closes the socket.
on(
event: string,
listener: (...args: never[]) => void
): void
Subscribes to a socket event.
readyState: number
Numeric ready state, matching the web WebSocket API's values.
send(data: string | Uint8Array): void
Sends a text or binary frame.

Classes

Functions

Interfaces

Usage