acrylblends 0.8.1 → 0.9.0

package/lib/cordis/inspect.d.ts

@@ -0,0 +1,77 @@
+import { Context, Service } from "@deepseek-ai/cordis";
+
+//#region ../../plugins/acryl-inspect/src/report.d.ts
+/**
+ * The per-plugin contract, read from the running system (spec 046, M4). Cordis already knows a plugin's name, its state, the
+ * services it requires (`inject`) and a labeled tree of everything it registered (`getEffects()`), so there is no second
+ * declaration to keep in step with the code. The only convention is the label: an effect says what it is, prefixed by its
+ * owner (`acryl-router: GET /a`). Pure functions over a structural view of a fiber, so they are testable without Cordis.
+ */
+/** The plugin states Cordis defines, by their numeric values (`FiberState`). */
+declare const STATE_NAMES: readonly ["PENDING", "LOADING", "ACTIVE", "FAILED", "DISPOSED", "UNLOADING"];
+type FiberStateName = typeof STATE_NAMES[number];
+interface EffectLabel {
+  readonly label: string;
+  readonly children: readonly EffectLabel[];
+}
+/** The slice of a Cordis fiber this module reads. */
+interface FiberView {
+  readonly state: number;
+  readonly inject: Readonly<Record<string, unknown>>;
+  readonly runtime: {
+    readonly name?: string | undefined;
+  } | null;
+  /** The context the fiber was loaded from; its own `fiber` is the owning plugin when this fiber is an inline `ctx.inject(...)` callback. */
+  readonly parent?: {
+    readonly fiber?: FiberView | undefined;
+  } | undefined;
+  getEffects(): readonly EffectLabel[];
+}
+interface RouteReport {
+  readonly method: string;
+  readonly path: string;
+}
+interface PluginReport {
+  readonly name: string;
+  readonly state: FiberStateName;
+  /** Services the plugin waits for before it starts. */
+  readonly requires: readonly string[];
+  /** Services it provides. */
+  readonly provides: readonly string[];
+  /** Paths it mounted an app under on the router. */
+  readonly mounts: readonly string[];
+  /** What those mounts serve; middleware and `all` routes show as method `ALL`, the way the core keeps them. */
+  readonly routes: readonly RouteReport[];
+  /** Every other labeled registration (event listeners, timers, commands, tools). */
+  readonly other: readonly string[];
+  /** How many registrations disappear when it unloads: all of them. */
+  readonly removedOnUnload: number;
+}
+declare function stateName(state: number): FiberStateName;
+/** Describe one fiber, counting the registrations of the unnamed inline callbacks it owns (`adopted`) as its own. */
+declare function reportFiber(fiber: FiberView, adopted?: readonly FiberView[]): PluginReport;
+/** A short, human explanation of one plugin: what it needs, what it adds, and what happens when it unloads. */
+declare function explain(report: PluginReport): string;
+/** One block per plugin, in registration order. */
+declare function renderReports(reports: readonly PluginReport[]): string;
+//#endregion
+//#region ../../plugins/acryl-inspect/src/service.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    inspect: Inspect;
+  }
+}
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-inspect";
+declare class Inspect extends Service {
+  constructor(ctx: Context);
+  /** A report for every live plugin instance, in registry order. */
+  plugins(): PluginReport[];
+  /** The text explanation of the plugin called `pluginName`, or `undefined` when none is registered. */
+  explain(pluginName: string): string | undefined;
+  /** The whole system as text. */
+  render(): string;
+}
+declare function apply(ctx: Context): void;
+//#endregion
+export { type EffectLabel, type FiberStateName, type FiberView, Inspect, type PluginReport, type RouteReport, apply, explain, name, renderReports, reportFiber, stateName };

package/lib/cordis/inspect.js

@@ -0,0 +1,149 @@
+import { t as Acryl } from "../app-BM0rTCp7.js";
+import { loopbackOnly } from "../loopback-only.js";
+import "../src-CwABFr6r.js";
+import "../middleware-CPQ8himN.js";
+import { Service } from "@deepseek-ai/cordis";
+//#region ../../plugins/acryl-inspect/src/report.ts
+/**
+* The per-plugin contract, read from the running system (spec 046, M4). Cordis already knows a plugin's name, its state, the
+* services it requires (`inject`) and a labeled tree of everything it registered (`getEffects()`), so there is no second
+* declaration to keep in step with the code. The only convention is the label: an effect says what it is, prefixed by its
+* owner (`acryl-router: GET /a`). Pure functions over a structural view of a fiber, so they are testable without Cordis.
+*/
+/** The plugin states Cordis defines, by their numeric values (`FiberState`). */
+const STATE_NAMES = [
+	"PENDING",
+	"LOADING",
+	"ACTIVE",
+	"FAILED",
+	"DISPOSED",
+	"UNLOADING"
+];
+const PROVIDE = /^ctx\.provide\("(.+)"\)$/;
+const MOUNT = /^acryl-router: route (\S+)$/;
+const SERVES = /^acryl-router: serves ([A-Z]+) (\S+)$/;
+function flatten(effects) {
+	return effects.flatMap((effect) => [effect.label, ...flatten(effect.children)]);
+}
+/** A mount's children name the routes it serves; they describe that one registration and are not registrations of their own. */
+function routeOf(label) {
+	const served = SERVES.exec(label);
+	return served?.[1] !== void 0 && served[2] !== void 0 ? {
+		method: served[1],
+		path: served[2]
+	} : void 0;
+}
+function stateName(state) {
+	return STATE_NAMES[state] ?? "FAILED";
+}
+const isNamed = (fiber) => (fiber.runtime?.name ?? "") !== "";
+/** The named plugin a fiber belongs to: itself, or for an unnamed inline callback (`ctx.inject([...], inner => ...)`) the nearest named ancestor. */
+function ownerOf(fiber) {
+	let current = fiber;
+	while (!isNamed(current)) {
+		const parent = current.parent?.fiber;
+		if (parent === void 0 || parent === current) return fiber;
+		current = parent;
+	}
+	return current;
+}
+/** Describe one fiber, counting the registrations of the unnamed inline callbacks it owns (`adopted`) as its own. */
+function reportFiber(fiber, adopted = []) {
+	const provides = [];
+	const mounts = [];
+	const routes = [];
+	const other = [];
+	const labels = [fiber, ...adopted].flatMap((source) => flatten(source.getEffects()));
+	let registrations = 0;
+	for (const label of labels) {
+		const provided = PROVIDE.exec(label);
+		const mount = MOUNT.exec(label);
+		const route = routeOf(label);
+		if (route !== void 0) {
+			routes.push(route);
+			continue;
+		}
+		registrations += 1;
+		if (provided?.[1] !== void 0) provides.push(provided[1]);
+		else if (mount?.[1] !== void 0) mounts.push(mount[1]);
+		else other.push(label);
+	}
+	return {
+		name: isNamed(fiber) ? fiber.runtime?.name ?? "anonymous" : "anonymous",
+		state: stateName(fiber.state),
+		requires: Object.keys(fiber.inject).sort(),
+		provides: provides.sort(),
+		mounts,
+		routes,
+		other,
+		removedOnUnload: registrations
+	};
+}
+const list = (items) => items.length === 0 ? "nothing" : items.join(", ");
+/** A short, human explanation of one plugin: what it needs, what it adds, and what happens when it unloads. */
+function explain(report) {
+	const lines = [
+		`${report.name} (${report.state})`,
+		`  needs:     ${list(report.requires)}`,
+		`  provides:  ${list(report.provides)}`,
+		`  routes:    ${list(report.routes.map((route) => `${route.method} ${route.path}`))}`,
+		`  mounts:    ${report.mounts.length === 0 ? "nothing" : report.mounts.join(", ")}`
+	];
+	if (report.other.length > 0) lines.push(`  also:      ${report.other.join("; ")}`);
+	lines.push(report.state === "PENDING" ? `  waiting:   it starts when ${list(report.requires)} ${report.requires.length === 1 ? "is" : "are"} available` : `  unloading: removes ${String(report.removedOnUnload)} registration${report.removedOnUnload === 1 ? "" : "s"} and nothing else`);
+	return lines.join("\n");
+}
+/** One block per plugin, in registration order. */
+function renderReports(reports) {
+	return reports.map(explain).join("\n\n");
+}
+//#endregion
+//#region ../../plugins/acryl-inspect/src/service.ts
+/**
+* The ACRYL inspector (`ctx.inspect`): what every running plugin requires, provides and registers, read from the live
+* registry. It owns no state and registers nothing of its own beyond an optional read-only pair of router routes, which are
+* reachable in process unless some plugin mounts their prefix over HTTP.
+*/
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-inspect";
+var Inspect = class extends Service {
+	constructor(ctx) {
+		super(ctx, "inspect");
+	}
+	/** A report for every live plugin instance, in registry order. */
+	plugins() {
+		const fibers = [...this.ctx.registry.values()].flatMap((runtime) => [...runtime.fibers]);
+		const adopted = /* @__PURE__ */ new Map();
+		const owners = [];
+		for (const fiber of fibers) {
+			const owner = ownerOf(fiber);
+			if (owner === fiber) owners.push(fiber);
+			else adopted.set(owner, [...adopted.get(owner) ?? [], fiber]);
+		}
+		return owners.map((fiber) => reportFiber(fiber, adopted.get(fiber) ?? []));
+	}
+	/** The text explanation of the plugin called `pluginName`, or `undefined` when none is registered. */
+	explain(pluginName) {
+		const found = this.plugins().filter((report) => report.name === pluginName);
+		return found.length === 0 ? void 0 : found.map(explain).join("\n\n");
+	}
+	/** The whole system as text. */
+	render() {
+		return renderReports(this.plugins());
+	}
+};
+function apply(ctx) {
+	const inspect = new Inspect(ctx);
+	ctx.inject(["router"], (inner) => {
+		const api = new Acryl().use(loopbackOnly({ inProcess: "allow" })).get("/plugins", (c) => c.json(inspect.plugins())).get("/plugins/:name", (c) => {
+			const text = inspect.explain(c.req.param("name"));
+			return text === void 0 ? c.json({ error: "no such plugin" }, 404) : c.text(text);
+		});
+		inner.router.route("/api/inspect", api);
+		inner.inject(["routerHttp"], (http) => {
+			http.routerHttp.mount("/api/inspect");
+		});
+	});
+}
+//#endregion
+export { Inspect, apply, explain, name, renderReports, reportFiber, stateName };

package/lib/cordis/kv-db.d.ts

@@ -0,0 +1,16 @@
+import { KvOnDbOptions, kvOnDb } from "../kv/db.js";
+import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region ../../plugins/acryl-kv-db/src/index.d.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-kv-db";
+/** The service this plugin needs: Cordis starts it only while a `db` provider is active. */
+declare const inject: string[];
+interface Config {
+  table?: string;
+}
+declare const Config: z<Config>;
+declare function apply(ctx: Context, rawConfig?: Config): Promise<void>;
+//#endregion
+export { Config, type KvOnDbOptions, apply, inject, kvOnDb, name };

package/lib/cordis/kv-db.js

@@ -0,0 +1,18 @@
+import "../src-DRFVEQQb.js";
+import { kvOnDb } from "../kv/db.js";
+import z from "@deepseek-ai/schemastery";
+//#region ../../plugins/acryl-kv-db/src/index.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-kv-db";
+/** The service this plugin needs: Cordis starts it only while a `db` provider is active. */
+const inject = ["db"];
+const Config = z.object({ table: z.string().description("The table that holds the documents. Defaults to kv.") });
+async function apply(ctx, rawConfig = {}) {
+	const config = Config(rawConfig);
+	const kv = kvOnDb(ctx.get("db"), config.table === void 0 ? {} : { table: config.table });
+	await ctx.effect(async function* () {
+		yield ctx.reflect.provide("kv", kv);
+	}, "acryl-kv-db");
+}
+//#endregion
+export { Config, apply, inject, kvOnDb, name };

package/lib/cordis/kv-json.d.ts

@@ -0,0 +1,16 @@
+import { OpenKvOptions, openKv } from "../kv/json.js";
+import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region ../../plugins/acryl-kv-json/src/index.d.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-kv-json";
+interface Config {
+  path?: string;
+}
+declare const Config: z<Config>;
+/** The file name used in the app home when `path` is not configured. */
+declare const DEFAULT_FILE = "kv.json";
+declare function apply(ctx: Context, rawConfig?: Config): Promise<void>;
+//#endregion
+export { Config, DEFAULT_FILE, type OpenKvOptions, apply, name, openKv };

package/lib/cordis/kv-json.js

@@ -0,0 +1,44 @@
+import "../src-DRFVEQQb.js";
+import { openKv } from "../kv/json.js";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import z from "@deepseek-ai/schemastery";
+//#region ../../plugins/acryl-kv-json/src/index.ts
+/**
+* The JSON-file provider of the `kv` port (spec 049 slice 3): one file, rewritten atomically on every write, opened with the plain
+* `openKv` and provided as `kv` by this Cordis plugin. App plugins declare `inject: ['kv']` and import types from `acryl-kv` only, so
+* replacing this row with `acryl-kv-db` does not touch them.
+*
+* Unloading withdraws `kv` first, so consumers stop calling, and then closes the store: the close waits for the writes in flight.
+*/
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-kv-json";
+function isAppHome(value) {
+	return typeof value === "object" && value !== null && "home" in value && typeof value.home === "string";
+}
+const Config = z.object({ path: z.string().description("The JSON file, absolute or relative to the app. Defaults to kv.json in the ACRYL app home; required where there is none.") });
+/** The file name used in the app home when `path` is not configured. */
+const DEFAULT_FILE = "kv.json";
+/** A configured path as a file path: absolute as given, relative to the Loader's base URL (the app) otherwise. */
+function resolveFromApp(ctx, path) {
+	if (path.startsWith("file:")) return fileURLToPath(path);
+	if (isAbsolute(path)) return path;
+	const base = ctx.baseUrl;
+	if (base === void 0 || !base.startsWith("file:")) throw new Error(`acryl-kv-json: path ${JSON.stringify(path)} is relative, but this app has no file base URL to resolve it from; give an absolute path`);
+	return resolve(base.endsWith("/") ? fileURLToPath(base) : dirname(fileURLToPath(base)), path);
+}
+async function apply(ctx, rawConfig = {}) {
+	const config = Config(rawConfig);
+	const appInstance = ctx.get("appInstance");
+	let file;
+	if (config.path !== void 0) file = resolveFromApp(ctx, config.path);
+	else if (isAppHome(appInstance)) file = join(appInstance.home, DEFAULT_FILE);
+	else throw new Error("acryl-kv-json: no file path; set `path` in this row's config (there is no ACRYL app home to default to)");
+	await ctx.effect(async function* () {
+		const opened = await openKv({ path: file });
+		yield () => opened.close();
+		yield ctx.reflect.provide("kv", opened.kv);
+	}, `acryl-kv-json: ${file}`);
+}
+//#endregion
+export { Config, DEFAULT_FILE, apply, name, openKv };

package/lib/cordis/kv.d.ts

@@ -0,0 +1,8 @@
+import { n as Kv } from "../kv-9f-AlRKN.js";
+
+//#region ../../plugins/acryl-kv/src/cordis.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    kv: Kv;
+  }
+}

package/lib/cordis/kv.js

@@ -0,0 +1 @@
+export {};

package/lib/cordis/node-server.d.ts

@@ -0,0 +1,45 @@
+import { t as RequestError } from "../error-t4N2js2I.js";
+import { ServeStaticOptions, serveStatic } from "../node-server/serve-static.js";
+import { Context, Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region ../../plugins/acryl-node-server/src/index.d.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-node-server";
+declare const inject: string[];
+interface Config {
+  hostname: string;
+  port: number;
+  scan: number;
+}
+/** Every field has a default, so a caller passes only what it changes: `ctx.plugin(plugin, { ... })` takes the partial shape. */
+declare const Config: z<Partial<Config>, Config>;
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    nodeServer: NodeServer;
+  }
+}
+declare class NodeServer extends Service {
+  readonly hostname: string;
+  readonly config: Config;
+  private readonly server;
+  private bound;
+  constructor(ctx: Context, config: Config);
+  /** The port in use, 0 before the server listens. */
+  get port(): number;
+  /** The address clients use. */
+  get url(): string;
+  /** Bind, scanning past taken ports. */
+  listen(): Promise<void>;
+}
+/**
+ * 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.
+ */
+declare function isPortUnavailable(error: unknown, platform?: NodeJS.Platform): boolean;
+/** Loads once the server listens, so a plugin that injects `nodeServer` can rely on `url`. A failure to bind fails the plugin. */
+declare function apply(ctx: Context, config?: Partial<Config>): Promise<void>;
+//#endregion
+export { Config, NodeServer, RequestError, type ServeStaticOptions, apply, inject, isPortUnavailable, name, serveStatic };

package/lib/cordis/node-server.js

@@ -0,0 +1,93 @@
+import { a as Request, o as RequestError, t as createAdaptorServer } from "../server-DvgMGtzo.js";
+import { t as serveStatic } from "../serve-static-3uo_9rjF.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"];
+/** 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 is followed by the next free one."),
+	scan: z.number().min(0).default(20).description("How many further ports to try when the configured one is taken.")
+});
+var NodeServer = class extends Service {
+	hostname;
+	config;
+	server;
+	bound = 0;
+	constructor(ctx, config) {
+		super(ctx, "nodeServer");
+		this.config = config;
+		this.hostname = config.hostname;
+		const router = ctx.router;
+		this.server = createAdaptorServer({
+			fetch: (request, { incoming }) => router.fetch(new Request(request), {
+				remoteAddress: incoming.socket.remoteAddress,
+				localPort: incoming.socket.localPort
+			}),
+			hostname: config.hostname,
+			overrideGlobalObjects: false
+		});
+		ctx.effect(() => async () => {
+			this.server.closeAllConnections();
+			if (this.server.listening) await new Promise((resolve) => {
+				this.server.close(() => {
+					resolve();
+				});
+			});
+		}, "acryl-node-server: close listener and open connections");
+	}
+	/** 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. */
+	async listen() {
+		const { port, scan, hostname } = this.config;
+		const last = port === 0 ? 0 : Math.min(65535, port + scan);
+		for (let candidate = port; candidate <= last; candidate += 1) 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 free port from ${String(port)} to ${String(last)} on ${hostname}`);
+	}
+};
+/**
+* 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,
+		...config
+	}).listen();
+}
+//#endregion
+export { Config, NodeServer, RequestError, apply, inject, isPortUnavailable, name, serveStatic };

package/lib/cordis/router-http.d.ts

@@ -0,0 +1,56 @@
+import { i as RouterHttpService } from "../index-BqVQkTnu.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Context, Service } from "@deepseek-ai/cordis";
+
+//#region ../../plugins/acryl-router-http/src/serve.d.ts
+/** The slice of the router this adapter needs; `acryl-router`'s `Router` satisfies it. */
+interface FetchRouter {
+  fetch(request: Request, connection?: {
+    readonly remoteAddress?: string | undefined;
+    readonly localPort?: number | undefined;
+  }): Promise<Response>;
+}
+/**
+ * Serve one node request through the router and write the result. The request's abort signal fires when the client
+ * disconnects before the response finished; the socket's peer address and local port travel as connection info, never in the request.
+ */
+declare function serve(router: FetchRouter, req: IncomingMessage, res: ServerResponse): Promise<void>;
+//#endregion
+//#region ../../plugins/acryl-router-http/src/bridge.d.ts
+/** Build the Web `Request` for an incoming message. The body, when the method has one, is streamed, not buffered. */
+declare function toRequest(req: IncomingMessage, signal: AbortSignal): Request;
+/**
+ * Write a Web `Response` to the node response: status, headers (repeated `set-cookie` kept separate) and the streamed body.
+ * A client that disconnects mid-stream ends the copy quietly; the caller's abort signal is what stops the handler.
+ */
+declare function sendResponse(res: ServerResponse, response: Response, method: string): Promise<void>;
+//#endregion
+//#region ../../plugins/acryl-router-http/src/index.d.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-router-http";
+/** Hard requirements: both services must exist, otherwise this plugin stays PENDING. */
+declare const inject: string[];
+/**
+ * The slice of the DSH `webServer` this adapter uses, as its own port: a prefix claim that returns its remover. The service
+ * is read by name, so this package imports nothing from the DeepSeek Harness (the layout gate keeps that count falling).
+ */
+interface WebServerPort {
+  register(route: {
+    readonly kind: 'prefix';
+    readonly path: string;
+    readonly handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void>;
+  }): () => void;
+}
+declare class RouterHttp extends Service implements RouterHttpService {
+  private readonly router;
+  private readonly web;
+  constructor(ctx: Context);
+  /**
+   * Serve `prefix` and everything below it through the router. Returns a remover; the mount also goes away when the
+   * calling plugin unloads. A prefix another route already claims throws, as the webServer treats it as misconfiguration.
+   */
+  mount(prefix: string): () => void;
+}
+declare function apply(ctx: Context): void;
+//#endregion
+export { type FetchRouter, RouterHttp, WebServerPort, apply, inject, name, sendResponse, serve, toRequest };

package/lib/cordis/router-http.js

@@ -0,0 +1,117 @@
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { Service } from "@deepseek-ai/cordis";
+//#region ../../plugins/acryl-router-http/src/bridge.ts
+const FALLBACK_ORIGIN = "http://localhost";
+/** Build the Web `Request` for an incoming message. The body, when the method has one, is streamed, not buffered. */
+function toRequest(req, signal) {
+	let url;
+	try {
+		url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+	} catch {
+		url = new URL(req.url ?? "/", FALLBACK_ORIGIN);
+	}
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+		else headers.set(key, value);
+	}
+	const method = (req.method ?? "GET").toUpperCase();
+	if (method === "GET" || method === "HEAD") return new Request(url, {
+		method,
+		headers,
+		signal
+	});
+	const init = {
+		method,
+		headers,
+		signal,
+		body: Readable.toWeb(req),
+		duplex: "half"
+	};
+	return new Request(url, init);
+}
+/**
+* Write a Web `Response` to the node response: status, headers (repeated `set-cookie` kept separate) and the streamed body.
+* A client that disconnects mid-stream ends the copy quietly; the caller's abort signal is what stops the handler.
+*/
+async function sendResponse(res, response, method) {
+	const headers = {};
+	response.headers.forEach((value, key) => {
+		if (key !== "set-cookie") headers[key] = value;
+	});
+	const cookies = response.headers.getSetCookie();
+	if (cookies.length > 0) headers["set-cookie"] = cookies;
+	res.writeHead(response.status, headers);
+	res.flushHeaders();
+	if (response.body === null || method === "HEAD") {
+		res.end();
+		return;
+	}
+	try {
+		await pipeline(Readable.fromWeb(response.body), res);
+	} catch {
+		if (!res.writableEnded) res.destroy();
+	}
+}
+//#endregion
+//#region ../../plugins/acryl-router-http/src/serve.ts
+/**
+* Serve one node request through the router and write the result. The request's abort signal fires when the client
+* disconnects before the response finished; the socket's peer address and local port travel as connection info, never in the request.
+*/
+async function serve(router, req, res) {
+	const controller = new AbortController();
+	res.once("close", () => {
+		if (!res.writableFinished) controller.abort();
+	});
+	const method = (req.method ?? "GET").toUpperCase();
+	let response;
+	try {
+		response = await router.fetch(toRequest(req, controller.signal), {
+			remoteAddress: req.socket.remoteAddress,
+			localPort: req.socket.localPort
+		});
+	} catch {
+		response = new Response("Internal Server Error", { status: 500 });
+	}
+	await sendResponse(res, response, method);
+}
+//#endregion
+//#region ../../plugins/acryl-router-http/src/index.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-router-http";
+/** Hard requirements: both services must exist, otherwise this plugin stays PENDING. */
+const inject = ["router", "webServer"];
+const PREFIX_PATTERN = /^\/[A-Za-z0-9._~\-/]*[A-Za-z0-9._~-]$/;
+var RouterHttp = class extends Service {
+	router;
+	web;
+	constructor(ctx) {
+		super(ctx, "routerHttp");
+		this.router = ctx.router;
+		this.web = ctx.get("webServer");
+	}
+	/**
+	* Serve `prefix` and everything below it through the router. Returns a remover; the mount also goes away when the
+	* calling plugin unloads. A prefix another route already claims throws, as the webServer treats it as misconfiguration.
+	*/
+	mount(prefix) {
+		if (!PREFIX_PATTERN.test(prefix)) throw new TypeError(`acryl-router-http: "${prefix}" is not a mountable path prefix`);
+		const remove = this.web.register({
+			kind: "prefix",
+			path: prefix,
+			handler: (req, res) => serve(this.router, req, res)
+		});
+		this.ctx.effect(() => () => {
+			remove();
+		}, `acryl-router-http: mount ${prefix}`);
+		return remove;
+	}
+};
+function apply(ctx) {
+	new RouterHttp(ctx);
+}
+//#endregion
+export { RouterHttp, apply, inject, name, sendResponse, serve, toRequest };

package/lib/cordis/router.d.ts

@@ -0,0 +1,8 @@
+import { B as NotFoundHandler, L as MiddlewareHandler, O as Handler, Q as ValidationTargets, V as NotFoundResponse, X as ToSchema, Y as Schema, Z as TypedResponse, a as ExecutionContext, j as Input, n as ContextRenderer, r as ContextVariableMap, s as AcrylRequest, t as Context, v as Env, y as ErrorHandler, z as Next } from "../context-DS3fYyG-.js";
+import { c as StatusCode, n as ContentfulStatusCode } from "../http-status-DaAwGAFL.js";
+import { a as getConnInfo, i as connectionOf, n as RouterBindings, r as RouterEnv, t as ConnectionInfo } from "../connection-ZLEso7XL.js";
+import { t as Acryl } from "../app-D8riatvv.js";
+import { n as AppRequest, t as App } from "../deprecated-CTy4N7ng.js";
+import { a as TrailingSlash, i as RouterHttpService, n as MountableApp, o as apply, r as Router, s as name, t as Config } from "../index-BqVQkTnu.js";
+import { t as HTTPException } from "../http-exception-kpGJkmpi.js";
+export { Acryl, type AcrylRequest, App, type AppRequest, Config, type ConnectionInfo, type ContentfulStatusCode, Context, type ContextRenderer, type ContextVariableMap, type Env, type ErrorHandler, type ExecutionContext, HTTPException, type Handler, type Input, type MiddlewareHandler, type MountableApp, type Next, type NotFoundHandler, type NotFoundResponse, Router, type RouterBindings, type RouterEnv, type RouterHttpService, type Schema, type StatusCode, type ToSchema, type TrailingSlash, type TypedResponse, type ValidationTargets, apply, connectionOf, getConnInfo, name };