acrylblends 1.0.10 → 1.2.0

package/lib/src-CtkIX_Gg.js

@@ -0,0 +1,427 @@
+import { c as RAW_RESPONSE_HANDLED, i as createAdaptorServer, l as RAW_UPGRADE_HANDLED, r as UpgradeHub, u as Request } from "./test-websocket-CQOSvBth.js";
+import "./serve-static-C1Nkj_xB.js";
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+//#region ../../plugins/acryl-node-server/src/index.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-node-server";
+const inject = ["router"];
+/** The pathname of a request target, for raw matching: a malformed one matches nothing (`'/'` matches only itself). */
+function pathnameOf(target) {
+	if (target === void 0) return "/";
+	try {
+		return new URL(target, "http://node-server.invalid").pathname;
+	} catch {
+		return "/";
+	}
+}
+/** Every field has a default, so a caller passes only what it changes: `ctx.plugin(plugin, { ... })` takes the partial shape. */
+const Config = z.object({
+	hostname: z.string().default("127.0.0.1").description("Address to bind. Loopback by default; binding elsewhere exposes the app to the network."),
+	port: z.number().min(0).max(65535).default(0).description("Port to listen on; 0 lets the system choose. A taken port, or one a browser refuses, is followed by the next usable one."),
+	scan: z.number().min(0).default(20).description("How many further ports to try when the configured one is taken or a browser refuses it."),
+	websocket: z.object({
+		maxPayload: z.number().min(1).default(1024 * 1024).description("The largest WebSocket frame accepted, in bytes; a bigger one closes the socket with 1009."),
+		heartbeat: z.number().min(0).default(3e4).description("Milliseconds between pings; a peer that did not answer the last one is terminated. 0 turns it off."),
+		grace: z.number().min(0).default(2e3).description("Milliseconds a closing socket gets before it is terminated when its plugin unloads.")
+	}).default({})
+});
+/**
+* Milliseconds a request already in flight, or an upgraded socket's own owner, may finish once the server stops taking new work. A save during a
+* restart must not be cut; a stream that never ends must not hold the stop open.
+*/
+const STOP_GRACE_MS = 2e3;
+var NodeServer = class extends Service {
+	hostname;
+	config;
+	server;
+	router;
+	hub;
+	bound = 0;
+	/** The one stop this server runs: a second call (the disposer after an explicit stop) waits on the same promise. */
+	stopping;
+	/** Requests whose response has not finished yet: the stop waits for them before their sockets are cut. */
+	active = 0;
+	/** Upgraded sockets this server handed out (WebSockets): neither close() nor closeAllConnections() reaches them, so the stop tracks them itself. */
+	upgraded = /* @__PURE__ */ new Set();
+	/** Raw routes registered by the host's compatibility layer (see {@link registerRaw}). */
+	rawExact = /* @__PURE__ */ new Map();
+	rawPrefix = /* @__PURE__ */ new Map();
+	rawUpgrades = /* @__PURE__ */ new Map();
+	/** Gates registered by a host that maps an app's URLs (see {@link NodeServer.gate}); they run in the order they were added. */
+	gates = [];
+	/** One raw dispatch per upgrade request: a second listener (or a re-added one) must never emit the same request again. */
+	rawUpgradeSeen = /* @__PURE__ */ new WeakSet();
+	constructor(ctx, config) {
+		super(ctx, "nodeServer");
+		this.config = config;
+		this.hostname = config.hostname;
+		const router = ctx.router;
+		this.router = router;
+		this.server = createAdaptorServer({
+			fetch: (request, bindings) => {
+				const { incoming, outgoing } = bindings;
+				this.active += 1;
+				let finished = false;
+				const settle = () => {
+					if (finished) return;
+					finished = true;
+					this.active -= 1;
+				};
+				outgoing.once("finish", settle);
+				outgoing.once("close", settle);
+				if (incoming.headers.upgrade !== void 0) {
+					const websocket = incoming.headers.upgrade.toLowerCase() === "websocket";
+					return new Response("", {
+						status: websocket ? 503 : 400,
+						headers: { connection: "close" }
+					});
+				}
+				if (this.gates.length > 0) {
+					const requestLike = request;
+					const connection = {
+						remoteAddress: incoming.socket.remoteAddress,
+						localPort: incoming.socket.localPort
+					};
+					for (const gate of this.gates) {
+						const answer = gate(requestLike, connection);
+						if (answer !== void 0) return answer;
+					}
+				}
+				const raw = this.rawFor(incoming);
+				if (raw !== void 0) {
+					(async () => {
+						try {
+							await raw(incoming, outgoing);
+						} catch {
+							if (!outgoing.headersSent) {
+								outgoing.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+								outgoing.end("internal error");
+							} else outgoing.destroy();
+						}
+					})();
+					return RAW_RESPONSE_HANDLED;
+				}
+				return router.fetch(new Request(request), {
+					remoteAddress: incoming.socket.remoteAddress,
+					localPort: incoming.socket.localPort
+				});
+			},
+			hostname: config.hostname,
+			overrideGlobalObjects: false
+		});
+		this.server.on("upgrade", (request, socket, head) => {
+			if (this.rawUpgradeSeen.has(request)) return;
+			this.upgraded.add(socket);
+			socket.once("close", () => {
+				this.upgraded.delete(socket);
+			});
+			socket.on("error", () => {
+				socket.destroy();
+			});
+			const websocket = request.headers.upgrade?.toLowerCase() === "websocket";
+			const handler = this.rawUpgrades.get(pathnameOf(request.url));
+			if (handler === void 0) {
+				if (!websocket || this.hub !== void 0) return;
+				if (socket.destroyed || socket.writableEnded) return;
+				request[RAW_UPGRADE_HANDLED] = true;
+				socket.end("HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+				return;
+			}
+			if (!websocket) {
+				if (socket.destroyed || socket.writableEnded) return;
+				request[RAW_UPGRADE_HANDLED] = true;
+				socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+				return;
+			}
+			this.rawUpgradeSeen.add(request);
+			request[RAW_UPGRADE_HANDLED] = true;
+			Promise.resolve(handler(request, socket, head)).catch(() => socket.destroy());
+		});
+		ctx.effect(() => () => this.stop(), "acryl-node-server: close listener and open connections");
+	}
+	/**
+	* Stop serving, gracefully, and resolve once the port is free: no new connections; requests already in flight may finish (a stream that never ends is
+	* cut) within {@link STOP_GRACE_MS}; each upgraded socket's owner closes it with a close frame first, and what is left is destroyed. Idempotent - the
+	* disposer calls it.
+	*
+	* Calling this BEFORE the rest of the app is disposed is what makes the grace count: the router has its own disposal, and it aborts in-flight requests
+	* and ends their bodies by design, concurrently with every other disposer (Cordis runs them together). A launcher that disposes the context directly
+	* therefore cuts the request this drains; a launcher that stops the server first lets it answer, then disposes.
+	*/
+	stop() {
+		this.stopping ??= this.closeGracefully();
+		return this.stopping;
+	}
+	async closeGracefully() {
+		const upgrades = this.hub?.close();
+		if (!this.server.listening) {
+			await upgrades;
+			return;
+		}
+		const stopped = new Promise((resolve) => {
+			this.server.close(() => {
+				resolve();
+			});
+		});
+		this.server.closeIdleConnections();
+		const settled = await this.settleStop(STOP_GRACE_MS);
+		this.server.closeIdleConnections();
+		if (!(settled ? await Promise.race([stopped.then(() => true), new Promise((resolve) => {
+			setTimeout(() => {
+				resolve(false);
+			}, 300);
+		})]) : false)) {
+			this.server.closeAllConnections();
+			for (const socket of this.upgraded) socket.destroy();
+			this.upgraded.clear();
+		}
+		await Promise.all([upgrades, stopped]);
+	}
+	/**
+	* Wait, bounded, until no request is in flight and no upgraded socket is left; true when both reached zero inside the bound. Every pass sweeps idle
+	* keep-alive sockets again: the single sweep `close()` does misses one that becomes idle after its request finished, and such a socket would otherwise
+	* hold the stop to its deadline.
+	*/
+	async settleStop(ms) {
+		const deadline = Date.now() + ms;
+		while (Date.now() < deadline) {
+			if (this.active === 0 && this.upgraded.size === 0) return true;
+			this.server.closeIdleConnections();
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+		return this.active === 0 && this.upgraded.size === 0;
+	}
+	/**
+	* Serve a raw node handler at `path`, beside the router: `exact` matches the pathname only, `prefix` the path and everything below it. The
+	* handler gets the platform's `IncomingMessage`/`ServerResponse` and owns the response; the router is not run for it. A path already served
+	* throws. The returned remover restores the path (the server itself goes on serving the rest).
+	*/
+	registerRaw(route) {
+		const table = route.kind === "exact" ? this.rawExact : this.rawPrefix;
+		if (table.has(route.path)) throw new Error(`acryl-node-server: ${route.path} is already served`);
+		table.set(route.path, route.handler);
+		return () => {
+			if (table.get(route.path) === route.handler) table.delete(route.path);
+		};
+	}
+	/**
+	* Answer matching requests before raw routes and the router, so a host can keep an app's URLs in scope under a prefix (the frame's canvas). A gate runs
+	* synchronously and can answer with a promise (see {@link RequestGate}); gates run in the order they were added, and the returned remover takes this one back.
+	*/
+	gate(handler) {
+		this.gates.push(handler);
+		return () => {
+			const at = this.gates.indexOf(handler);
+			if (at !== -1) this.gates.splice(at, 1);
+		};
+	}
+	/**
+	* A gate's asynchronous answer: run the request it was given through the router, in the adapter's request form (a gate never makes one itself), with the
+	* socket facts. The raw routes do not run for that request.
+	*/
+	throughRouter(request, connection = {}) {
+		return this.router.fetch(new Request(request), connection);
+	}
+	/**
+	* Claim an upgrade path for a raw node handler: the handler receives `(req, socket, head)` and from then on owns the socket. The router's
+	* WebSocket handling never sees a claimed upgrade. A path already claimed throws; the remover releases the claim. The transport's one raw
+	* listener exists for the server's whole lifetime and consults this registry, so claims coming and going never add or remove a listener.
+	*/
+	registerRawUpgrade(route) {
+		if (this.rawUpgrades.has(route.path)) throw new Error(`acryl-node-server: the upgrade path ${route.path} is already claimed`);
+		this.rawUpgrades.set(route.path, route.handler);
+		return () => {
+			if (this.rawUpgrades.get(route.path) !== route.handler) return;
+			this.rawUpgrades.delete(route.path);
+		};
+	}
+	/** The raw handler for a request: an exact path first, then the longest matching prefix. */
+	rawFor(incoming) {
+		const path = pathnameOf(incoming.url);
+		const exact = this.rawExact.get(path);
+		if (exact !== void 0) return exact;
+		let best;
+		for (const [prefix, handler] of this.rawPrefix) if ((path === prefix || path.startsWith(`${prefix}/`)) && (best === void 0 || prefix.length > best.length)) best = {
+			length: prefix.length,
+			handler
+		};
+		return best?.handler;
+	}
+	/**
+	* `upgradeWebSocket` for the plugin that asks (call it once, in `apply`): `app.get('/ws', upgrade((c) => ({ onMessage(event, ws) { ... } })))`. Checks go in ordinary middleware on the
+	* route, and a handler that returns a `Response` refuses the upgrade with that status before any handshake. Every socket it accepts belongs to the calling plugin: when the plugin
+	* unloads they are closed with 1001 within `websocket.grace` and the handler sees `close` once. Pass `{ textOnly: true }` to drop binary frames. Needs the `ws` package.
+	*/
+	upgrades() {
+		if (!this.hub) {
+			this.hub = new UpgradeHub(this.config.websocket);
+			this.hub.attach(this.server, this.ctx.router, { skipWhenRawUpgrade: true });
+		}
+		return this.hub.upgradeWebSocketFor(this.ctx);
+	}
+	/** How many `upgrade` listeners the transport holds (raw plus router setups); a test asserts it does not grow across claim changes. */
+	get upgradeListenerCount() {
+		return this.server.listenerCount("upgrade");
+	}
+	/** How many WebSocket connections are open now. */
+	get sockets() {
+		return this.hub?.size ?? 0;
+	}
+	/** The port in use, 0 before the server listens. */
+	get port() {
+		return this.bound;
+	}
+	/** The address clients use. */
+	get url() {
+		return `http://${this.hostname.includes(":") ? `[${this.hostname}]` : this.hostname}:${String(this.bound)}`;
+	}
+	/** Bind, scanning past taken ports and past the ports a browser refuses. */
+	async listen() {
+		const { port, scan, hostname } = this.config;
+		const last = port === 0 ? 0 : Math.min(65535, port + scan);
+		for (const candidate of portCandidates(port, scan)) try {
+			await new Promise((resolve, reject) => {
+				const onError = (error) => {
+					reject(error);
+				};
+				this.server.once("error", onError);
+				this.server.listen(candidate, hostname, () => {
+					this.server.off("error", onError);
+					resolve();
+				});
+			});
+			this.bound = this.server.address().port;
+			return;
+		} catch (error) {
+			if (!isPortUnavailable(error)) throw error;
+		}
+		throw new Error(`acryl-node-server: no usable port from ${String(port)} to ${String(last)} on ${hostname}: each is taken, or one a browser refuses`);
+	}
+};
+/**
+* The ports every Fetch client refuses to connect to: the Fetch standard's bad ports (https://fetch.spec.whatwg.org/#port-blocking). Chromium
+* refuses a page on one (ERR_UNSAFE_PORT) and Node's fetch answers "bad port"; the list below is the one Node 24 reports, probed port by port
+* on 2026-11-03 (82 ports, 1 to 10080). An app's stable port is hashed into 3100..3999, and 3659 is on the list: without this rule one app in
+* 900 would come up on an address no browser may open, which the frame gate caught that day (verify-frame-token was refused at 3659).
+*/
+const RESTRICTED_PORTS = /* @__PURE__ */ new Set([
+	1,
+	7,
+	9,
+	11,
+	13,
+	15,
+	17,
+	19,
+	20,
+	21,
+	22,
+	23,
+	25,
+	37,
+	42,
+	43,
+	53,
+	69,
+	77,
+	79,
+	87,
+	95,
+	101,
+	102,
+	103,
+	104,
+	109,
+	110,
+	111,
+	113,
+	115,
+	117,
+	119,
+	123,
+	135,
+	137,
+	139,
+	143,
+	161,
+	179,
+	389,
+	427,
+	465,
+	512,
+	513,
+	514,
+	515,
+	526,
+	530,
+	531,
+	532,
+	540,
+	548,
+	554,
+	556,
+	563,
+	587,
+	601,
+	636,
+	989,
+	990,
+	993,
+	995,
+	1719,
+	1720,
+	1723,
+	2049,
+	3659,
+	4045,
+	4190,
+	5060,
+	5061,
+	6e3,
+	6566,
+	6665,
+	6666,
+	6667,
+	6668,
+	6669,
+	6679,
+	6697,
+	10080
+]);
+/** Whether a browser refuses to open this port. */
+function isRestrictedPort(port) {
+	return RESTRICTED_PORTS.has(port);
+}
+/**
+* The ports `listen` may try, in order: `port` with at most `scan` further ones, without the ports a browser refuses. Port 0 stays alone: the
+* system chooses it, and the ports it hands out are above the restricted range.
+*/
+function portCandidates(port, scan) {
+	const last = port === 0 ? 0 : Math.min(65535, port + scan);
+	const candidates = [];
+	for (let candidate = port; candidate <= last; candidate += 1) if (!isRestrictedPort(candidate)) candidates.push(candidate);
+	return candidates;
+}
+/**
+* Whether a failed bind means "this port, try the next one". A port another socket holds answers `EADDRINUSE` everywhere. On Windows a port
+* inside a range the system reserves (Hyper-V, WSL and Docker exclude ranges, `netsh interface ipv4 show excludedportrange`) answers
+* `EACCES`, which is a property of that port too; elsewhere `EACCES` means the process may not bind low ports at all, so moving on would
+* only hide the reason.
+*/
+function isPortUnavailable(error, platform = process.platform) {
+	const code = error?.code;
+	return code === "EADDRINUSE" || platform === "win32" && code === "EACCES";
+}
+/** Loads once the server listens, so a plugin that injects `nodeServer` can rely on `url`. A failure to bind fails the plugin. */
+async function apply(ctx, config = {}) {
+	await new NodeServer(ctx, {
+		hostname: "127.0.0.1",
+		port: 0,
+		scan: 20,
+		websocket: {},
+		...config
+	}).listen();
+}
+//#endregion
+export { apply as a, isRestrictedPort as c, STOP_GRACE_MS as i, name as l, NodeServer as n, inject as o, RESTRICTED_PORTS as r, isPortUnavailable as s, Config as t, portCandidates as u };

package/lib/{src-BTBm4OPD.js → src-iBJ2ysV9.js}

@@ -5,6 +5,8 @@ import { t as TrieRouter } from "./trie-router-JydLKUa2.js";
 import { t as Acryl } from "./app-CQcGWjrk.js";
 import "./core-BOu1jYua.js";
 import "./connection-C7xgP1hP.js";
+import { appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 //#region ../../plugins/acryl-router/src/service.ts
@@ -17,6 +19,28 @@ import z from "@deepseek-ai/schemastery";
 * response body still streaming and waits for all of it to settle.
 */
 const DEFAULT_DISPOSE_GRACE_MS = 2e3;
+/** How long disposal waits for the flights it had to abort after the drain, before it continues without them. */
+const ABORT_SETTLE_MS = 300;
+/** Set by ACRYL_ROUTER_TRACE=1: append request-signal lifecycle lines to ACRYL_ROUTER_TRACE_FILE (the CI artifact) - diagnostics for the abort-reaches-handler defect. */
+const traceFile = () => process.env.ACRYL_ROUTER_TRACE_FILE ?? `${tmpdir()}/acryl-router-trace.log`;
+const trace = (line) => {
+	if (process.env.ACRYL_ROUTER_TRACE !== "1") return;
+	try {
+		appendFileSync(traceFile(), `${String(Date.now())} [${String(process.pid)}] ${line}\n`);
+	} catch {}
+};
+let flightSeq = 0;
+const SIGNAL_TAG = Symbol.for("acryl.router.signalTag");
+const tagOf = (signal) => {
+	if (signal === void 0) return "none";
+	const tag = signal[SIGNAL_TAG];
+	return typeof tag === "string" ? tag : "untagged";
+};
+const tagSignal = (signal, tag) => {
+	try {
+		signal[SIGNAL_TAG] = tag;
+	} catch {}
+};
 /** Every field has a default, so a caller passes only what it changes: `ctx.plugin(plugin, { ... })` takes the partial shape. */
 const Config = z.object({
 	trailingSlash: z.union(["strict", "ignore"]).default("strict").description("Whether `/a` and `/a/` are different paths."),
@@ -64,8 +88,8 @@ var Router = class extends Service {
 		};
 		ctx.effect(() => async () => {
 			this.state.closing = true;
-			await this.end([...this.flights], "disposal");
-		}, "acryl-router: abort and settle in-flight requests");
+			await this.drain();
+		}, "acryl-router: drain in-flight requests, then abort what is left");
 	}
 	/** Registrations currently held (mounts, and the router-wide error and not-found handlers); a leak check for reload tests. */
 	get size() {
@@ -83,7 +107,7 @@ var Router = class extends Service {
 		const remove = () => {
 			if (!this.state.mounts.delete(mount)) return Promise.resolve();
 			this.state.composed = void 0;
-			return this.end([...this.flights].filter((flight) => (flight.running.get(mount) ?? 0) > 0 || flight.producer === mount), `removing ${path}`);
+			return this.drainFlights([...this.flights].filter((flight) => (flight.running.get(mount) ?? 0) > 0 || flight.producer === mount), `removing ${path}`);
 		};
 		const served = new Set(app.routes.map((route) => `${route.method} ${mergePath(path, route.path)}`));
 		const owner = this.ctx;
@@ -125,6 +149,7 @@ var Router = class extends Service {
 			const handler = async (c, next) => {
 				const flight = this.flightOf.get(c.req.raw);
 				if (flight === void 0) return inner(c, next);
+				trace(`handler ${flight.tag} requestTag=${tagOf(c.req.raw.signal)} innerTag=${tagOf(flight.inner.signal)} sameSignal=${String(c.req.raw.signal === flight.inner.signal)} aborted=${String(c.req.raw.signal.aborted)}`);
 				let calledNext = false;
 				flight.running.set(mount, (flight.running.get(mount) ?? 0) + 1);
 				try {
@@ -145,22 +170,52 @@ var Router = class extends Service {
 		}
 		return mount;
 	}
-	/** Abort `flights`, cut their bodies short and wait for them to settle, at most `disposeGraceMs`. */
-	async end(flights, why) {
+	/**
+	* The router's own disposal: let the flights already in flight finish within `disposeGraceMs` - a save being written when the app stops must not be cut
+	* by the router beneath it - then abort what is left and settle it for a moment, so disposal does not wait a second full grace on code that ignores
+	* its abort signal.
+	*/
+	async drain() {
+		await this.drainFlights([...this.flights], "disposal");
+	}
+	/** The one draining rule: let `flights` finish inside the grace, then abort and settle what is left. */
+	async drainFlights(flights, why) {
+		trace(`drain ${why} chosen=[${flights.map((flight) => flight.tag).join(", ")}]`);
 		if (flights.length === 0) return;
-		for (const flight of flights) {
-			flight.controller.abort();
-			flight.endBody();
+		if (await this.settledWithin(flights, this.graceMs)) {
+			trace(`drain ${why} settled inside the grace`);
+			return;
 		}
+		const left = flights.filter((flight) => this.flights.has(flight));
+		trace(`drain ${why} grace over left=[${left.map((flight) => flight.tag).join(", ")}]`);
+		if (left.length > 0) await this.end(left, why, ABORT_SETTLE_MS);
+	}
+	/** Resolve true when every flight settled inside `ms`, false at the deadline. */
+	async settledWithin(flights, ms) {
 		let timer;
 		const gaveUp = new Promise((resolve) => {
 			timer = setTimeout(() => {
-				resolve("gave-up");
-			}, this.graceMs);
+				resolve(false);
+			}, ms);
 		});
-		const outcome = await Promise.race([Promise.allSettled(flights.map((flight) => flight.settled)).then(() => "settled"), gaveUp]);
+		const outcome = await Promise.race([Promise.allSettled(flights.map((flight) => flight.settled)).then(() => true), gaveUp]);
 		clearTimeout(timer);
-		if (outcome === "gave-up") this.ctx.logger.warn(`acryl-router: ${String(flights.length)} request(s) did not finish ${String(this.graceMs)} ms after abort (${why}); continued without them`);
+		return outcome;
+	}
+	/** Abort `flights`, cut their bodies short and wait for them to settle, at most `settleMs`. */
+	async end(flights, why, settleMs = this.graceMs) {
+		if (flights.length === 0) return;
+		for (const flight of flights) {
+			trace(`abort ${flight.tag} before=${String(flight.controller.signal.aborted)}`);
+			flight.controller.abort();
+			trace(`abort ${flight.tag} after=${String(flight.controller.signal.aborted)} innerAborted=${String(flight.inner.signal.aborted)}`);
+			queueMicrotask(() => {
+				trace(`post-abort ${flight.tag} innerAborted=${String(flight.inner.signal.aborted)}`);
+			});
+			flight.endBody();
+		}
+		if (await this.settledWithin(flights, settleMs)) return;
+		this.ctx.logger.warn(`acryl-router: ${String(flights.length)} request(s) did not finish ${String(settleMs)} ms after abort (${why}); continued without them`);
 	}
 	/** Turn errors no mounted app handled into responses. One handler per router; the calling plugin owns it. */
 	onError(handler) {
@@ -203,7 +258,10 @@ var Router = class extends Service {
 	* `bindings` is an object an adapter hands to the handler as `c.env` (an upgrade request's socket hooks, for `upgradeWebSocket`); `connection` is added to it.
 	*/
 	fetch(request, connection = {}, bindings) {
-		if (this.state.closing) return Promise.resolve(new Response("Service Unavailable", { status: 503 }));
+		if (this.state.closing) return Promise.resolve(new Response("Service Unavailable", {
+			status: 503,
+			headers: { connection: "close" }
+		}));
 		const controller = new AbortController();
 		const forward = () => controller.abort();
 		if (request.signal.aborted) controller.abort();
@@ -220,8 +278,13 @@ var Router = class extends Service {
 		let bodyDone = Promise.resolve();
 		let endBody = () => {};
 		let resolveSettled;
+		const tag = `f${String(++flightSeq)}`;
+		const inner = new Request(request, { signal: controller.signal });
+		tagSignal(inner.signal, tag);
 		const flight = {
 			controller,
+			inner,
+			tag,
 			running: /* @__PURE__ */ new Map(),
 			producer: void 0,
 			endBody: () => {
@@ -231,7 +294,7 @@ var Router = class extends Service {
 				resolveSettled = resolve;
 			})
 		};
-		const inner = new Request(request, { signal: controller.signal });
+		trace(`create ${tag} ${request.method} ${new URL(request.url).pathname}`);
 		this.flightOf.set(inner, flight);
 		const response = this.dispatch(inner, env, executionCtx).then((raw) => {
 			const tracked = this.track(raw);

package/lib/{test-websocket-BLeEvybj.js → test-websocket-CQOSvBth.js}

@@ -744,6 +744,12 @@ Object.defineProperty(Response$1, "json", {
 	configurable: true
 });
 //#endregion
+//#region ../../plugins/acryl-node-server/src/adapter/raw.ts
+/** Returned by a raw-aware fetch callback: the node response is already owned, do not write. */
+const RAW_RESPONSE_HANDLED = Symbol.for("acryl-node-server.raw-response");
+/** Set on an upgrade request a raw handler took over; the adapter's WebSocket setup skips it. */
+const RAW_UPGRADE_HANDLED = Symbol.for("acryl-node-server.raw-upgrade");
+//#endregion
 //#region ../../plugins/acryl-node-server/src/adapter/utils.ts
 async function readWithoutBlocking(readPromise) {
 	return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
@@ -1040,6 +1046,7 @@ const getRequestListener = (fetchCallback, options = {}) => {
 				incoming,
 				outgoing
 			});
+			if (res === RAW_RESPONSE_HANDLED) return;
 			if (!isPromise(res) && isImmediateCacheableResponse(res)) {
 				if (needsBodyCleanup && !incoming.readableEnded) outgoing.once("finish", () => {
 					if (!incoming.readableEnded) drainIncoming(incoming);
@@ -1137,6 +1144,7 @@ const appendResponseHeaders = (headers, responseHeaders) => {
 	});
 };
 const rejectUpgradeRequest = (socket, status, responseHeaders) => {
+	if (socket.destroyed || socket.writableEnded) return;
 	const responseLines = ["Connection: close", "Content-Length: 0"];
 	appendResponseHeaders(responseLines, responseHeaders);
 	socket.end(`HTTP/1.1 ${status.toString()} ${STATUS_CODES[status] ?? ""}\r\n${responseLines.join("\r\n")}\r\n\r
@@ -1154,7 +1162,7 @@ const createUpgradeRequest = (request) => {
 	return new Request(url, { headers });
 };
 const setupWebSocket = (options) => {
-	const { server, fetchCallback, wss } = options;
+	const { server, fetchCallback, wss, skipWhenRawUpgrade = false } = options;
 	const waiterMap = /* @__PURE__ */ new Map();
 	wss.on("connection", (ws, request) => {
 		const waiter = waiterMap.get(request);
@@ -1180,8 +1188,9 @@ const setupWebSocket = (options) => {
 		});
 	};
 	server.on("upgrade", async (request, socket, head) => {
+		if (skipWhenRawUpgrade && request[RAW_UPGRADE_HANDLED] === true) return;
 		if (request.headers.upgrade?.toLowerCase() !== "websocket") {
-			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, 400);
+			rejectUpgradeRequest(socket, 400);
 			return;
 		}
 		const env = {
@@ -1199,13 +1208,13 @@ const setupWebSocket = (options) => {
 				responseHeaders = response.headers;
 			}
 		} catch {
-			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, 500);
+			rejectUpgradeRequest(socket, 500);
 			return;
 		}
 		const waiter = waiterMap.get(request);
 		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
 			rejectWaiter(request);
-			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status, responseHeaders);
+			rejectUpgradeRequest(socket, status, responseHeaders);
 			return;
 		}
 		const addResponseHeaders = (headers) => {
@@ -1389,7 +1398,7 @@ var UpgradeHub = class {
 	* Accept upgrades from `source` and answer them with `router`: the request runs through the router's middleware with the socket's peer address and local port as connection
 	* facts (so the same loopback, origin and host checks work), and the upgrade bindings travel in `c.env` for `upgradeWebSocket`.
 	*/
-	attach(source, router) {
+	attach(source, router, options = {}) {
 		const fetchCallback = (request, env) => {
 			const { incoming } = env;
 			return router.fetch(request, {
@@ -1400,7 +1409,8 @@ var UpgradeHub = class {
 		setupWebSocket({
 			server: source,
 			fetchCallback,
-			wss: this.server
+			wss: this.server,
+			...options
 		});
 	}
 	/** How many sockets are open. */
@@ -1541,4 +1551,4 @@ async function testWebSocket(fetch, path, options = {}) {
 	};
 }
 //#endregion
-export { serve as a, Request$1 as c, createAdaptorServer as i, RequestError as l, UpgradeEmitter as n, upgradeWebSocket as o, UpgradeHub as r, getRequestListener as s, testWebSocket as t };
+export { serve as a, RAW_RESPONSE_HANDLED as c, RequestError as d, createAdaptorServer as i, RAW_UPGRADE_HANDLED as l, UpgradeEmitter as n, upgradeWebSocket as o, UpgradeHub as r, getRequestListener as s, testWebSocket as t, Request$1 as u };

package/lib/{test-websocket-DyeS50Tr.d.ts → test-websocket-GUTAkFQT.d.ts}

@@ -88,7 +88,9 @@ declare class UpgradeHub {
    * Accept upgrades from `source` and answer them with `router`: the request runs through the router's middleware with the socket's peer address and local port as connection
    * facts (so the same loopback, origin and host checks work), and the upgrade bindings travel in `c.env` for `upgradeWebSocket`.
    */
-  attach(source: UpgradeSource, router: UpgradeRouter): void;
+  attach(source: UpgradeSource, router: UpgradeRouter, options?: {
+    skipWhenRawUpgrade?: boolean;
+  }): void;
   /** How many sockets are open. */
   get size(): number;
   /** `upgradeWebSocket` for the plugin `owner`: the sockets it accepts are closed with 1001 when that plugin unloads. */