acrylblends 0.8.1 → 0.9.0

package/lib/snapshot-text-D3NspDyT.js

@@ -0,0 +1,338 @@
+import { t as Acryl } from "./app-BM0rTCp7.js";
+import { bodyLimit } from "./body-limit.js";
+import { methodNotAllowed } from "./method-not-allowed.js";
+import { r as streamSSE } from "./streaming-DHST3Scg.js";
+import { loopbackAuthority, loopbackOnly } from "./loopback-only.js";
+import "./helpers-CvTauQT5.js";
+import { UiControlError, WINDOW_ID, parseChannelToHost } from "./door/protocol.js";
+import "./src-CwABFr6r.js";
+import "./middleware-CPQ8himN.js";
+import { dirname, join } from "node:path";
+import { timingSafeEqual } from "node:crypto";
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeSync } from "node:fs";
+//#region ../../plugins/acryl-door/src/host/channel.ts
+/**
+* The Host's side of the page channel: the connected pages of the app, and calls that go to the current one (moved from
+* `acryl-agent-control`, spec 041).
+*
+* The Host cannot reach into a page, so each page opens one event stream to the Host and answers calls by POST. With several pages open,
+* the one the user focused last is the one the agent drives. A page that reconnects with the same window id replaces its old stream.
+*/
+/** How long a call may take before it is given up (a wait may take up to 10 seconds itself). */
+const DEFAULT_CALL_TIMEOUT_MS = 3e4;
+var UiChannel = class {
+	connections = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	nextId = 1;
+	clock = 0;
+	closed = false;
+	/**
+	* Register a page's stream. A stream already open for the same window is closed first, and its calls settle as `disconnected`.
+	* @returns the function to call when this stream ends.
+	*/
+	attach(windowId, focused, stream) {
+		const previous = this.connections.get(windowId);
+		if (previous !== void 0) this.drop(previous, true);
+		const connection = {
+			stream,
+			windowId,
+			focused,
+			lastActive: ++this.clock
+		};
+		this.connections.set(windowId, connection);
+		return () => {
+			if (this.connections.get(windowId) === connection) this.drop(connection, false);
+		};
+	}
+	/** A message a page sent by POST. Only the window that was asked may answer a call, so another page cannot forge a result. */
+	receive(windowId, message) {
+		const connection = this.connections.get(windowId);
+		if (connection === void 0) return;
+		if (message.t === "focus") {
+			connection.focused = message.focused;
+			if (message.focused) connection.lastActive = ++this.clock;
+			return;
+		}
+		const entry = this.pending.get(message.id);
+		if (entry === void 0 || entry.connection !== connection) return;
+		if (message.t === "result") this.settle(message.id, message.value);
+		else this.settle(message.id, void 0, new UiControlError(message.code, message.message));
+	}
+	/** True when at least one page is connected. */
+	get connected() {
+		return this.connections.size > 0;
+	}
+	/** The windows currently connected, most recently active first (for diagnostics and tests). */
+	windows() {
+		return this.byRecency().map(({ windowId, focused }) => ({
+			windowId,
+			focused
+		}));
+	}
+	/**
+	* Ask the current page to do something.
+	* @throws UiControlError `no-window`, `timeout`, `aborted`, `unloaded`, `disconnected`, or whatever the page refused with.
+	*/
+	call(request, options = {}) {
+		if (this.closed) return Promise.reject(new UiControlError("unloaded", "the door was unloaded"));
+		const target = this.byRecency()[0];
+		if (target === void 0) return Promise.reject(new UiControlError("no-window", "no page of the app is open to control"));
+		const signal = options.signal;
+		if (signal?.aborted === true) return Promise.reject(new UiControlError("aborted", "the call was cancelled"));
+		const id = this.nextId;
+		this.nextId += 1;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.settle(id, void 0, new UiControlError("timeout", "the page did not answer in time"));
+			}, options.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS);
+			const onAbort = () => {
+				this.settle(id, void 0, new UiControlError("aborted", "the call was cancelled"));
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.pending.set(id, {
+				connection: target,
+				resolve,
+				reject,
+				timer,
+				cleanup: () => {
+					signal?.removeEventListener("abort", onAbort);
+				}
+			});
+			const frame = {
+				t: "call",
+				id,
+				request
+			};
+			try {
+				target.stream.send(JSON.stringify(frame));
+			} catch {
+				this.settle(id, void 0, new UiControlError("disconnected", "the page could not be reached"));
+			}
+		});
+	}
+	/** Close every page's stream and settle every pending call as `unloaded`. */
+	close() {
+		this.closed = true;
+		for (const id of [...this.pending.keys()]) this.settle(id, void 0, new UiControlError("unloaded", "the door was unloaded"));
+		for (const connection of [...this.connections.values()]) connection.stream.close();
+		this.connections.clear();
+	}
+	byRecency() {
+		return [...this.connections.values()].sort((a, b) => b.lastActive - a.lastActive);
+	}
+	/** Forget a connection; its calls in flight settle as `disconnected` at once rather than waiting for their timeout. */
+	drop(connection, closeStream) {
+		this.connections.delete(connection.windowId);
+		for (const [id, entry] of [...this.pending]) if (entry.connection === connection) this.settle(id, void 0, new UiControlError("disconnected", "the page went away before it answered"));
+		if (closeStream) connection.stream.close();
+	}
+	settle(id, value, failure) {
+		const entry = this.pending.get(id);
+		if (entry === void 0) return;
+		this.pending.delete(id);
+		clearTimeout(entry.timer);
+		entry.cleanup();
+		if (failure !== void 0) entry.reject(failure);
+		else if (value !== void 0) entry.resolve(value);
+	}
+};
+//#endregion
+//#region ../../plugins/acryl-door/src/host/audit.ts
+/**
+* The audit log: one JSON line per door call, append-only, in the app's own `.acryl/audit/` (moved from `acryl-agent-control`, spec 041).
+*
+* It is the record of what the agent did to the app. It never holds text the agent typed or values it read,
+* only which control was touched and how the call ended.
+*/
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+/** The audit log below a folder the caller owns (the app's `.acryl/` here; ACRYL's app home for the DSH face). */
+function auditPath(folder) {
+	return join(folder, "audit", "ui-control.jsonl");
+}
+var AuditLog = class {
+	path;
+	constructor(path) {
+		this.path = path;
+	}
+	/** Append one line; a failing disk never breaks the tool call. */
+	record(entry) {
+		try {
+			mkdirSync(dirname(this.path), { recursive: true });
+			this.rotateIfLarge();
+			const fd = openSync(this.path, "a", 384);
+			try {
+				writeSync(fd, `${JSON.stringify(entry)}\n`);
+			} finally {
+				closeSync(fd);
+			}
+		} catch {}
+	}
+	/** The most recent entries, oldest first. */
+	recent(limit = 100) {
+		try {
+			return readFileSync(this.path, "utf8").split("\n").filter((line) => line !== "").slice(-limit).flatMap((line) => {
+				try {
+					return [JSON.parse(line)];
+				} catch {
+					return [];
+				}
+			});
+		} catch {
+			return [];
+		}
+	}
+	rotateIfLarge() {
+		try {
+			if (statSync(this.path).size >= MAX_LOG_BYTES) renameSync(this.path, `${this.path}.1`);
+		} catch {}
+	}
+};
+//#endregion
+//#region ../../plugins/acryl-door/src/host/http.ts
+/**
+* What every door route shares (moved from `acryl-agent-control`, spec 041). Two kinds of caller reach it, each with its own guard: the
+* app's own page (same origin, on a loopback address), and an operator on this machine (`.acryl/bin/acryl`, an agent's shell) presenting
+* this run's secret.
+*/
+/** Every door route lives below this path. */
+const DOOR_PREFIX = "/api/acryl-door";
+/** The cap on a JSON request body. */
+const MAX_BODY_BYTES = 64 * 1024;
+/** The JSON body of a refusal. */
+function error(message) {
+	return { error: message };
+}
+/** The app's own page, on a loopback address, and nothing else: another origin, another port and a script on the machine are refused. */
+const ownPage = loopbackOnly({ callers: "own-page" });
+/** A constant-time comparison of a `Bearer` header with the secret. */
+function tokenMatches(header, secret) {
+	const presented = header?.startsWith("Bearer ") === true ? header.slice(7) : "";
+	const a = Buffer.from(presented);
+	const b = Buffer.from(secret);
+	return a.length === b.length && timingSafeEqual(a, b);
+}
+/**
+* Only an operator on this machine: a loopback peer addressing this server's own port (`loopbackAuthority`), presenting this run's
+* secret. Anything else is 403 `forbidden`, which the client reads as "refused: the app restarted and the secret rotated?".
+*/
+function operatorOnly(secret) {
+	return async (c, next) => {
+		if (loopbackAuthority(c) === void 0 || !tokenMatches(c.req.header("authorization"), secret)) return c.json(error("forbidden"), 403);
+		await next();
+	};
+}
+/** The headers every private answer carries, set after the handler so a refusal carries them too. */
+const privateHeaders = async (c, next) => {
+	await next();
+	c.header("cache-control", "no-store");
+	c.header("x-content-type-options", "nosniff");
+};
+/**
+* The door's routes as one app: each part's routes, every answer with the private headers, and a known path asked with another method
+* answered 405 with its `Allow` before any guard runs. The middleware is scoped to the prefix, so it never wraps another plugin's routes.
+*/
+function privateApi(prefix, ...routes) {
+	const app = new Acryl();
+	app.use(`${prefix}/*`, privateHeaders, methodNotAllowed({
+		app,
+		onMethodNotAllowed: (c, allowed) => c.json(error("method not allowed"), 405, { allow: allowed.join(", ") })
+	}));
+	for (const part of routes) app.route("/", part);
+	return app;
+}
+/** Refuse a body over {@link MAX_BODY_BYTES} with 413 before the handler reads it. */
+const jsonBody = bodyLimit({
+	maxSize: MAX_BODY_BYTES,
+	onError: (c) => c.json(error("request body is too large"), 413)
+});
+/** Returned by {@link readJson} for a body that is not JSON. */
+const INVALID_JSON = Symbol("invalid JSON");
+/** The parsed body, or {@link INVALID_JSON}. */
+async function readJson(c) {
+	try {
+		return await c.req.json();
+	} catch {
+		return INVALID_JSON;
+	}
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/host/page-routes.ts
+/**
+* The page channel on the router: an event stream down to the page and POST up, so it needs no WebSocket upgrade on any adapter.
+*
+* `GET <prefix>/channel?window=<id>&focused=0|1` is the page's stream. The Host writes each call as `event: call` and a `ping` every
+* heartbeat, so a page that hears nothing for a while knows the stream died and reconnects. `POST <prefix>/channel/answer` carries
+* `{ window, message }` (a result, an error or a focus change). Both are for the app's own page only (same origin, loopback).
+*/
+/** How often the Host writes a `ping`; the page gives up on a stream that is silent for three of these. */
+const HEARTBEAT_MS = 15e3;
+function pageChannelRoutes(channel, options) {
+	const heartbeatMs = options.heartbeatMs ?? 15e3;
+	const page = options.hostnames === void 0 ? ownPage : loopbackOnly({
+		callers: "own-page",
+		hostnames: options.hostnames
+	});
+	return new Acryl().get(`${options.prefix}/channel`, page, (c) => {
+		const windowId = c.req.query("window");
+		if (windowId === void 0 || !WINDOW_ID.test(windowId)) return c.json(error("a window id is required"), 400);
+		const focused = c.req.query("focused") === "1";
+		const signal = c.req.raw.signal;
+		return streamSSE(c, async (stream) => {
+			let end = () => {};
+			const ended = new Promise((resolve) => {
+				end = resolve;
+			});
+			stream.onAbort(end);
+			signal.addEventListener("abort", end, { once: true });
+			const write = (event, data) => {
+				stream.writeSSE({
+					event,
+					data
+				}).catch(end);
+			};
+			const detach = channel.attach(windowId, focused, {
+				send: (data) => {
+					write("call", data);
+				},
+				close: end
+			});
+			const beat = setInterval(() => {
+				write("ping", "");
+			}, heartbeatMs);
+			try {
+				write("ready", "");
+				await ended;
+			} finally {
+				clearInterval(beat);
+				signal.removeEventListener("abort", end);
+				detach();
+			}
+		});
+	}).post(`${options.prefix}/channel/answer`, page, jsonBody, async (c) => {
+		const body = await readJson(c);
+		if (body === INVALID_JSON || typeof body !== "object" || body === null) return c.json(error("invalid request body"), 400);
+		const { window: windowId, message } = body;
+		const parsed = parseChannelToHost(message);
+		if (typeof windowId !== "string" || !WINDOW_ID.test(windowId) || parsed === null) return c.json(error("invalid message"), 400);
+		channel.receive(windowId, parsed);
+		return c.body(null, 204);
+	});
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/page/snapshot-text.ts
+/**
+* The snapshot as compact text for an agent: one line per element, indented by depth.
+* @param more - how to ask for the rest when the page was cut, given the cursor to continue from.
+*/
+function renderSnapshot(snapshot, more = (cursor) => `call ui_snapshot with cursor ${String(cursor)}`) {
+	const lines = snapshot.nodes.map((node) => {
+		const level = node.level === void 0 ? "" : ` level=${String(node.level)}`;
+		const states = node.states.length === 0 ? "" : ` [${node.states.join(", ")}]`;
+		const value = node.value === void 0 ? "" : ` value=${JSON.stringify(node.value)}`;
+		return `${"  ".repeat(Math.min(node.depth, 8))}- ${node.role}${node.name === "" ? "" : ` ${JSON.stringify(node.name)}`}${level}${states}${value} [ref=${node.ref}]`;
+	});
+	const rest = snapshot.nextCursor === void 0 ? "" : `\n(${String(snapshot.total - snapshot.nextCursor)} more elements; ${more(snapshot.nextCursor)})`;
+	return `Page: ${snapshot.title || "(untitled)"}\nSnapshot ${String(snapshot.generation)}, ${String(snapshot.nodes.length)} of ${String(snapshot.total)} elements:\n${lines.join("\n")}${rest}`;
+}
+//#endregion
+export { INVALID_JSON as a, operatorOnly as c, AuditLog as d, auditPath as f, DOOR_PREFIX as i, privateApi as l, HEARTBEAT_MS as n, error as o, UiChannel as p, pageChannelRoutes as r, jsonBody as s, renderSnapshot as t, readJson as u };

package/lib/src-CwABFr6r.js

@@ -0,0 +1,328 @@
+import { HTTPException } from "./http-exception.js";
+import { mergePath } from "./utils/url.js";
+import { COMPOSED_HANDLER } from "./utils/constants.js";
+import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
+import { t as Acryl } from "./app-BM0rTCp7.js";
+import "./core-CaY8XDZ6.js";
+import "./deprecated-BP4fPt38.js";
+import "./connection-C7xgP1hP.js";
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+//#region ../../plugins/acryl-router/src/service.ts
+/**
+* The ACRYL router service (`ctx.router`): plugin-owned `Acryl` mounts on Web-standard Request and Response.
+*
+* A plugin builds an ordinary `Acryl` and mounts it with `ctx.router.route(path, app)` from its own context, so the mount disappears when that
+* plugin unloads. `fetch(request)` runs a request in process: Web and Desktop serve it behind HTTP through an adapter, the terminal UI calls
+* it directly, so one handler serves every surface without opening a socket. Disposal refuses new requests, aborts in-flight ones, ends any
+* response body still streaming and waits for all of it to settle.
+*/
+const DEFAULT_DISPOSE_GRACE_MS = 2e3;
+/** 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."),
+	disposeGraceMs: z.number().min(0).default(DEFAULT_DISPOSE_GRACE_MS).description("How long disposal waits for aborted requests, their response bodies and their waitUntil tasks before it gives up on them.")
+});
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-router";
+/** The core's `app.route` with a structural app: at run time it reads only the routes and the app's own error handler. */
+const copyRoutes = (app) => new Acryl().route("/", app);
+/** Wait for `tasks`, including any added while waiting (a stream may register more after the handler returned). */
+async function drain(tasks) {
+	let seen = 0;
+	while (seen < tasks.length) {
+		const batch = tasks.slice(seen);
+		seen = tasks.length;
+		await Promise.allSettled(batch);
+	}
+}
+var Router = class extends Service {
+	/** Everything that changes after construction, kept in one object so the service's live state is in one place. */
+	state = {
+		mounts: /* @__PURE__ */ new Set(),
+		errorHandler: void 0,
+		notFoundHandler: void 0,
+		composed: void 0,
+		closing: false
+	};
+	flights = /* @__PURE__ */ new Set();
+	/** The flight of each request the router dispatched, keyed by the request its handlers see as `c.req.raw`. */
+	flightOf = /* @__PURE__ */ new WeakMap();
+	strict;
+	graceMs;
+	logError;
+	constructor(ctx, config = {}) {
+		super(ctx, "router");
+		const { trailingSlash = "strict", disposeGraceMs = DEFAULT_DISPOSE_GRACE_MS } = config;
+		this.strict = trailingSlash === "strict";
+		this.graceMs = disposeGraceMs;
+		this.logError = (error, c) => {
+			if (error instanceof HTTPException) return error.getResponse();
+			if (c.req.raw.signal.aborted) return new Response("Client Closed Request", { status: 499 });
+			ctx.logger.error(`acryl-router: handler failed: ${error instanceof Error ? error.message : String(error)}`);
+			return c.text("Internal Server Error", 500);
+		};
+		ctx.effect(() => async () => {
+			this.state.closing = true;
+			await this.end([...this.flights], "disposal");
+		}, "acryl-router: abort and settle in-flight requests");
+	}
+	/** Registrations currently held (mounts, and the router-wide error and not-found handlers); a leak check for reload tests. */
+	get size() {
+		return this.state.mounts.size + (this.state.errorHandler === void 0 ? 0 : 1) + (this.state.notFoundHandler === void 0 ? 0 : 1);
+	}
+	/**
+	* Serve `app` under `path` (`'/'` for its own paths as they are). The mount belongs to the calling plugin and goes away when it unloads;
+	* the returned function removes it sooner. Mounts are composed in the order they were made. Like the core's own `app.route`, the routes
+	* are copied now: one the app registers after this call is not served (mount again, or finish the app first).
+	*/
+	route(path, app) {
+		const mount = this.snapshot(path, app);
+		this.state.mounts.add(mount);
+		this.state.composed = void 0;
+		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}`);
+		};
+		const served = new Set(app.routes.map((route) => `${route.method} ${mergePath(path, route.path)}`));
+		const owner = this.ctx;
+		owner.effect(function* () {
+			for (const route of served) yield owner.effect(() => () => {}, `acryl-router: serves ${route}`);
+			yield remove;
+		}, `acryl-router: route ${path}`);
+		return () => {
+			remove();
+		};
+	}
+	/**
+	* The mount's own copy of `app`'s routes as they are now (like the core's `app.route`), each handler wrapped so the router knows which
+	* mount's code a request is in. The core's `app.route` runs first so a sub-app's own `onError` still applies to its routes.
+	*/
+	snapshot(path, app) {
+		const copy = copyRoutes(app);
+		const tagged = new Acryl();
+		const mount = {
+			path,
+			app: tagged
+		};
+		for (const route of copy.routes) {
+			const inner = route.handler;
+			const handler = async (c, next) => {
+				const flight = this.flightOf.get(c.req.raw);
+				if (flight === void 0) return inner(c, next);
+				let calledNext = false;
+				flight.running.set(mount, (flight.running.get(mount) ?? 0) + 1);
+				try {
+					const result = await inner(c, () => {
+						calledNext = true;
+						return next();
+					});
+					if (!calledNext && result instanceof Response) flight.producer = mount;
+					return result;
+				} finally {
+					flight.running.set(mount, (flight.running.get(mount) ?? 1) - 1);
+				}
+			};
+			handler[COMPOSED_HANDLER] = inner;
+			tagged.on(route.method, route.path, handler);
+			const registered = tagged.routes.at(-1);
+			if (registered !== void 0) registered.basePath = route.basePath;
+		}
+		return mount;
+	}
+	/** Abort `flights`, cut their bodies short and wait for them to settle, at most `disposeGraceMs`. */
+	async end(flights, why) {
+		if (flights.length === 0) return;
+		for (const flight of flights) {
+			flight.controller.abort();
+			flight.endBody();
+		}
+		let timer;
+		const gaveUp = new Promise((resolve) => {
+			timer = setTimeout(() => {
+				resolve("gave-up");
+			}, this.graceMs);
+		});
+		const outcome = await Promise.race([Promise.allSettled(flights.map((flight) => flight.settled)).then(() => "settled"), 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`);
+	}
+	/** Turn errors no mounted app handled into responses. One handler per router; the calling plugin owns it. */
+	onError(handler) {
+		if (this.state.errorHandler !== void 0) throw new Error("router: an error handler is already registered");
+		this.state.errorHandler = handler;
+		this.state.composed = void 0;
+		const remove = () => {
+			if (this.state.errorHandler !== handler) return;
+			this.state.errorHandler = void 0;
+			this.state.composed = void 0;
+		};
+		this.ctx.effect(() => remove, "acryl-router: onError");
+		return remove;
+	}
+	/** Answer requests no route claimed. One handler per router; the calling plugin owns it. */
+	notFound(handler) {
+		if (this.state.notFoundHandler !== void 0) throw new Error("router: a not-found handler is already registered");
+		this.state.notFoundHandler = handler;
+		this.state.composed = void 0;
+		const remove = () => {
+			if (this.state.notFoundHandler !== handler) return;
+			this.state.notFoundHandler = void 0;
+			this.state.composed = void 0;
+		};
+		this.ctx.effect(() => remove, "acryl-router: notFound");
+		return remove;
+	}
+	/**
+	* Call the router the way a test calls an app: a path or URL string, a `URL` or a `Request`, with the usual init.
+	* A relative path is resolved against `http://localhost`.
+	*/
+	request(input, init, connection) {
+		const request = input instanceof Request ? input : new Request(new URL(String(input), "http://localhost"), init);
+		return this.fetch(request, connection);
+	}
+	/**
+	* Run a request in process. Never throws: failures become a 500, a disposed router answers 503. `connection` describes the transport
+	* (an HTTP adapter passes the socket's peer address and local port); an in-process caller omits it. Handlers read it with
+	* `connectionOf(c)`, abort with `c.req.raw.signal` and keep the request in flight with `c.executionCtx.waitUntil(task)`.
+	*/
+	fetch(request, connection = {}) {
+		if (this.state.closing) return Promise.resolve(new Response("Service Unavailable", { status: 503 }));
+		const controller = new AbortController();
+		const forward = () => controller.abort();
+		if (request.signal.aborted) controller.abort();
+		else request.signal.addEventListener("abort", forward, { once: true });
+		const tasks = [];
+		const executionCtx = {
+			waitUntil: (task) => {
+				tasks.push(task);
+			},
+			passThroughOnException: () => {},
+			props: {}
+		};
+		const env = { connection };
+		let bodyDone = Promise.resolve();
+		let endBody = () => {};
+		let resolveSettled;
+		const flight = {
+			controller,
+			running: /* @__PURE__ */ new Map(),
+			producer: void 0,
+			endBody: () => {
+				endBody();
+			},
+			settled: new Promise((resolve) => {
+				resolveSettled = resolve;
+			})
+		};
+		const inner = new Request(request, { signal: controller.signal });
+		this.flightOf.set(inner, flight);
+		const response = this.dispatch(inner, env, executionCtx).then((raw) => {
+			const tracked = this.track(raw);
+			bodyDone = tracked.done;
+			endBody = tracked.end;
+			if (controller.signal.aborted) tracked.end();
+			return tracked.response;
+		});
+		const settled = response.then(async () => {
+			await bodyDone;
+			await drain(tasks);
+		});
+		resolveSettled(settled);
+		this.flights.add(flight);
+		settled.finally(() => {
+			request.signal.removeEventListener("abort", forward);
+			this.flights.delete(flight);
+		});
+		return response;
+	}
+	async dispatch(request, env, executionCtx) {
+		try {
+			return await this.app().fetch(request, env, executionCtx);
+		} catch (error) {
+			this.ctx.logger.error(`acryl-router: request failed: ${error instanceof Error ? error.message : String(error)}`);
+			return new Response("Internal Server Error", { status: 500 });
+		}
+	}
+	app() {
+		if (this.state.composed !== void 0) return this.state.composed;
+		const root = new Acryl({
+			strict: this.strict,
+			router: new TrieRouter()
+		});
+		for (const mount of this.state.mounts) root.route(mount.path, mount.app);
+		root.onError(this.state.errorHandler ?? this.logError);
+		if (this.state.notFoundHandler !== void 0) root.notFound(this.state.notFoundHandler);
+		this.state.composed = root;
+		return root;
+	}
+	/**
+	* Hand the caller a body the router can end. Reading it passes the handler's chunks through; disposal cancels the handler's stream (which runs
+	* the stream helpers' own abort cleanup) and closes the caller's side, so a stream never outlives the plugin that served it.
+	*/
+	track(response) {
+		const source = response.body;
+		if (source === null) return {
+			response,
+			done: Promise.resolve(),
+			end: () => {}
+		};
+		const reader = source.getReader();
+		let finish;
+		const done = new Promise((resolve) => {
+			finish = resolve;
+		});
+		let ended = false;
+		let sink;
+		const end = () => {
+			if (ended) return;
+			ended = true;
+			finish();
+		};
+		const endEarly = () => {
+			if (ended) return;
+			reader.cancel(/* @__PURE__ */ new Error("acryl-router: disposed")).catch(() => {});
+			try {
+				sink?.close();
+			} catch {}
+			end();
+		};
+		const body = new ReadableStream({
+			start: (controller) => {
+				sink = controller;
+			},
+			pull: async (controller) => {
+				try {
+					const chunk = await reader.read();
+					if (ended) return;
+					if (chunk.done) {
+						controller.close();
+						end();
+					} else controller.enqueue(chunk.value);
+				} catch (error) {
+					if (!ended) controller.error(error);
+					end();
+				}
+			},
+			cancel: async (reason) => {
+				end();
+				await reader.cancel(reason);
+			}
+		});
+		return {
+			response: new Response(body, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			}),
+			done,
+			end: endEarly
+		};
+	}
+};
+function apply(ctx, config = {}) {
+	new Router(ctx, config);
+}
+//#endregion
+export { name as i, Router as n, apply as r, Config as t };

package/lib/timeout.d.ts

@@ -1,5 +1,5 @@
 import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
-import { HTTPException } from "./http-exception.js";
+import { t as HTTPException } from "./http-exception-kpGJkmpi.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/timeout/index.d.ts
 type HTTPExceptionFunction = (context: Context) => HTTPException;