@rhythmjs/router 0.0.7 → 0.0.9

package/README.md

@@ -9,15 +9,15 @@ Web-standard HTTP routing on top of `@rhythmjs/rhythm`. `RhythmRouter` matches r
 ```ts
 import { Rhythm } from "@rhythmjs/rhythm";
 import { RhythmRouter } from "@rhythmjs/router";
-import { toFetchHandler } from "@rhythmjs/router/adapters/bun";
-import type { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+import { serve } from "@rhythmjs/router/serve";
+import type { RhythmHttpContext } from "@rhythmjs/router/context";
 
 const usersRouter = new RhythmRouter({ prefix: "/users" }).get("/:id", (ctx) => {
   ctx.json({ id: ctx.params.id });
 });
 
-const app = new Rhythm<RhythmHttpContext>().use(usersRouter.routes());
-Bun.serve({ fetch: toFetchHandler(app) });
+const app = new Rhythm<RhythmHttpContext>().use(usersRouter.middleware());
+serve(app, { port: 3000 });
 ```
 
 A fuller runnable version, including nested prefixes and a fallback route, is at [`examples/router`](../../examples/router).
@@ -37,18 +37,118 @@ A fuller runnable version, including nested prefixes and a fallback route, is at
 - `.get/.post/.put/.patch/.delete(path, ...handlers)` — register a route; `path` may contain `:param` segments.
 - `.use(fn)` — plain middleware. `.use(child)` — mount a nested `RhythmRouter` (prefixes compose).
 - `.routes()` — this router as a plain middleware, for mounting into a `Rhythm` app via `.use()`; the router's only way onto a server. Note: mounting a _router_ into a _router_ must use `.use(child)`, not `.use(child.routes())` — an opaque middleware can't have the parent's prefix applied to its routes.
-- `ctx.json/.text/.html(body, status?)`, `ctx.error(status, message?)`, `ctx.redirect(url, status?)` — response helpers built into the context by the adapters (`createHttpContext` in `adapters/context`).
+- `ctx.json/.text/.html(body, status?)`, `ctx.error(status, message?)`, `ctx.redirect(url, status?)` — response helpers built into the context by the adapters (`createHttpContext` in `@rhythmjs/router/context`).
 - `toFetchHandler(app)` — bridges a `Rhythm` app to a Web-standard `(Request) => Promise<Response>` handler.
 
-## Runtime adapters
+## Serving
 
-Everything above (`RhythmRouter`, `ctx.response`, etc.) is runtime-agnostic; only turning it into an actual server touches a specific runtime.
+Everything above (`RhythmRouter`, `ctx.response`, etc.) is runtime-agnostic. Two primitives turn an app into a server, both built on [srvx](https://srvx.h3.dev):
 
-- **`@rhythmjs/router/adapters/web-std`** — `toFetchHandler(app)`, the runtime-neutral Web-standard `(Request) => Promise<Response>` adapter every fetch-based runtime can use.
-- **`@rhythmjs/router/adapters/bun`** — re-exports `toFetchHandler` from `web-std`, for `Bun.serve({ fetch: toFetchHandler(app) })`.
-- **`@rhythmjs/router/adapters/deno`** — re-exports the same `toFetchHandler`, for `Deno.serve(toFetchHandler(app))`. `Deno.serve()` accepts the identical handler shape `Bun.serve()` does, so no conversion is needed.
-- **`@rhythmjs/router/adapters/node`** — `toNodeHandler(app, options?)`, for `http.createServer(toNodeHandler(app)).listen(port)`. Node's `IncomingMessage`/`ServerResponse` aren't Web-standard, so this one does real conversion:
-  - The request body is read eagerly into a buffer, up to `options.bodyLimit` (default 1mb). This guarantees the socket is always fully drained before the handler runs, even if the handler never reads `ctx.request`'s body — otherwise, on a keep-alive connection, unconsumed bytes left on the socket would stall the next request on it. A body over the limit gets a `413` and the connection is closed rather than kept alive.
-  - Pass `{ bodyLimit: false }` to opt out of buffering — `ctx.request`'s body becomes a live stream over the raw connection instead, with no size limit, for uploads or proxying where materializing the whole body in memory isn't acceptable. This reintroduces the keep-alive caveat: if the handler doesn't read the body, unconsumed bytes are left on the socket.
-  - The resulting `Response` is streamed back to the client via `Readable.fromWeb(...).pipe(res)`.
-  - Errors thrown anywhere in the middleware chain are caught, logged via `console.error`, and answered with a 500 (or the connection is destroyed if headers were already sent) — without this, an unhandled rejection would crash the whole Node process.
+- **`serve(app, options)`** (`@rhythmjs/router/serve`) — starts a server on Node, Bun, or Deno with one identical call; srvx picks the runtime implementation via conditional exports. On Node, requests are lazy: method, url, headers, and body materialize only when middleware touches them.
+- **`toFetchHandler(app)`** (`@rhythmjs/router/fetch`) — the universal `(Request) => Promise<Response>` handler, for platforms that invoke you per request instead of letting you own a listener.
+
+`serve()` accepts every srvx `ServerOptions` field except `fetch`: `port`, `hostname`, `tls` (HTTPS/HTTP2), `maxRequestBodySize` (an over-limit body read is answered with `413`), `reusePort`, `gracefulShutdown`, plus the three extension points below. Errors thrown in the middleware chain are answered with `500` (or the error's own `status`) without crashing the process; override the mapping with `options.error`.
+
+### Extending: CORS, WebSockets, and similar
+
+- **`middleware`** — srvx middlewares (`(request, next) => Response`) run around the whole app, the natural place for CORS, logging, or auth gates:
+
+  ```ts
+  serve(app, {
+    middleware: [
+      async (request, next) => {
+        if (request.method === "OPTIONS")
+          return new Response(null, { status: 204, headers: { "access-control-allow-origin": "*" } });
+        const response = await next();
+        response.headers.set("access-control-allow-origin", "*");
+        return response;
+      },
+    ],
+  });
+  ```
+
+- **`plugins`** — a plugin receives the live srvx `Server`, the hook for anything below fetch, WebSockets included ([crossws](https://crossws.h3.dev) attaches here; on Node the raw server is at `server.node.server`):
+
+  ```ts
+  serve(app, { plugins: [(server) => wireWebSockets(server)] });
+  ```
+
+- **`error`** — replace the default error-to-response mapping.
+
+## Deploying per runtime
+
+One app definition; each runtime has its own adapter under `@rhythmjs/router/adapters/*`, hono-style: import from your target's adapter and export what the platform expects. Runtimes that speak web-standard `Request`/`Response` natively (Bun, Deno, Vercel) can equally use `toFetchHandler(app)` from `@rhythmjs/router/fetch` — their adapters are aliases for it.
+
+Every adapter maps errors thrown in the middleware chain to a response (`500`, or the error's own `status`) instead of crashing, and accepts `{ onError }` to replace that mapping: `handle(app, { onError: (error) => new Response("down", { status: 503 }) })`. Platform metadata (Cloudflare `env`/`ctx`, the Netlify context) is readable in middleware via `getRuntime(ctx.request)` from `@rhythmjs/router/context`.
+
+**Node** — `getRequestListener` returns a listener for your own `node:http` server:
+
+```ts
+import { createServer } from "node:http";
+import { getRequestListener } from "@rhythmjs/router/adapters/node";
+
+createServer(getRequestListener(app, { maxRequestBodySize: 1024 * 1024 })).listen(3000);
+```
+
+(Or skip the adapter entirely and use `serve(app, { port: 3000 })`.)
+
+**Bun**
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/bun";
+
+Bun.serve({ port: 3000, fetch: handle(app) });
+```
+
+**Deno**
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/deno";
+
+Deno.serve({ port: 3000 }, handle(app));
+```
+
+**Vercel** — in a catch-all route file:
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/vercel";
+
+const handler = handle(app);
+export const GET = handler;
+export const POST = handler; // …and the other methods you serve
+```
+
+**Cloudflare Workers** — `env` and `ctx` are exposed to middleware as `ctx.request.runtime.cloudflare`:
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/cloudflare";
+
+export default { fetch: handle(app) };
+```
+
+**AWS Lambda** — API Gateway v1/v2 events, translated by srvx:
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/aws-lambda";
+
+export const lambda = handle(app);
+```
+
+**Netlify Edge Functions** — the Netlify context is exposed as `ctx.request.runtime.netlify`:
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/netlify";
+
+export default handle(app);
+export const config = { path: "/*" };
+```
+
+**Service workers**
+
+```ts
+import { handle } from "@rhythmjs/router/adapters/service-worker";
+
+addEventListener("fetch", handle(app));
+```
+
+Any other fetch-based runtime works with the raw primitive: `toFetchHandler(app)` from `@rhythmjs/router/fetch`.

package/dist/adapters/aws-lambda.d.ts

@@ -0,0 +1,8 @@
+import { t as RhythmHttpContext } from "../context-ChHlG-q0.js";
+import { t as AdapterOptions } from "../base--TyruAfY.js";
+import { AWSLambdaHandler } from "srvx/aws-lambda";
+import { Rhythm } from "@rhythmjs/rhythm";
+//#region src/adapters/aws-lambda.d.ts
+export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: AdapterOptions): AWSLambdaHandler;
+//#endregion
+export type { AWSLambdaHandler, AdapterOptions };

package/dist/adapters/aws-lambda.js

@@ -0,0 +1,9 @@
+import { t as createFetchAdapter } from "../base-B8GEu3z4.js";
+import { toLambdaHandler } from "srvx/aws-lambda";
+//#region src/adapters/aws-lambda.ts
+const fetchHandle = createFetchAdapter();
+function handle(app, options = {}) {
+	return toLambdaHandler({ fetch: fetchHandle(app, options) });
+}
+//#endregion
+export { handle };

package/dist/adapters/bun.d.ts

@@ -1,2 +1,5 @@
-import { toFetchHandler } from "./web-std.js";
-export { toFetchHandler };
+import { n as FetchAdapter, t as AdapterOptions } from "../base--TyruAfY.js";
+//#region src/adapters/bun.d.ts
+export declare const handle: FetchAdapter;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/bun.js

@@ -1,2 +1,5 @@
-import { toFetchHandler } from "./web-std.js";
-export { toFetchHandler };
+import { t as createFetchAdapter } from "../base-B8GEu3z4.js";
+//#region src/adapters/bun.ts
+const handle = createFetchAdapter();
+//#endregion
+export { handle };

package/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,5 @@
+import { n as FetchAdapter, t as AdapterOptions } from "../base--TyruAfY.js";
+//#region src/adapters/cloudflare.d.ts
+export declare const handle: FetchAdapter<[env?: unknown, context?: unknown]>;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/cloudflare.js

@@ -0,0 +1,13 @@
+import { n as setRuntime, t as createFetchAdapter } from "../base-B8GEu3z4.js";
+//#region src/adapters/cloudflare.ts
+const handle = createFetchAdapter((request, env, context) => {
+	if (env !== void 0 || context !== void 0) setRuntime(request, {
+		name: "cloudflare",
+		cloudflare: {
+			env,
+			context
+		}
+	});
+});
+//#endregion
+export { handle };

package/dist/adapters/deno.d.ts

@@ -1,2 +1,5 @@
-import { toFetchHandler } from "./web-std.js";
-export { toFetchHandler };
+import { n as FetchAdapter, t as AdapterOptions } from "../base--TyruAfY.js";
+//#region src/adapters/deno.d.ts
+export declare const handle: FetchAdapter;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/deno.js

@@ -1,2 +1,5 @@
-import { toFetchHandler } from "./web-std.js";
-export { toFetchHandler };
+import { t as createFetchAdapter } from "../base-B8GEu3z4.js";
+//#region src/adapters/deno.ts
+const handle = createFetchAdapter();
+//#endregion
+export { handle };

package/dist/adapters/netlify.d.ts

@@ -0,0 +1,5 @@
+import { n as FetchAdapter, t as AdapterOptions } from "../base--TyruAfY.js";
+//#region src/adapters/netlify.d.ts
+export declare const handle: FetchAdapter<[context?: unknown]>;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/netlify.js

@@ -0,0 +1,10 @@
+import { n as setRuntime, t as createFetchAdapter } from "../base-B8GEu3z4.js";
+//#region src/adapters/netlify.ts
+const handle = createFetchAdapter((request, context) => {
+	if (context !== void 0) setRuntime(request, {
+		name: "netlify",
+		netlify: { context }
+	});
+});
+//#endregion
+export { handle };

package/dist/adapters/node.d.ts

@@ -1,12 +1,11 @@
-import { t as RhythmHttpContext } from "../context-B0711qPV.js";
+import { t as RhythmHttpContext } from "../context-ChHlG-q0.js";
+import { t as AdapterOptions } from "../base--TyruAfY.js";
+import { NodeHttp1Handler, NodeHttp2Handler } from "srvx";
 import { Rhythm } from "@rhythmjs/rhythm";
-import { IncomingMessage, ServerResponse } from "node:http";
 //#region src/adapters/node.d.ts
-export declare class RhythmBodyTooLargeError extends Error {
-  constructor(limit: number);
+export interface NodeHandlerOptions extends AdapterOptions {
+  maxRequestBodySize?: number;
 }
-export interface RhythmNodeHandlerOptions {
-  bodyLimit?: number | false;
-}
-export declare function toNodeHandler<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: RhythmNodeHandlerOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export type NodeHandler = NodeHttp1Handler & NodeHttp2Handler;
+export declare function getRequestListener<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: NodeHandlerOptions): NodeHandler;
 //#endregion

package/dist/adapters/node.js

@@ -1,135 +1,9 @@
-import { createHttpContext, toResponse } from "./context.js";
-import { Readable } from "node:stream";
-import { Buffer } from "node:buffer";
+import { t as createFetchAdapter } from "../base-B8GEu3z4.js";
+import { toNodeHandler } from "srvx/node";
 //#region src/adapters/node.ts
-const DEFAULT_BODY_LIMIT = 1048576;
-var RhythmBodyTooLargeError = class extends Error {
-	constructor(limit) {
-		super(`request body exceeds the ${limit} byte limit`);
-		this.name = "RhythmBodyTooLargeError";
-	}
-};
-function readRawBody(req, limit) {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		let received = 0;
-		let tooLarge = false;
-		let settled = false;
-		req.on("data", (chunk) => {
-			received += chunk.length;
-			if (received > limit) {
-				if (!tooLarge) {
-					tooLarge = true;
-					settled = true;
-					reject(new RhythmBodyTooLargeError(limit));
-				}
-				return;
-			}
-			chunks.push(chunk);
-		});
-		req.on("end", () => {
-			if (settled) return;
-			settled = true;
-			resolve(Buffer.concat(chunks));
-		});
-		req.on("error", (err) => {
-			if (settled) return;
-			settled = true;
-			reject(err);
-		});
-		req.on("aborted", () => {
-			if (settled) return;
-			settled = true;
-			reject(/* @__PURE__ */ new Error("request aborted"));
-		});
-	});
-}
-async function toWebRequest(req, bodyLimit) {
-	const method = req.method ?? "GET";
-	const url = `http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`;
-	const headers = [];
-	for (const key in req.headers) {
-		const value = req.headers[key];
-		if (value === void 0) continue;
-		if (Array.isArray(value)) for (const entry of value) headers.push([key, entry]);
-		else headers.push([key, value]);
-	}
-	if (!(method !== "GET" && method !== "HEAD")) return new Request(url, {
-		method,
-		headers
-	});
-	if (bodyLimit === false) return new Request(url, {
-		method,
-		headers,
-		body: Readable.toWeb(req),
-		duplex: "half"
-	});
-	const body = await readRawBody(req, bodyLimit);
-	return new Request(url, {
-		method,
-		headers,
-		body
-	});
-}
-function toNodeHeaders(headers) {
-	const result = {};
-	const setCookie = typeof headers.getSetCookie === "function" ? headers.getSetCookie() : [];
-	if (setCookie.length > 0) result["set-cookie"] = setCookie;
-	for (const [key, value] of headers) {
-		if (key === "set-cookie") continue;
-		result[key] = value;
-	}
-	return result;
-}
-async function writeWebResponse(response, res) {
-	res.writeHead(response.status, toNodeHeaders(response.headers));
-	if (!response.body) {
-		res.end();
-		return;
-	}
-	await new Promise((resolve, reject) => {
-		const nodeStream = Readable.fromWeb(response.body);
-		nodeStream.on("error", reject);
-		res.on("finish", resolve);
-		nodeStream.pipe(res);
-	});
-}
-function writeDirectResponse(response, res) {
-	const { body, status } = response;
-	const headers = toNodeHeaders(response.headers);
-	let payload;
-	if (typeof body === "string") payload = body;
-	else if (body instanceof Uint8Array) payload = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-	else if (body instanceof ArrayBuffer) payload = Buffer.from(body);
-	if (!("content-length" in headers) && status !== 204 && status !== 304) headers["content-length"] = payload === void 0 ? "0" : String(typeof payload === "string" ? Buffer.byteLength(payload) : payload.byteLength);
-	if (response.statusText !== void 0) res.writeHead(status, response.statusText, headers);
-	else res.writeHead(status, headers);
-	res.end(payload);
-}
-function hasDirectBody(body) {
-	return body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof ArrayBuffer;
-}
-function toNodeHandler(app, options = {}) {
-	const run = app.callback();
-	const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT;
-	return async (req, res) => {
-		try {
-			const request = await toWebRequest(req, bodyLimit);
-			const ctx = await run(createHttpContext(request));
-			if (hasDirectBody(ctx.response.body)) writeDirectResponse(ctx.response, res);
-			else await writeWebResponse(toResponse(ctx.response), res);
-		} catch (err) {
-			if (!(err instanceof RhythmBodyTooLargeError)) console.error(err);
-			if (!res.headersSent) {
-				const status = err instanceof RhythmBodyTooLargeError ? 413 : 500;
-				const message = err instanceof RhythmBodyTooLargeError ? err.message : "Internal Server Error";
-				const headers = { "content-type": "text/plain; charset=utf-8" };
-				if (err instanceof RhythmBodyTooLargeError) headers.connection = "close";
-				res.writeHead(status, headers);
-				res.end(message);
-			} else res.destroy(err instanceof Error ? err : new Error(String(err)));
-		}
-	};
+const fetchHandle = createFetchAdapter();
+function getRequestListener(app, options = {}) {
+	return toNodeHandler(fetchHandle(app, options), options);
 }
 //#endregion
-export { RhythmBodyTooLargeError, toNodeHandler };
+export { getRequestListener };

package/dist/adapters/service-worker.d.ts

@@ -0,0 +1,11 @@
+import { t as RhythmHttpContext } from "../context-ChHlG-q0.js";
+import { t as AdapterOptions } from "../base--TyruAfY.js";
+import { Rhythm } from "@rhythmjs/rhythm";
+//#region src/adapters/service-worker.d.ts
+interface FetchEventLike {
+  readonly request: Request;
+  respondWith(response: Response | Promise<Response>): void;
+}
+export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: AdapterOptions): (event: FetchEventLike) => void;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/service-worker.js

@@ -0,0 +1,11 @@
+import { t as createFetchAdapter } from "../base-B8GEu3z4.js";
+//#region src/adapters/service-worker.ts
+const fetchHandle = createFetchAdapter();
+function handle(app, options = {}) {
+	const handler = fetchHandle(app, options);
+	return (event) => {
+		event.respondWith(handler(event.request));
+	};
+}
+//#endregion
+export { handle };

package/dist/adapters/vercel.d.ts

@@ -0,0 +1,5 @@
+import { n as FetchAdapter, t as AdapterOptions } from "../base--TyruAfY.js";
+//#region src/adapters/vercel.d.ts
+export declare const handle: FetchAdapter;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/vercel.js

@@ -0,0 +1,5 @@
+import { t as createFetchAdapter } from "../base-B8GEu3z4.js";
+//#region src/adapters/vercel.ts
+const handle = createFetchAdapter();
+//#endregion
+export { handle };

package/dist/base--TyruAfY.d.ts

@@ -0,0 +1,10 @@
+import { t as RhythmHttpContext } from "./context-ChHlG-q0.js";
+import { ErrorHandler, ServerRuntimeContext } from "srvx";
+import { Rhythm } from "@rhythmjs/rhythm";
+//#region src/adapters/base.d.ts
+interface AdapterOptions {
+  onError?: ErrorHandler;
+}
+type FetchAdapter<TExtra extends unknown[] = []> = <TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: AdapterOptions) => (request: Request, ...extra: TExtra) => Promise<Response>;
+//#endregion
+export { FetchAdapter as n, AdapterOptions as t };

package/dist/base-B8GEu3z4.js

@@ -0,0 +1,25 @@
+import { toFetchHandler } from "./fetch.js";
+import { errorToResponse } from "./serve.js";
+//#region src/adapters/base.ts
+function setRuntime(request, runtime) {
+	Object.defineProperty(request, "runtime", {
+		value: runtime,
+		configurable: true
+	});
+}
+function createFetchAdapter(enrich) {
+	return (app, options = {}) => {
+		const handler = toFetchHandler(app);
+		const onError = options.onError ?? errorToResponse;
+		return async (request, ...extra) => {
+			try {
+				enrich?.(request, ...extra);
+				return await handler(request);
+			} catch (error) {
+				return onError(error);
+			}
+		};
+	};
+}
+//#endregion
+export { setRuntime as n, createFetchAdapter as t };

package/dist/{context-B0711qPV.d.ts → context-ChHlG-q0.d.ts}

@@ -1,4 +1,7 @@
-//#region src/adapters/context.d.ts
+import { ServerRuntimeContext } from "srvx";
+//#region src/context.d.ts
+type RhythmRuntime = ServerRuntimeContext;
+declare function getRuntime(request: Request): RhythmRuntime | undefined;
 type RhythmResponseBody = string | ArrayBuffer | Uint8Array | Blob | FormData | URLSearchParams | ReadableStream<Uint8Array> | null;
 declare class RhythmResponse {
   status: number;
@@ -18,4 +21,4 @@ interface RhythmHttpContext {
 declare function createHttpContext(request: Request): RhythmHttpContext;
 declare function toResponse(response: RhythmResponse): Response;
 //#endregion
-export { toResponse as a, createHttpContext as i, RhythmResponse as n, RhythmResponseBody as r, RhythmHttpContext as t };
+export { createHttpContext as a, RhythmRuntime as i, RhythmResponse as n, getRuntime as o, RhythmResponseBody as r, toResponse as s, RhythmHttpContext as t };

package/dist/context.d.ts

@@ -0,0 +1,2 @@
+import { a as createHttpContext, i as RhythmRuntime, n as RhythmResponse, o as getRuntime, r as RhythmResponseBody, s as toResponse, t as RhythmHttpContext } from "./context-ChHlG-q0.js";
+export { RhythmHttpContext, RhythmResponse, RhythmResponseBody, RhythmRuntime, createHttpContext, getRuntime, toResponse };

package/dist/{adapters/context.js → context.js}

@@ -1,4 +1,7 @@
-//#region src/adapters/context.ts
+//#region src/context.ts
+function getRuntime(request) {
+	return request.runtime;
+}
 var RhythmResponse = class {
 	status = 200;
 	statusText = void 0;
@@ -63,4 +66,4 @@ function toResponse(response) {
 	});
 }
 //#endregion
-export { RhythmResponse, createHttpContext, toResponse };
+export { RhythmResponse, createHttpContext, getRuntime, toResponse };

package/dist/{adapters/web-std.d.ts → fetch.d.ts}

@@ -1,5 +1,5 @@
-import { t as RhythmHttpContext } from "../context-B0711qPV.js";
+import { t as RhythmHttpContext } from "./context-ChHlG-q0.js";
 import { Rhythm } from "@rhythmjs/rhythm";
-//#region src/adapters/web-std.d.ts
+//#region src/fetch.d.ts
 export declare function toFetchHandler<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request) => Promise<Response>;
 //#endregion

package/dist/fetch.js

@@ -0,0 +1,16 @@
+import { createHttpContext } from "./context.js";
+import { FastResponse } from "srvx";
+//#region src/fetch.ts
+function toFetchHandler(app) {
+	const run = app.callback();
+	return async (request) => {
+		const response = (await run(createHttpContext(request))).response;
+		return new FastResponse(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+	};
+}
+//#endregion
+export { toFetchHandler };

package/dist/rhythm-router.d.ts

@@ -1,4 +1,4 @@
-import { t as RhythmHttpContext } from "./context-B0711qPV.js";
+import { t as RhythmHttpContext } from "./context-ChHlG-q0.js";
 import { DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
 //#region src/rhythm-router.d.ts
 export interface RhythmRouterContext {

package/dist/serve.d.ts

@@ -0,0 +1,9 @@
+import { t as RhythmHttpContext } from "./context-ChHlG-q0.js";
+import { ErrorHandler, Server, ServerMiddleware, ServerOptions, ServerPlugin } from "srvx";
+import { Rhythm } from "@rhythmjs/rhythm";
+//#region src/serve.d.ts
+export type RhythmServeOptions = Omit<ServerOptions, "fetch">;
+export declare const errorToResponse: ErrorHandler;
+export declare function serve<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: RhythmServeOptions): Server;
+//#endregion
+export type { ErrorHandler, Server, ServerMiddleware, ServerPlugin };

package/dist/serve.js

@@ -0,0 +1,21 @@
+import { toFetchHandler } from "./fetch.js";
+import { serve as serve$1 } from "srvx";
+//#region src/serve.ts
+const errorToResponse = (error) => {
+	const status = error.status ?? error.statusCode ?? 500;
+	const message = status >= 500 ? "Internal Server Error" : error instanceof Error ? error.message : String(error);
+	if (status >= 500) console.error(error);
+	return new Response(message, {
+		status,
+		headers: { "content-type": "text/plain; charset=utf-8" }
+	});
+};
+function serve(app, options = {}) {
+	return serve$1({
+		error: errorToResponse,
+		...options,
+		fetch: toFetchHandler(app)
+	});
+}
+//#endregion
+export { errorToResponse, serve };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Radix-tree HTTP router for the Rhythm middleware kernel, with Bun, Node, and Deno adapters.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
@@ -23,9 +23,21 @@
       "types": "./dist/radix-tree.d.ts",
       "default": "./dist/radix-tree.js"
     },
-    "./adapters/web-std": {
-      "types": "./dist/adapters/web-std.d.ts",
-      "default": "./dist/adapters/web-std.js"
+    "./context": {
+      "types": "./dist/context.d.ts",
+      "default": "./dist/context.js"
+    },
+    "./fetch": {
+      "types": "./dist/fetch.d.ts",
+      "default": "./dist/fetch.js"
+    },
+    "./serve": {
+      "types": "./dist/serve.d.ts",
+      "default": "./dist/serve.js"
+    },
+    "./adapters/node": {
+      "types": "./dist/adapters/node.d.ts",
+      "default": "./dist/adapters/node.js"
     },
     "./adapters/bun": {
       "types": "./dist/adapters/bun.d.ts",
@@ -35,13 +47,29 @@
       "types": "./dist/adapters/deno.d.ts",
       "default": "./dist/adapters/deno.js"
     },
-    "./adapters/node": {
-      "types": "./dist/adapters/node.d.ts",
-      "default": "./dist/adapters/node.js"
+    "./adapters/vercel": {
+      "types": "./dist/adapters/vercel.d.ts",
+      "default": "./dist/adapters/vercel.js"
+    },
+    "./adapters/netlify": {
+      "types": "./dist/adapters/netlify.d.ts",
+      "default": "./dist/adapters/netlify.js"
+    },
+    "./adapters/cloudflare": {
+      "types": "./dist/adapters/cloudflare.d.ts",
+      "default": "./dist/adapters/cloudflare.js"
+    },
+    "./adapters/aws-lambda": {
+      "types": "./dist/adapters/aws-lambda.d.ts",
+      "default": "./dist/adapters/aws-lambda.js"
+    },
+    "./adapters/service-worker": {
+      "types": "./dist/adapters/service-worker.d.ts",
+      "default": "./dist/adapters/service-worker.js"
     },
     "./adapters/context": {
-      "types": "./dist/adapters/context.d.ts",
-      "default": "./dist/adapters/context.js"
+      "types": "./dist/context.d.ts",
+      "default": "./dist/context.js"
     },
     "./package.json": "./package.json"
   },
@@ -49,7 +77,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@rhythmjs/rhythm": "0.0.7"
+    "srvx": "^1.0.5",
+    "@rhythmjs/rhythm": "0.0.9"
   },
   "devDependencies": {
     "@types/node": "^26.6.3",

package/dist/adapters/context.d.ts

@@ -1,2 +0,0 @@
-import { a as toResponse, i as createHttpContext, n as RhythmResponse, r as RhythmResponseBody, t as RhythmHttpContext } from "../context-B0711qPV.js";
-export { RhythmHttpContext, RhythmResponse, RhythmResponseBody, createHttpContext, toResponse };

package/dist/adapters/web-std.js

@@ -1,11 +0,0 @@
-import { createHttpContext, toResponse } from "./context.js";
-//#region src/adapters/web-std.ts
-function toFetchHandler(app) {
-	const run = app.callback();
-	return async (request) => {
-		const ctx = await run(createHttpContext(request));
-		return toResponse(ctx.response);
-	};
-}
-//#endregion
-export { toFetchHandler };