@nifrajs/node 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,696 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Run a nifra app (or any Web-`fetch` handler) on Node's `http` server.
+ *
+ *   import { serve } from "@nifrajs/node"
+ *   import { server } from "@nifrajs/core"
+ *   const app = server().get("/", () => ({ ok: true }))
+ *   serve(app, { port: 3000 })
+ *
+ * nifra's lifecycle is `app.fetch(Request): Response | Promise<Response>` — pure Web Standards —
+ * so this adapter just bridges Node's stream-based `(req, res)` to/from Web
+ * `Request`/`Response`, plus a Bun-`listen()`-style graceful `stop()`.
+ */
+import { open } from "node:fs/promises";
+import { createServer, } from "node:http";
+import { extname, resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+/**
+ * The `Content-Type` the host runtime's `Response.json` emits — Node's undici uses `application/json`,
+ * Bun uses `application/json;charset=utf-8`. Probed once at module load (zero per-request cost) so the
+ * fast path is byte-for-byte identical to the `Response`-building path on whatever runtime hosts us.
+ */
+const JSON_CONTENT_TYPE = Response.json(0).headers.get("content-type") ?? "application/json";
+const INTERNAL_ERROR_BODY = '{"ok":false,"error":"internal_error"}';
+const EMPTY_BUFFER = Buffer.alloc(0);
+const NODE_RESPONSE_BODY = Symbol.for("nifra.response.body");
+const DEFAULT_DRAIN_MS = 10_000;
+const DRAIN_POLL_MS = 10;
+const STATIC_CONTENT_TYPES = {
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".html": "text/html; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".map": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".wasm": "application/wasm",
+    ".txt": "text/plain; charset=utf-8",
+    ".webmanifest": "application/manifest+json",
+};
+function staticStateOf(options) {
+    const root = resolve(typeof options.dir === "string" ? options.dir : fileURLToPath(options.dir));
+    const raw = options.prefix ?? "/assets";
+    const prefix = raw === "/" ? "/" : `/${raw.replace(/^\/+|\/+$/g, "")}`;
+    return { root, prefix, immutable: options.immutable !== false, headers: options.headers };
+}
+/**
+ * Resolve a request URL to a file under the served root — **synchronously**, so non-matching requests
+ * stay on the app's sync fast path. Returns `"pass"` (let the app handle it), a rejection `Response`
+ * (malformed encoding / NUL / `..` traversal out of root), or a confined absolute file path to read.
+ */
+function staticMatch(state, rawUrl) {
+    const query = rawUrl.indexOf("?");
+    const path = query === -1 ? rawUrl : rawUrl.slice(0, query);
+    const underPrefix = state.prefix === "/" ? true : path === state.prefix || path.startsWith(`${state.prefix}/`);
+    if (!underPrefix)
+        return "pass";
+    let rel;
+    try {
+        rel = decodeURIComponent(state.prefix === "/" ? path : path.slice(state.prefix.length));
+    }
+    catch {
+        return { reject: new Response("Bad Request", { status: 400 }) };
+    }
+    rel = rel.replace(/^\/+/, "");
+    if (rel === "" || rel.endsWith("/"))
+        return "pass"; // a directory request → the app decides
+    if (rel.includes("\0"))
+        return { reject: new Response("Bad Request", { status: 400 }) };
+    const file = resolve(state.root, rel);
+    // Confine to the served directory — block `..` from escaping root.
+    if (file !== state.root && !file.startsWith(state.root + sep)) {
+        return { reject: new Response("Forbidden", { status: 403 }) };
+    }
+    return { file };
+}
+async function readStatic(file, state, method) {
+    let handle;
+    try {
+        handle = await open(file, "r");
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            await handle.close();
+            return { kind: "response", response: new Response("Not Found", { status: 404 }) };
+        }
+        const headers = { ...state.headers };
+        headers["content-type"] =
+            STATIC_CONTENT_TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
+        headers["content-length"] = String(stat.size);
+        if (state.immutable && headers["cache-control"] === undefined) {
+            headers["cache-control"] = "public, max-age=31536000, immutable";
+        }
+        if (method === "HEAD") {
+            await handle.close();
+            return { kind: "response", response: new Response(null, { headers }) };
+        }
+        const stream = handle.createReadStream();
+        return {
+            kind: "response",
+            response: new Response(Readable.toWeb(stream), { headers }),
+        };
+    }
+    catch {
+        await handle?.close().catch(() => { });
+        // Missing/unreadable under the static prefix → 404 (don't fall through to an SSR 404 page).
+        return { kind: "response", response: new Response("Not Found", { status: 404 }) };
+    }
+}
+/**
+ * Serve a Web-`fetch` app on a Node `http` server. Resolves once bound — Node binds
+ * the port asynchronously, so awaiting gives you the real port (matters for `port: 0`).
+ */
+export function serve(app, options) {
+    let inFlight = 0;
+    let closed = false;
+    const protocol = protocolResolver(options.protocol);
+    const staticState = options.static !== undefined ? staticStateOf(options.static) : undefined;
+    const server = createServer((nodeReq, nodeRes) => {
+        inFlight += 1;
+        try {
+            const handled = handle(app, nodeReq, nodeRes, protocol, staticState);
+            if (handled instanceof Promise) {
+                void handled.finally(() => {
+                    inFlight -= 1;
+                });
+                return;
+            }
+            inFlight -= 1;
+        }
+        catch {
+            writeInternalError(nodeRes);
+            inFlight -= 1;
+        }
+    });
+    // WebSocket upgrades (a nifra app exposing the seam): handled on the http server's `upgrade` event via
+    // the optional `ws` package — lazy-imported (and the server lazily built) on the FIRST real WS
+    // upgrade, so a non-WS Node app never loads `ws`.
+    const resolveWs = app.resolveWebSocketUpgrade?.bind(app);
+    if (resolveWs !== undefined) {
+        let wssPromise;
+        server.on("upgrade", (nodeReq, socket, head) => {
+            void handleUpgrade(resolveWs, protocol, nodeReq, socket, head, () => {
+                wssPromise ??= loadWsServer();
+                return wssPromise;
+            });
+        });
+    }
+    // Opt-in: own SIGTERM/SIGINT so `docker stop` / Ctrl-C drains in-flight requests
+    // before exit. `stop` is hoisted, so `onSignal` can reference it.
+    const onSignal = () => {
+        void stop();
+    };
+    async function stop({ drainMs = DEFAULT_DRAIN_MS } = {}) {
+        if (closed)
+            return; // idempotent
+        closed = true;
+        if (options.signals === true) {
+            // Remove our own handlers so repeated serve()/stop() cycles don't leak listeners.
+            process.removeListener("SIGTERM", onSignal);
+            process.removeListener("SIGINT", onSignal);
+        }
+        server.close(); // stop accepting new connections; existing requests continue
+        const deadline = Date.now() + drainMs;
+        while (inFlight > 0 && Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, DRAIN_POLL_MS));
+        }
+        server.closeAllConnections(); // force-close stragglers + idle keep-alive sockets
+    }
+    return new Promise((resolve) => {
+        server.listen(options.port, options.hostname, () => {
+            const address = server.address();
+            const port = address !== null && typeof address === "object" ? address.port : options.port;
+            if (options.signals === true) {
+                process.once("SIGTERM", onSignal);
+                process.once("SIGINT", onSignal);
+            }
+            resolve({ port, stop });
+        });
+    });
+}
+function handle(app, nodeReq, nodeRes, getProtocol, staticState) {
+    let protocol;
+    try {
+        protocol = getProtocol(nodeReq);
+    }
+    catch {
+        writeInternalError(nodeRes);
+        return;
+    }
+    // Static files first (GET/HEAD). The match is synchronous, so a non-asset request never leaves the
+    // app's sync fast path below; only a prefix hit reads from disk (and async-writes the file).
+    if (staticState !== undefined && (nodeReq.method === "GET" || nodeReq.method === "HEAD")) {
+        const matched = staticMatch(staticState, nodeReq.url ?? "/");
+        if (matched !== "pass") {
+            if ("reject" in matched)
+                return writeNodeResponse(matched.reject, nodeRes);
+            return readStatic(matched.file, staticState, nodeReq.method ?? "GET").then((outcome) => writeNodeOutcome(outcome, nodeRes), () => writeInternalError(nodeRes));
+        }
+    }
+    // Fast path: a nifra app exposes `resolveNode`, which renders a plain-data result as primitives we
+    // write straight to the socket — skipping the undici `Response` build + body drain (the bulk of the
+    // Web-bridge cost on Node). A handler-returned `Response`/redirect, 404/405, error, timeout, or any
+    // `onResponse` hook comes back as `{ kind: "response" }` and takes the same Web path as before, so
+    // behavior is identical. A plain `{ fetch }` handler (no `resolveNode`) uses the Web path too.
+    const resolveNodeSource = app.resolveNodeSource;
+    if (typeof resolveNodeSource === "function") {
+        try {
+            const outcome = resolveNodeSource.call(app, toNodeRequestSource(nodeReq, protocol));
+            return outcome instanceof Promise
+                ? outcome.then((settled) => writeNodeOutcome(settled, nodeRes), () => writeInternalError(nodeRes))
+                : writeNodeOutcome(outcome, nodeRes);
+        }
+        catch {
+            writeInternalError(nodeRes);
+            return;
+        }
+    }
+    const request = toWebRequest(nodeReq, protocol);
+    const resolveNode = app.resolveNode;
+    if (typeof resolveNode === "function") {
+        try {
+            const outcome = resolveNode.call(app, request);
+            return outcome instanceof Promise
+                ? outcome.then((settled) => writeNodeOutcome(settled, nodeRes), () => writeInternalError(nodeRes))
+                : writeNodeOutcome(outcome, nodeRes);
+        }
+        catch {
+            writeInternalError(nodeRes);
+            return;
+        }
+    }
+    try {
+        const response = app.fetch(request);
+        return response instanceof Promise
+            ? response.then((settled) => writeNodeResponse(settled, nodeRes), () => writeInternalError(nodeRes))
+            : writeNodeResponse(response, nodeRes);
+    }
+    catch {
+        // The app should never throw (nifra returns a 500), but never leak a stack to the wire.
+        writeInternalError(nodeRes);
+        return;
+    }
+}
+function writeNodeOutcome(outcome, nodeRes) {
+    if (outcome.kind === "json") {
+        writeJsonOutcome(outcome, nodeRes);
+        return;
+    }
+    if (outcome.kind === "body") {
+        writeBodyOutcome(outcome, nodeRes);
+        return;
+    }
+    return writeNodeResponse(outcome.response, nodeRes);
+}
+/** A flat 500 with no leaked detail — the adapter's last-resort guard if a handler throws. */
+function writeInternalError(nodeRes) {
+    nodeRes.writeHead(500, { "content-type": "application/json" });
+    nodeRes.end(INTERNAL_ERROR_BODY);
+}
+/**
+ * Serialize a node-direct JSON outcome straight to the socket — no undici `Response`, no stream drain.
+ * Mirrors `Response.json(data, { status, headers })` byte-for-byte: user headers are lowercased to
+ * match undici's `Headers` normalization, the JSON `Content-Type` matches the host runtime's, and each
+ * queued cookie is emitted as its own `Set-Cookie` line (never comma-joined).
+ */
+function writeJsonOutcome(outcome, nodeRes) {
+    const headers = {};
+    if (outcome.headers !== undefined) {
+        for (const [key, value] of Object.entries(outcome.headers))
+            headers[key.toLowerCase()] = value;
+    }
+    // A `null` body is a 204/no-content render — `new Response(null)` carries no Content-Type, so we add
+    // none either; a non-null body is JSON, matching `Response.json`'s Content-Type.
+    if (outcome.body !== null)
+        headers["content-type"] = JSON_CONTENT_TYPE;
+    if (outcome.cookies !== undefined && outcome.cookies.length > 0) {
+        headers["set-cookie"] = [...outcome.cookies];
+    }
+    nodeRes.writeHead(outcome.status, headers);
+    if (outcome.body !== null)
+        nodeRes.end(outcome.body);
+    else
+        nodeRes.end();
+}
+/**
+ * Write a node-direct buffered body outcome straight to the socket. This is the Response-shaped
+ * sibling of `writeJsonOutcome`: headers/status were already normalized by core, and the body is the
+ * exact marked payload from the Response producer, so there is no Web body reader to drain.
+ */
+function writeBodyOutcome(outcome, nodeRes) {
+    const headers = {};
+    if (outcome.headers !== undefined) {
+        for (const [key, value] of Object.entries(outcome.headers)) {
+            headers[key] = typeof value === "string" ? value : [...value];
+        }
+    }
+    nodeRes.writeHead(outcome.status, headers);
+    nodeRes.end(outcome.body);
+}
+function protocolResolver(option) {
+    if (option === undefined)
+        return () => "http";
+    if (typeof option === "function")
+        return (req) => normalizeProtocol(option(req));
+    const protocol = normalizeProtocol(option);
+    return () => protocol;
+}
+function normalizeProtocol(value) {
+    if (value === "http" || value === "https")
+        return value;
+    throw new Error(`@nifrajs/node: protocol must be "http" or "https" (got ${JSON.stringify(value)})`);
+}
+function toWebRequest(req, protocol) {
+    const host = req.headers.host ?? "localhost";
+    const url = `${protocol}://${host}${req.url ?? "/"}`;
+    const method = req.method ?? "GET";
+    return makeWebRequest(req, method, url, headersFromNode(req.headers));
+}
+function toNodeRequestSource(req, protocol) {
+    return new LazyNodeRequestSource(req, protocol);
+}
+/**
+ * Lazy view over a Node `IncomingMessage`. Methods live on the prototype (not re-allocated per
+ * request), and every materialization is deferred: the `Headers` object, the Web `ReadableStream`
+ * body, and the undici `Request` are each built only when first read. A bare GET that never touches
+ * `c.req` allocates just this instance.
+ */
+class LazyNodeRequestSource {
+    method;
+    url;
+    headersValue;
+    bodyValue;
+    requestValue;
+    consumedBody;
+    readBodyPromise;
+    nodeReq;
+    constructor(nodeReq, protocol) {
+        this.nodeReq = nodeReq;
+        this.method = nodeReq.method ?? "GET";
+        const host = nodeReq.headers.host ?? "localhost";
+        this.url = `${protocol}://${host}${nodeReq.url ?? "/"}`;
+    }
+    get headers() {
+        this.headersValue ??= headersFromNode(this.nodeReq.headers);
+        return this.headersValue;
+    }
+    // Read straight off Node's already-lowercased header bag (comma-joining multi-values to match
+    // `Headers.get`) so the body-cap path can check content-type/length without building a `Headers`.
+    header(name) {
+        const value = this.nodeReq.headers[name.toLowerCase()];
+        if (value === undefined)
+            return null;
+        return Array.isArray(value) ? value.join(", ") : value;
+    }
+    get body() {
+        if (this.method === "GET" || this.method === "HEAD")
+            return null;
+        if (this.consumedBody !== undefined)
+            return this.request.body;
+        this.bodyValue ??= Readable.toWeb(this.nodeReq);
+        return this.bodyValue;
+    }
+    arrayBuffer() {
+        if (this.requestValue !== undefined)
+            return this.requestValue.arrayBuffer();
+        return this.readNodeBody().then((buffer) => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
+    }
+    json() {
+        if (this.requestValue !== undefined)
+            return this.requestValue.json();
+        return this.readNodeBody().then((buffer) => JSON.parse(buffer.toString("utf8")));
+    }
+    get request() {
+        if (this.requestValue !== undefined)
+            return this.requestValue;
+        if (this.consumedBody !== undefined) {
+            this.requestValue = makeWebRequest(this.nodeReq, this.method, this.url, this.headers, this.consumedBody);
+            // Preserve one-shot body semantics if user code asks for `c.req` after nifra already consumed it.
+            void this.requestValue.arrayBuffer().catch(() => { });
+            return this.requestValue;
+        }
+        this.requestValue = makeWebRequest(this.nodeReq, this.method, this.url, this.headers, this.body);
+        return this.requestValue;
+    }
+    // Buffer the request body once. A single-chunk body (the common case) skips the array + `concat`;
+    // a client abort / socket error rejects (via `error`/`aborted`), which the body-cap callers catch
+    // and map to a flat 400.
+    readNodeBody() {
+        if (this.consumedBody !== undefined)
+            return Promise.resolve(this.consumedBody);
+        this.readBodyPromise ??= new Promise((resolve, reject) => {
+            let first;
+            let chunks;
+            let total = 0;
+            const finish = () => {
+                cleanup();
+                this.consumedBody =
+                    chunks === undefined ? (first ?? EMPTY_BUFFER) : Buffer.concat(chunks, total);
+                resolve(this.consumedBody);
+            };
+            const fail = (err) => {
+                cleanup();
+                reject(err);
+            };
+            const onData = (chunk) => {
+                const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+                if (first === undefined) {
+                    first = buffer;
+                }
+                else {
+                    chunks ??= [first];
+                    chunks.push(buffer);
+                }
+                total += buffer.byteLength;
+            };
+            const onAborted = () => fail(new Error("request aborted"));
+            const cleanup = () => {
+                this.nodeReq.removeListener("data", onData);
+                this.nodeReq.removeListener("end", finish);
+                this.nodeReq.removeListener("error", fail);
+                this.nodeReq.removeListener("aborted", onAborted);
+                this.nodeReq.removeListener("close", onClose);
+            };
+            // `aborted` is deprecated on newer Node; `close`-without-`end` is the forward-compatible signal
+            // that the connection dropped mid-body. Either way the read rejects instead of hanging forever.
+            const onClose = () => {
+                if (this.consumedBody === undefined)
+                    fail(new Error("request closed before body completed"));
+            };
+            this.nodeReq.on("data", onData);
+            this.nodeReq.once("end", finish);
+            this.nodeReq.once("error", fail);
+            this.nodeReq.once("aborted", onAborted);
+            this.nodeReq.once("close", onClose);
+        });
+        return this.readBodyPromise;
+    }
+}
+function headersFromNode(input) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(input)) {
+        if (value === undefined)
+            continue;
+        headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+    }
+    return headers;
+}
+function makeWebRequest(req, method, url, headers, body) {
+    const init = { method, headers };
+    if (method !== "GET" && method !== "HEAD") {
+        // Stream the body in; `duplex: "half"` is required for a streamed request body.
+        init.body = body ?? Readable.toWeb(req);
+        init.duplex = "half";
+    }
+    return new Request(url, init);
+}
+function waitForDrain(nodeRes) {
+    if (nodeRes.destroyed || nodeRes.writableEnded || !nodeRes.writable) {
+        return Promise.resolve(false);
+    }
+    return new Promise((resolve) => {
+        const cleanup = () => {
+            nodeRes.removeListener("drain", onDrain);
+            nodeRes.removeListener("close", onClose);
+            nodeRes.removeListener("error", onError);
+        };
+        const onDrain = () => {
+            cleanup();
+            resolve(true);
+        };
+        const onClose = () => {
+            cleanup();
+            resolve(false);
+        };
+        const onError = () => {
+            cleanup();
+            resolve(false);
+        };
+        nodeRes.once("drain", onDrain);
+        nodeRes.once("close", onClose);
+        nodeRes.once("error", onError);
+        if (nodeRes.destroyed || nodeRes.writableEnded || !nodeRes.writable) {
+            cleanup();
+            resolve(false);
+        }
+    });
+}
+function writeNodeResponse(response, nodeRes) {
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    // `Headers.forEach` comma-joins repeated `Set-Cookie` into one value — wrong, since a cookie's
+    // `Expires` attribute itself contains a comma (so a client can't safely split it back). Emit one
+    // header line per cookie via the un-joined `getSetCookie()` array (a response can set several:
+    // e.g. a session cookie + a CSRF cookie).
+    const setCookies = response.headers.getSetCookie?.();
+    if (setCookies !== undefined && setCookies.length > 0)
+        headers["set-cookie"] = setCookies;
+    nodeRes.writeHead(response.status, headers);
+    const directBody = nodeResponseBody(response);
+    if (directBody !== undefined) {
+        nodeRes.end(directBody);
+        return;
+    }
+    if (response.body === null) {
+        if (!nodeRes.destroyed && !nodeRes.writableEnded && nodeRes.writable)
+            nodeRes.end();
+        return;
+    }
+    return writeNodeResponseBody(response, nodeRes);
+}
+async function writeNodeResponseBody(response, nodeRes) {
+    const reader = response.body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!nodeRes.write(value)) {
+                if (nodeRes.destroyed || nodeRes.writableEnded || !nodeRes.writable) {
+                    try {
+                        await reader.cancel();
+                    }
+                    catch { }
+                    return;
+                }
+                const drained = await waitForDrain(nodeRes);
+                if (!drained || nodeRes.destroyed || nodeRes.writableEnded || !nodeRes.writable) {
+                    try {
+                        await reader.cancel();
+                    }
+                    catch { }
+                    return;
+                }
+            }
+        }
+    }
+    catch {
+        await reader.cancel().catch(() => { });
+        if (!nodeRes.headersSent)
+            writeInternalError(nodeRes);
+        else
+            nodeRes.destroy();
+        return;
+    }
+    if (!nodeRes.destroyed && !nodeRes.writableEnded && nodeRes.writable)
+        nodeRes.end();
+}
+function nodeResponseBody(response) {
+    if (response.bodyUsed)
+        return undefined;
+    const body = response[NODE_RESPONSE_BODY];
+    return typeof body === "string" || body instanceof Uint8Array ? body : undefined;
+}
+/** A non-literal specifier so TS treats `import(...)` as `any` — `ws` is an optional peer with no
+ * `@types/ws` dependency here (the surface is structurally typed via {@link WsServer}/{@link WsSocket}). */
+const WS_MODULE_SPECIFIER = "ws";
+/** Lazily build a noServer `ws` `WebSocketServer`, or `undefined` if `ws` isn't installed. */
+async function loadWsServer() {
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(WS_MODULE_SPECIFIER)));
+        const Ctor = mod.WebSocketServer ?? mod.default?.WebSocketServer;
+        return Ctor === undefined ? undefined : new Ctor({ noServer: true });
+    }
+    catch {
+        return undefined; // `ws` not installed — caller responds 501
+    }
+}
+const WS_STATUS_TEXT = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    426: "Upgrade Required",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+};
+/** Resolve a Node `upgrade` event: run the nifra upgrade guard, then either reject (write an HTTP error
+ * to the raw socket) or perform the `ws` upgrade and wire the socket to the handler. */
+async function handleUpgrade(resolveWs, getProtocol, nodeReq, socket, head, getWss) {
+    let outcome;
+    try {
+        outcome = await resolveWs(toWebRequest(nodeReq, getProtocol(nodeReq)));
+    }
+    catch {
+        writeUpgradeRejection(socket, 500, "internal_error");
+        return;
+    }
+    if (outcome.kind === "pass") {
+        writeUpgradeRejection(socket, 404, "not_found"); // upgrade to a path with no WS route
+        return;
+    }
+    if (outcome.kind === "reject") {
+        await writeRejectionResponse(socket, outcome.response);
+        return;
+    }
+    const wss = await getWss();
+    if (wss === undefined) {
+        writeUpgradeRejection(socket, 501, "websocket_unavailable"); // `ws` not installed
+        return;
+    }
+    const { handler, data, pubsub } = outcome;
+    wss.handleUpgrade(nodeReq, socket, head, (ws) => attachNodeWebSocket(ws, handler, data, pubsub));
+}
+/** Wire a `ws` socket (already open in `handleUpgrade`'s callback) to a nifra WS handler. The Node copy
+ * of core's `attachWebSocket` — binary frames normalize to `Uint8Array`; a thrown/rejected callback
+ * routes to `error()` and never crashes the connection. */
+function attachNodeWebSocket(ws, handler, data, pubsub) {
+    const nifra = {
+        send: (payload) => ws.send(payload),
+        close: (code, reason) => ws.close(code, reason),
+        get readyState() {
+            return ws.readyState;
+        },
+        subscribe: (topic) => pubsub.subscribe(topic, nifra),
+        unsubscribe: (topic) => pubsub.unsubscribe(topic, nifra),
+        data,
+        raw: ws,
+    };
+    const reportError = (error) => {
+        if (handler.error === undefined)
+            return;
+        try {
+            const r = handler.error(nifra, error);
+            if (r instanceof Promise)
+                r.catch(() => { });
+        }
+        catch {
+            /* the error handler itself failed — last resort, swallow */
+        }
+    };
+    const safe = (call) => {
+        try {
+            const r = call();
+            if (r instanceof Promise)
+                r.catch(reportError);
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    ws.on("message", (raw, isBinary) => {
+        const payload = isBinary
+            ? new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength)
+            : raw.toString();
+        safe(() => handler.message?.(nifra, payload));
+    });
+    ws.on("close", (code, reason) => {
+        pubsub.unsubscribeAll(nifra); // drop topic subscriptions so the registry never holds a dead socket
+        safe(() => handler.close?.(nifra, code, reason.toString()));
+    });
+    ws.on("error", (error) => reportError(error));
+    safe(() => handler.open?.(nifra)); // open: the socket is already established here
+}
+/** Write a minimal JSON error response to a raw upgrade socket, then close it. */
+function writeUpgradeRejection(socket, status, error) {
+    const body = JSON.stringify({ ok: false, error });
+    socket.write(`HTTP/1.1 ${status} ${WS_STATUS_TEXT[status] ?? "Error"}\r\n` +
+        `Content-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\n` +
+        "Connection: close\r\n\r\n" +
+        body);
+    socket.destroy();
+}
+/** Serialize a nifra guard's rejection `Response` (e.g. a 401) to a raw upgrade socket, then close. */
+async function writeRejectionResponse(socket, response) {
+    const body = await response.text();
+    let head = `HTTP/1.1 ${response.status} ${response.statusText || WS_STATUS_TEXT[response.status] || "Error"}\r\n`;
+    response.headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "content-length")
+            head += `${key}: ${value}\r\n`;
+    });
+    head += `Content-Length: ${Buffer.byteLength(body)}\r\nConnection: close\r\n\r\n`;
+    socket.write(head + body);
+    socket.destroy();
+}
+//# sourceMappingURL=index.js.map