@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/ws/bun.d.ts

@@ -1,34 +1,39 @@
-export { type RawSocket, type WSAdapter, type WSAdapterOptions, type WSContext, WSContextImpl, type WSHandler, } from "./cloudflare.ts";
-import type { WSAdapter, WSContext, WSHandler } from "./cloudflare.ts";
+/**
+ * The Bun WebSocket adapter: `server.upgrade(req)` with the connection's handler stored on the
+ * socket, and the `websocket` callbacks `Bun.serve` takes at creation (`serve(app)` passes them).
+ * Bun pings idle sockets itself (`idleTimeout`, whole seconds, at most 960) and has no error
+ * event. Bun creates the socket lazily, so the context is made on its first event, whichever it is.
+ */
+import { type WSAdapter, type WSContext, type WSHandler } from "./contract.ts";
 import { type WSAdapterOptions } from "./shared.ts";
-type BunRawSocket = {
+type BunSocketData = {
+    readonly handler: WSHandler<unknown>;
+    socket?: WSContext;
+};
+type BunSocket = {
     close(code?: number, reason?: string): void;
-    data: BunWSData;
+    readonly data: BunSocketData;
     getBufferedAmount?(): number;
-    readyState: number;
-    send(data: ArrayBufferLike | ArrayBufferView | string, compress?: boolean): number;
+    readonly readyState: number;
+    send(data: ArrayBufferLike | ArrayBufferView | string): number;
 };
-type BunWSData = {
-    handler: WSHandler<unknown>;
-    socket: WSContext;
+export type BunWebSocketHandlers = {
+    readonly backpressureLimit: number;
+    close(ws: BunSocket, code: number, reason: string): void;
+    readonly closeOnBackpressureLimit: boolean;
+    readonly idleTimeout: number;
+    readonly maxPayloadLength: number;
+    message(ws: BunSocket, data: ArrayBufferView | string): void;
+    open(ws: BunSocket): void;
 };
 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;
-    };
+    /** For `Bun.serve({ websocket })`; `serve(app)` passes it. */
+    readonly websocket: BunWebSocketHandlers;
 };
 /**
- * Bun WebSocket adapter.
- * Returns adapter + websocket handler object for Bun.serve().
- * Bun has no onError callback (noted limitation). Bun pings idle sockets itself
- * (`idleTimeout`, whole seconds, at most 960); there is no `keepalive` option.
+ * The Bun WebSocket adapter. Bun enforces `maxPayload` itself (`maxPayloadLength`), so the memory
+ * bound holds before honey sees a byte; past it Bun force-closes with 1006 and no close frame,
+ * where Node and Workers close with 1009.
  */
-export declare function bunWebSocket(opts?: WSAdapterOptions): BunWSAdapter;
-//# sourceMappingURL=bun.d.ts.map
+export declare function bunWebSocket(options?: WSAdapterOptions): BunWSAdapter;
+export {};

package/dist/ws/bun.js

@@ -1,20 +1,34 @@
-export { WSContextImpl, } from "./cloudflare.js";
-import { fireHandler, WSContextImpl } from "./cloudflare.js";
+/**
+ * The Bun WebSocket adapter: `server.upgrade(req)` with the connection's handler stored on the
+ * socket, and the `websocket` callbacks `Bun.serve` takes at creation (`serve(app)` passes them).
+ * Bun pings idle sockets itself (`idleTimeout`, whole seconds, at most 960) and has no error
+ * event. Bun creates the socket lazily, so the context is made on its first event, whichever it is.
+ */
+import { fireHandler, switchingProtocols, WSContextImpl, } from "./contract.js";
 import { resolveWSOptions, selectProtocol, toArrayBuffer } from "./shared.js";
+/** Bun's server: the env itself (`Bun.serve({ fetch: app.fetch })`) or `env.server` (`serve(app)`). */
+function serverOf(env) {
+    const candidate = env;
+    if (typeof candidate?.upgrade === "function")
+        return candidate;
+    const server = candidate?.server;
+    if (typeof server?.upgrade === "function")
+        return server;
+    throw new Error("bunWebSocket needs Bun's server: serve(app), or Bun.serve({ fetch: app.fetch, websocket })");
+}
+/** Bun's idle timeout: whole seconds, 1 to 960; 0 keeps it off. */
+function idleSeconds(ms) {
+    return ms === 0 ? 0 : Math.min(Math.max(Math.ceil(ms / 1000), 1), 960);
+}
 /**
- * Bun WebSocket adapter.
- * Returns adapter + websocket handler object for Bun.serve().
- * Bun has no onError callback (noted limitation). Bun pings idle sockets itself
- * (`idleTimeout`, whole seconds, at most 960); there is no `keepalive` option.
+ * The Bun WebSocket adapter. Bun enforces `maxPayload` itself (`maxPayloadLength`), so the memory
+ * bound holds before honey sees a byte; past it Bun force-closes with 1006 and no close frame,
+ * where Node and Workers close with 1009.
  */
-export function bunWebSocket(opts) {
-    const options = resolveWSOptions(opts);
+export function bunWebSocket(options) {
+    const resolved = resolveWSOptions(options);
     const open = new Set();
-    const socketOf = (ws) => {
-        if (!ws.data.socket)
-            ws.data.socket = new WSContextImpl(ws, options);
-        return ws.data.socket;
-    };
+    const socketOf = (ws) => (ws.data.socket ??= new WSContextImpl(ws, resolved));
     return {
         closeAll(code, reason) {
             for (const ws of open) {
@@ -26,50 +40,33 @@ export function bunWebSocket(opts) {
                 }
             }
         },
-        options,
+        options: resolved,
+        runtime: "bun",
         upgrade(req, env, handler) {
-            const server = env.server;
-            /*
-             * Socket is undefined here — Bun creates it lazily in the open callback.
-             * 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(req, {
-                data: { handler, socket: undefined },
-                headers: protocol === null ? undefined : { "sec-websocket-protocol": protocol },
-            });
-            if (!success) {
-                return {
-                    response: new Response("WebSocket upgrade failed", { status: 500 }),
-                    socket: undefined,
-                };
+            const protocol = selectProtocol(req, resolved);
+            const headers = protocol === null ? undefined : { "sec-websocket-protocol": protocol };
+            if (!serverOf(env).upgrade(req, { data: { handler }, headers })) {
+                throw new Error("Bun refused the WebSocket upgrade");
             }
-            /* Node's Response rejects status 101 (Fetch spec: 200-599 only).
-               Create a valid Response and override status for the sentinel check. */
-            const response = new Response(null);
-            Object.defineProperty(response, "status", { value: 101 });
-            return {
-                response,
-                socket: undefined,
-            };
+            /* the socket exists once Bun opens it: the callbacks below hand it to the handler */
+            return { response: switchingProtocols({ upgrade: "websocket" }), socket: undefined };
         },
         websocket: {
-            /* honey applies its own policy on send (WSContext); Bun's limit only bounds its queue */
-            backpressureLimit: Math.max(options.backpressureLimit, 1),
+            /* honey applies its own send policy (WSContext); Bun's limit only bounds its queue */
+            backpressureLimit: Math.max(resolved.backpressureLimit, 1),
             close(ws, 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,
+            idleTimeout: idleSeconds(resolved.idleTimeout),
+            maxPayloadLength: resolved.maxPayload,
             message(ws, data) {
                 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));
+                /* Bun passes a Buffer for a binary frame: hand over exactly its bytes */
+                const message = typeof data === "string" ? data : toArrayBuffer(data);
+                fireHandler("message", () => ws.data.handler.onMessage?.(undefined, socket, message));
             },
             open(ws) {
                 open.add(ws);
@@ -79,4 +76,3 @@ export function bunWebSocket(opts) {
         },
     };
 }
-//# sourceMappingURL=bun.js.map

package/dist/ws/cloudflare.d.ts

@@ -1,77 +1,8 @@
-import "./session.ts";
-import type { WSReadyState } from "../types.ts";
-import { type ResolvedWSOptions, type WSAdapterOptions } from "./shared.ts";
-export type { WSAdapterOptions } from "./shared.ts";
-export declare 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 declare class WSContextImpl<T extends RawSocket = RawSocket> implements WSContext<T> {
-    raw: T;
-    private sendBuffer;
-    private readonly limits;
-    constructor(raw: T, opts?: Pick<ResolvedWSOptions, "backpressureLimit" | "backpressurePolicy">);
-    get bufferedAmount(): number;
-    get readyState(): WSReadyState;
-    /** Send what was queued while the socket was opening (adapters without an `open` event call this). */
-    flush(): void;
-    close(code?: number, reason?: string): void;
-    send(data: ArrayBuffer | Uint8Array | object | string): void;
-}
-/** Call an adapter event on the handler; whatever it throws is logged, never thrown into the runtime. */
-export declare function fireHandler(phase: string, fn: () => unknown): void;
 /**
- * Cloudflare Workers WebSocket adapter.
- * Uses WebSocketPair + server.accept() + addEventListener. `idleTimeout` is not enforced:
- * Workers has no ping API and evicts idle sockets itself.
+ * The Cloudflare Workers WebSocket adapter: a `WebSocketPair`, the server side accepted and wired
+ * to the handler, the client side handed back in the 101. `idleTimeout` is not enforced: Workers
+ * has no ping API and evicts idle sockets itself. Set it with `app.wsAdapter(cfWebSocket())`.
  */
-export declare function cfWebSocket(opts?: WSAdapterOptions): WSAdapter;
-//# sourceMappingURL=cloudflare.d.ts.map
+import { type WSAdapter } from "./contract.ts";
+import { type WSAdapterOptions } from "./shared.ts";
+export declare function cfWebSocket(options?: WSAdapterOptions): WSAdapter;

package/dist/ws/cloudflare.js

@@ -1,117 +1,50 @@
-import "./session.js";
-import { invokeUser } from "../invoke-user.js";
-import { truncateUtf8 } from "../realtime/route.js";
-import { bufferedAmountOf, CLOSE_TOO_BIG, CLOSE_TRY_AGAIN, exceedsPayload, MAX_CLOSE_REASON, resolveWSOptions, selectProtocol, sendableCloseCode, } from "./shared.js";
-export const WS_SEND_BUFFER_MAX = 32;
-export class WSContextImpl {
-    raw;
-    sendBuffer = [];
-    limits;
-    constructor(raw, opts) {
-        this.raw = raw;
-        this.limits = opts ?? null;
-        const target = raw;
-        if (raw.readyState !== 1 && typeof target.addEventListener === "function") {
-            target.addEventListener("open", () => this.flush());
+/**
+ * The Cloudflare Workers WebSocket adapter: a `WebSocketPair`, the server side accepted and wired
+ * to the handler, the client side handed back in the 101. `idleTimeout` is not enforced: Workers
+ * has no ping API and evicts idle sockets itself. Set it with `app.wsAdapter(cfWebSocket())`.
+ */
+import { fireHandler, switchingProtocols, WSContextImpl, } from "./contract.js";
+import { CLOSE_TOO_BIG, exceedsPayload, resolveWSOptions, selectProtocol, sendableCloseCode, } from "./shared.js";
+/** Wire the accepted server side's events to `handler`. */
+function wire(server, socket, handler, maxPayload) {
+    server.addEventListener("message", (event) => {
+        const data = event.data;
+        if (exceedsPayload(data, maxPayload))
+            return socket.close(CLOSE_TOO_BIG, "message too big");
+        fireHandler("message", () => handler.onMessage?.(undefined, socket, data));
+    });
+    server.addEventListener("close", (event) => {
+        const { code, reason } = event;
+        fireHandler("close", () => handler.onClose?.(undefined, socket, code, reason));
+        /* echo the close so the client's closing handshake completes; 1005 and 1006 are never sent */
+        try {
+            server.close(sendableCloseCode(code), reason);
         }
-    }
-    get bufferedAmount() {
-        return bufferedAmountOf(this.raw);
-    }
-    get readyState() {
-        return this.raw.readyState;
-    }
-    /** Send what was queued while the socket was opening (adapters without an `open` event call this). */
-    flush() {
-        const queued = this.sendBuffer;
-        this.sendBuffer = [];
-        for (const msg of queued)
-            this.send(msg);
-    }
-    close(code, reason) {
-        this.sendBuffer = [];
-        this.raw.close(code, reason === undefined ? undefined : truncateUtf8(reason, MAX_CLOSE_REASON));
-    }
-    send(data) {
-        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;
+        catch {
+            /* already closed */
         }
-        /* 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, fn) {
-    void invokeUser(fn, { phase: `websocket ${phase}` });
+    });
+    server.addEventListener("error", (event) => {
+        fireHandler("error", () => handler.onError?.(undefined, socket, event));
+    });
 }
-/**
- * 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) {
-    const options = resolveWSOptions(opts);
+export function cfWebSocket(options) {
+    const resolved = resolveWSOptions(options);
     return {
-        options,
+        options: resolved,
+        runtime: "workers",
         upgrade(req, _env, handler) {
-            const Ctor = globalThis["WebSocketPair"];
-            const [client, server] = new Ctor();
+            const Pair = globalThis.WebSocketPair;
+            const [client, server] = new Pair();
             server.accept();
-            const socket = new WSContextImpl(server, options);
-            const raw = server;
-            if ("addEventListener" in raw) {
-                raw.addEventListener("message", (evt) => {
-                    const data = evt.data;
-                    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) => {
-                    const closeEvt = evt;
-                    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) => {
-                    fireHandler("error", () => handler.onError?.(undefined, socket, evt));
-                });
-            }
+            const socket = new WSContextImpl(server, resolved);
+            wire(server, socket, handler, resolved.maxPayload);
             fireHandler("open", () => handler.onOpen?.(undefined, socket));
             const headers = { upgrade: "websocket" };
-            const protocol = selectProtocol(req, options);
+            const protocol = selectProtocol(req, resolved);
             if (protocol !== null)
                 headers["sec-websocket-protocol"] = protocol;
-            return {
-                response: new Response(null, {
-                    headers,
-                    status: 101,
-                    webSocket: client,
-                }),
-                socket,
-            };
+            return { response: switchingProtocols(headers, { webSocket: client }), socket };
         },
     };
 }
-//# sourceMappingURL=cloudflare.js.map

package/dist/ws/contract.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The WebSocket contract every adapter and the session share: the socket a handler talks to, the
+ * route's handler, the adapter shape, and `WSContextImpl` over a runtime socket. A plain module:
+ * importing it registers nothing (H23).
+ */
+import { type InvokeLogger } from "../realtime/invoke-user.ts";
+import { type ResolvedWSOptions } from "./shared.ts";
+/** CONNECTING, OPEN, CLOSING, CLOSED. */
+export type WSReadyState = 0 | 1 | 2 | 3;
+/** Messages kept while a socket is still opening; past this the oldest goes. */
+export declare const WS_SEND_BUFFER_MAX = 32;
+export type WSContext<T = unknown> = {
+    /** Outbound bytes the runtime holds unsent, when it reports them (0 otherwise). */
+    readonly bufferedAmount?: number;
+    /** Close the connection; a reason over 123 UTF-8 bytes is cut to fit. */
+    close(code?: number, reason?: string): void;
+    readonly raw: T;
+    readonly readyState: WSReadyState;
+    /**
+     * Send a message; any other value goes as JSON. While the socket opens, the newest 32 wait
+     * for it; after it closed they are dropped. Over the adapter's backpressure limit its 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;
+    /** In place of `onOpen` when the client reconnects with a `reconnect_token`; the token is client data. */
+    onReconnect?(ctx: TCtx, ws: WSContext, token: string): Promise<void> | void;
+};
+export type WSAdapter = {
+    upgrade(req: Request, env: unknown, handler: WSHandler<unknown>): Promise<{
+        response: Response;
+        socket: WSContext;
+    }> | {
+        response: Response;
+        socket: WSContext;
+    };
+    /** Close every open connection (graceful shutdown). */
+    closeAll?(code: number, reason: string): void;
+    readonly options?: ResolvedWSOptions;
+    /** The runtime the adapter upgrades on; `serve(app)` refuses another runtime's adapter. */
+    readonly runtime?: "bun" | "node" | "workers";
+};
+export type RawSocket = {
+    close(code?: number, reason?: string): void;
+    readyState: number;
+    send(data: ArrayBuffer | Uint8Array | string): void;
+};
+type Limits = Pick<ResolvedWSOptions, "backpressureLimit" | "backpressurePolicy">;
+/** `WSContext` over a runtime socket: JSON for objects, a queue while opening, the backpressure policy. */
+export declare class WSContextImpl<T extends RawSocket = RawSocket> implements WSContext<T> {
+    #private;
+    readonly raw: T;
+    constructor(raw: T, limits?: Limits);
+    get bufferedAmount(): number;
+    get readyState(): WSReadyState;
+    /** Send what waited while the socket opened; adapters without an `open` event call this. */
+    flush(): void;
+    close(code?: number, reason?: string): void;
+    send(data: ArrayBuffer | Uint8Array | object | string): void;
+}
+/**
+ * The 101 an adapter answers an upgrade with. Workers builds a real one, carrying its socket in
+ * `init`; Fetch elsewhere refuses status 101, so there it is an empty response that reports 101:
+ * dispatch passes it on unchanged and the runtime writes the real handshake itself.
+ */
+export declare function switchingProtocols(headers: Record<string, string>, init?: Record<string, unknown>): Response;
+/** Call an adapter event on the handler; what it throws or rejects is logged, never thrown into the runtime. */
+export declare function fireHandler(phase: string, fn: () => unknown, log?: InvokeLogger | null): void;
+export {};

package/dist/ws/contract.js

@@ -0,0 +1,83 @@
+/**
+ * The WebSocket contract every adapter and the session share: the socket a handler talks to, the
+ * route's handler, the adapter shape, and `WSContextImpl` over a runtime socket. A plain module:
+ * importing it registers nothing (H23).
+ */
+import { invokeUser } from "../realtime/invoke-user.js";
+import { bufferedAmountOf, CLOSE_TRY_AGAIN, MAX_CLOSE_REASON, truncateUtf8 } from "./shared.js";
+/** Messages kept while a socket is still opening; past this the oldest goes. */
+export const WS_SEND_BUFFER_MAX = 32;
+/** `WSContext` over a runtime socket: JSON for objects, a queue while opening, the backpressure policy. */
+export class WSContextImpl {
+    raw;
+    #limits;
+    #queue = [];
+    constructor(raw, limits) {
+        this.raw = raw;
+        this.#limits = limits ?? null;
+        const target = raw;
+        if (raw.readyState !== 1 && typeof target.addEventListener === "function") {
+            target.addEventListener("open", () => this.flush());
+        }
+    }
+    get bufferedAmount() {
+        return bufferedAmountOf(this.raw);
+    }
+    get readyState() {
+        return this.raw.readyState;
+    }
+    /** Send what waited while the socket opened; adapters without an `open` event call this. */
+    flush() {
+        const queued = this.#queue;
+        this.#queue = [];
+        for (const message of queued)
+            this.send(message);
+    }
+    close(code, reason) {
+        this.#queue = [];
+        this.raw.close(code, reason === undefined ? undefined : truncateUtf8(reason, MAX_CLOSE_REASON));
+    }
+    send(data) {
+        const payload = typeof data === "string" || data instanceof ArrayBuffer || data instanceof Uint8Array
+            ? data
+            : JSON.stringify(data);
+        const state = this.raw.readyState;
+        if (state === 1)
+            return this.#sendOpen(payload);
+        /* closing or closed: nothing would ever send it */
+        if (state !== 0)
+            return;
+        if (this.#queue.length >= WS_SEND_BUFFER_MAX)
+            this.#queue.shift();
+        this.#queue.push(payload);
+    }
+    #sendOpen(payload) {
+        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);
+    }
+}
+/**
+ * The 101 an adapter answers an upgrade with. Workers builds a real one, carrying its socket in
+ * `init`; Fetch elsewhere refuses status 101, so there it is an empty response that reports 101:
+ * dispatch passes it on unchanged and the runtime writes the real handshake itself.
+ */
+export function switchingProtocols(headers, init) {
+    try {
+        return new Response(null, { ...init, headers, status: 101 });
+    }
+    catch {
+        /* Fetch refuses 101 outside Workers: expected, not a failure; the runtime writes the real handshake */
+        const response = new Response(null, { headers });
+        Object.defineProperty(response, "status", { value: 101 });
+        return response;
+    }
+}
+/** Call an adapter event on the handler; what it throws or rejects is logged, never thrown into the runtime. */
+export function fireHandler(phase, fn, log) {
+    void invokeUser(fn, { log, phase: `websocket ${phase}` });
+}

package/dist/ws/node.d.ts

@@ -1,27 +1,18 @@
-export { type RawSocket, type WSAdapter, type WSAdapterOptions, type WSContext, WSContextImpl, type WSHandler, } from "./cloudflare.ts";
-import type { WSAdapter } from "./cloudflare.ts";
+import { type WSAdapter } from "./contract.ts";
 import { type WSAdapterOptions } from "./shared.ts";
-/**
- * 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;
+/** The upgrade the Node bridge hands over on the request view. `upgraded` turns true once `ws` wrote the 101. */
+export type NodeUpgrade = {
+    readonly head: Buffer;
+    readonly req: unknown;
+    readonly socket: unknown;
     upgraded: boolean;
 };
-type KeepaliveConfig = {
-    interval: number;
-    timeout: number;
-};
+export declare const NODE_UPGRADE: unique symbol;
 export type NodeWebSocketOptions = WSAdapterOptions & {
     /** Ping every `interval` ms; a pong missing after `timeout` ms terminates the connection. */
-    keepalive?: KeepaliveConfig;
+    keepalive?: {
+        interval: number;
+        timeout: number;
+    };
 };
-/**
- * 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 declare function nodeWebSocket(opts?: NodeWebSocketOptions): WSAdapter;
-//# sourceMappingURL=node.d.ts.map
+export declare function nodeWebSocket(options?: NodeWebSocketOptions): WSAdapter;