@rhythmjs/router 0.0.10 → 0.0.12

package/README.md

@@ -1,17 +1,17 @@
 # @rhythmjs/router
 
-Web-standard HTTP routing on top of `@rhythmjs/rhythm`. `RhythmRouter` matches routes with [rou3](https://github.com/h3js/rou3), the router that powers h3 (a static segment always wins over a `:param` segment, regardless of registration order), supports prefixes and nested routers, and mounts flat into a parent `Rhythm` app via `.use(router.middleware())`, so an unmatched request correctly falls through to whatever's registered after it.
+The HTTP layer of Rhythm, the Bun-native backend framework: web-standard (`Request`/`Response`) routing on top of the `@rhythmjs/rhythm` kernel, served on `Bun.serve`. `RhythmRouter` matches routes with [rou3](https://github.com/h3js/rou3), the router that powers h3 (a static segment always wins over a `:param` segment, regardless of registration order), supports prefixes and nested routers, and mounts flat into a parent `Rhythm` app via `.use(router.middleware())`, so an unmatched request correctly falls through to whatever's registered after it.
 
 Route patterns follow rou3's conventions: `:name` params (`:name?` optional, `:id(\\d+)` regex-constrained), `*` for one unnamed segment (captured as `params["0"]`), and `**` for the rest of the path (`params._`, or `params.name` with `**:name`). Param values are the raw path segments, undecoded.
 
-`RhythmRouter` is not an app and does not extend `Rhythm` — it is a controller that compiles routes and middleware down to a single middleware (`.middleware()`). It shares the core middleware contract (`compose`, `Middleware`, `next(extra)`), but has no `provide()` or `register()`, and it can't be served on its own: a `Rhythm` app is always the host that owns the lifecycle and the adapters.
+`RhythmRouter` is not an app and does not extend `Rhythm`; it is a controller that compiles routes and middleware down to a single middleware (`.middleware()`). It shares the core middleware contract (`compose`, `Middleware`, `next(extra)`), but has no `provide()` or `register()`, and it can't be served on its own: a `Rhythm` app is always the host that owns the lifecycle and the adapters.
 
 ## Example
 
 ```ts
 import { Rhythm } from "@rhythmjs/rhythm";
 import { RhythmRouter } from "@rhythmjs/router";
-import { serve } from "@rhythmjs/router/serve";
+import { toFetchHandler } from "@rhythmjs/router/fetch";
 import type { RhythmHttpContext } from "@rhythmjs/router/context";
 
 const usersRouter = new RhythmRouter({ prefix: "/users" }).get("/:id", (ctx) => {
@@ -19,140 +19,80 @@ const usersRouter = new RhythmRouter({ prefix: "/users" }).get("/:id", (ctx) =>
 });
 
 const app = new Rhythm<RhythmHttpContext>().use(usersRouter.middleware());
-serve(app, { port: 3000 });
+Bun.serve({ port: 3000, fetch: toFetchHandler(app) });
 ```
 
 A fuller runnable version, including nested prefixes and a fallback route, is at [`examples/router`](../../examples/router).
 
 ## Concepts
 
-- **`ctx.response`** is a plain mutable object (`status`, `statusText`, `headers`, `body`) — set it directly rather than constructing a `Response` yourself. The adapter converts it to a real `Response` at the end.
-- **Response helpers** — `ctx.json(data, status?)`, `ctx.text(body, status?)`, `ctx.html(body, status?)`, `ctx.error(status, message?)`, and `ctx.redirect(url, status = 302)` set the content type, body, and status on `ctx.response` in one call. `error()` defaults the message from the status code (`ctx.error(404)` → `"Not Found"`). They're sugar over `ctx.response`, so mixing both styles is fine, and later writes win.
-- **`ctx.params`** — captured `:name` path segments, added once a route matches.
-- **Nesting is `.use(child.middleware())`** — a router mounts into another router (or into the app) as a compiled middleware. The mount is opaque, so the parent's prefix is **not** applied to the child's routes: the child carries its own absolute prefix (`new RhythmRouter({ prefix: "/api/users" })`). On a miss the child falls through to `next()`, so the parent's later middleware and routes still run, and the child keeps working standalone.
-- **Registration order is execution order** — a `.use()` middleware wraps only the routes registered after it; routes registered before it are untouched, and a matched route that doesn't call `next()` returns without reaching anything registered later. Consecutive routes share one rou3 lookup; an unmatched request falls through, entry by entry, to the outer `next()`.
-- **A router is a controller, not a module** — it has no `provide()` or `register()`, and it cannot be `register()`ed into a `Rhythm` app either; `register()` composes `Rhythm` modules only. A router mounts into an app exactly one way: koa-style, via `.use(router.middleware())`.
+- **`ctx.response`** is a plain mutable object (`status`, `statusText`, `headers`, `body`): set it directly rather than constructing a `Response` yourself. The adapter converts it to a real `Response` at the end.
+- **Response helpers**: `ctx.json(data, status?)`, `ctx.text(body, status?)`, `ctx.html(body, status?)`, `ctx.error(status, message?)`, and `ctx.redirect(url, status = 302)` set the content type, body, and status on `ctx.response` in one call. `error()` defaults the message from the status code (`ctx.error(404)` → `"Not Found"`). They're sugar over `ctx.response`, so mixing both styles is fine, and later writes win.
+- **`ctx.params`**: captured `:name` path segments, added once a route matches.
+- **Nesting is `.use(child.middleware())`**: a router mounts into another router (or into the app) as a compiled middleware. The mount is opaque, so the parent's prefix is **not** applied to the child's routes: the child carries its own absolute prefix (`new RhythmRouter({ prefix: "/api/users" })`). On a miss the child falls through to `next()`, so the parent's later middleware and routes still run, and the child keeps working standalone.
+- **Registration order is execution order**: a `.use()` middleware wraps only the routes registered after it; routes registered before it are untouched, and a matched route that doesn't call `next()` returns without reaching anything registered later. Consecutive routes share one rou3 lookup; an unmatched request falls through, entry by entry, to the outer `next()`.
+- **A router is a controller, not a module**: it has no `provide()` or `register()`, and it cannot be `register()`ed into a `Rhythm` app either; `register()` composes `Rhythm` modules only. A router mounts into an app exactly one way: koa-style, via `.use(router.middleware())`.
 
 ## API
 
-- `new RhythmRouter(options?)` — `options.prefix`.
-- `.get/.post/.put/.patch/.delete(path, ...handlers)` — register a route; `path` may contain `:param` segments.
-- `.use(fn)` — plain middleware; it takes only functions, so a nested router mounts as `.use(child.middleware())`.
-- `.middleware()` — this router compiled to a plain middleware: the one form that mounts anywhere, into a `Rhythm` app or into another router. Because the compiled form is opaque, the mounting router's prefix is not applied to it — give the child its full prefix.
-- `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.
+- `new RhythmRouter(options?)`: `options.prefix`.
+- `.get/.post/.put/.patch/.delete(path, ...handlers)`: register a route; `path` may contain `:param` segments.
+- `.use(fn)`: plain middleware; it takes only functions, so a nested router mounts as `.use(child.middleware())`.
+- `.middleware()`: this router compiled to a plain middleware: the one form that mounts anywhere, into a `Rhythm` app or into another router. Because the compiled form is opaque, the mounting router's prefix is not applied to it, so give the child its full prefix.
+- `ctx.json/.text/.html(body, status?)`, `ctx.error(status, message?)`, `ctx.redirect(url, status?)`: response helpers built into the context (`createHttpContext` in `@rhythmjs/router/context`).
+- `toFetchHandler(app)`: bridges a `Rhythm` app to a Web-standard `(Request) => Promise<Response>` handler.
 
-## Serving
+## Serving: your Bun.serve, no wrapper
 
-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):
+There is no `serve()` helper and no static-file helper. You write `Bun.serve` in your own `main.ts`, and the package gives you exactly two plain pieces for its `fetch`:
 
-- **`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.
+- **`toFetchHandler(app)`** (`@rhythmjs/router/fetch`): the app as a `(Request) => Promise<Response>` handler.
+- **`errorToResponse(error)`** (`@rhythmjs/router/fetch`): maps a thrown error to a Response: the error's own `status`/`statusCode` when set, else a logged `500`.
 
-`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`.
-
-Fetch-shaped adapters also accept `{ websocket }` — anything with a `handleUpgrade(request, ...extra)` method, such as a [crossws](https://crossws.h3.dev) instance or an `@rhythmjs/ws` adapter. Requests carrying an `upgrade: websocket` header divert to it (with the runtime's extra arguments — Bun's `server`, Deno's `info`, Cloudflare's `env`/`ctx` — forwarded) before the app runs; every other request is untouched.
-
-**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`:
+Everything wired, explicitly:
 
 ```ts
-import { handle } from "@rhythmjs/router/adapters/cloudflare";
-
-export default { fetch: handle(app) };
+import { toFetchHandler, errorToResponse } from "@rhythmjs/router/fetch";
+
+const handler = toFetchHandler(app);
+
+const server = Bun.serve({
+  port: 3000,
+  async fetch(request, srv) {
+    // Optional: expose the client address as request.ip, the field
+    // @rhythmjs/security's rate limit and @rhythmjs/http's proxy key off.
+    Object.defineProperty(request, "ip", {
+      configurable: true,
+      get: () => srv.requestIP(request)?.address,
+    });
+    try {
+      return await handler(request);
+    } catch (error) {
+      return errorToResponse(error);
+    }
+  },
+});
 ```
 
-**AWS Lambda** — API Gateway v1/v2 events, translated by srvx:
+Since `Bun.serve` is yours, all of Bun's server options (`port`, `hostname`, `unix`, `tls`, `idleTimeout`, `maxRequestBodySize`, `reusePort`, `development`, …) and the `Server` itself (`server.url`, `server.publish`, `server.stop()`) are used directly; nothing is proxied or renamed.
 
-```ts
-import { handle } from "@rhythmjs/router/adapters/aws-lambda";
-
-export const lambda = handle(app);
-```
+### Static files
 
-**Netlify Edge Functions** — the Netlify context is exposed as `ctx.request.runtime.netlify`:
+Use Bun's built-in `routes`; there is nothing to import:
 
 ```ts
-import { handle } from "@rhythmjs/router/adapters/netlify";
-
-export default handle(app);
-export const config = { path: "/*" };
+const server = Bun.serve({
+  routes: {
+    "/": new Response(Bun.file("public/index.html")), // one known file
+    "/static/*": { dir: "./public" }, // a whole folder
+  },
+  fetch: toFetchHandler(app), // everything else is the app
+});
 ```
 
-**Service workers**
+Directory routes (`{ dir }`, path must end in `/*`) come with content types, `Last-Modified` + weak `ETag` with `304` revalidation, `Range` requests, `index.html` for trailing-slash requests (and a `301` to add the slash), and `404` for missing or non-canonical (traversal) paths.
 
-```ts
-import { handle } from "@rhythmjs/router/adapters/service-worker";
-
-addEventListener("fetch", handle(app));
-```
+> **Warning: never mount a directory at `"/*"`.** A directory route answers its own `404`s: with `"/*": { dir }`, every URL that isn't a file dies there and your app's `fetch` never runs. Keep folders on dedicated prefixes (`/static/*`, `/assets/*`) and let `fetch` stay the app's. For root-level files (favicon, robots.txt), map each one explicitly: `"/favicon.svg": new Response(Bun.file("public/favicon.svg"))`.
+### WebSockets
 
-Any other fetch-based runtime works with the raw primitive: `toFetchHandler(app)` from `@rhythmjs/router/fetch`.
+[`@rhythmjs/ws`](https://github.com/rhythmjs/ws) plugs into the same hand-wired `fetch`: its `upgrade()` returns `null` synchronously for non-websocket requests, so it composes as `ws.upgrade(request, srv) ?? handler(request)`, with `websocket: ws.websocket` on the same `Bun.serve` call.

package/dist/context.d.ts

@@ -1,2 +1,18 @@
-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 };
+export type RhythmResponseBody = string | ArrayBuffer | Uint8Array | Blob | FormData | URLSearchParams | ReadableStream<Uint8Array> | null;
+export declare class RhythmResponse {
+    status: number;
+    statusText: string | undefined;
+    headers: Headers;
+    body: RhythmResponseBody;
+}
+export interface RhythmHttpContext {
+    readonly request: Request;
+    readonly response: RhythmResponse;
+    json(data: unknown, status?: number): void;
+    text(body: string, status?: number): void;
+    html(body: string, status?: number): void;
+    error(status: number, message?: string): void;
+    redirect(url: string, status?: number): void;
+}
+export declare function createHttpContext(request: Request): RhythmHttpContext;
+export declare function toResponse(response: RhythmResponse): Response;

package/dist/context.js

@@ -1,69 +1,11 @@
-//#region src/context.ts
-function getRuntime(request) {
-	return request.runtime;
-}
-var RhythmResponse = class {
-	status = 200;
-	statusText = void 0;
-	headers = new Headers();
-	body = null;
+// @bun
+import {
+  RhythmResponse2,
+  createHttpContext2,
+  toResponse2
+} from "./rhythm-router-yj4ffyyg.js";
+export {
+  RhythmResponse2 as RhythmResponse,
+  createHttpContext2 as createHttpContext,
+  toResponse2 as toResponse
 };
-const STATUS_TEXT = {
-	400: "Bad Request",
-	401: "Unauthorized",
-	403: "Forbidden",
-	404: "Not Found",
-	405: "Method Not Allowed",
-	409: "Conflict",
-	410: "Gone",
-	413: "Payload Too Large",
-	415: "Unsupported Media Type",
-	422: "Unprocessable Entity",
-	429: "Too Many Requests",
-	500: "Internal Server Error",
-	501: "Not Implemented",
-	502: "Bad Gateway",
-	503: "Service Unavailable",
-	504: "Gateway Timeout"
-};
-function createHttpContext(request) {
-	const response = new RhythmResponse();
-	return {
-		request,
-		response,
-		json(data, status) {
-			if (status !== void 0) response.status = status;
-			response.headers.set("content-type", "application/json; charset=utf-8");
-			response.body = JSON.stringify(data);
-		},
-		text(body, status) {
-			if (status !== void 0) response.status = status;
-			response.headers.set("content-type", "text/plain; charset=utf-8");
-			response.body = body;
-		},
-		html(body, status) {
-			if (status !== void 0) response.status = status;
-			response.headers.set("content-type", "text/html; charset=utf-8");
-			response.body = body;
-		},
-		error(status, message) {
-			response.status = status;
-			response.headers.set("content-type", "text/plain; charset=utf-8");
-			response.body = message ?? STATUS_TEXT[status] ?? `Error ${status}`;
-		},
-		redirect(url, status = 302) {
-			response.status = status;
-			response.headers.set("location", url);
-			response.body = null;
-		}
-	};
-}
-function toResponse(response) {
-	return new Response(response.body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers: response.headers
-	});
-}
-//#endregion
-export { RhythmResponse, createHttpContext, getRuntime, toResponse };

package/dist/fetch.d.ts

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

package/dist/fetch.js

@@ -1,16 +1,32 @@
-import { createHttpContext } from "./context.js";
-import { FastResponse } from "srvx";
-//#region src/fetch.ts
+// @bun
+import {
+  createHttpContext2
+} from "./rhythm-router-yj4ffyyg.js";
+
+// 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
-		});
-	};
+  const run = app.callback();
+  return async (request) => {
+    const ctx = await run(createHttpContext2(request));
+    const response = ctx.response;
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
 }
-//#endregion
-export { toFetchHandler };
+function 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" }
+  });
+}
+export {
+  errorToResponse,
+  toFetchHandler
+};

package/dist/rhythm-router-88dtq5mx.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  createHttpContext2
+} from "./rhythm-router-yj4ffyyg.js";
+
+// src/fetch.ts
+function toFetchHandler2(app) {
+  const run = app.callback();
+  return async (request) => {
+    const ctx = await run(createHttpContext2(request));
+    const response = ctx.response;
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+}
+
+export { toFetchHandler2 };

package/dist/rhythm-router-n08cmxbj.js

@@ -0,0 +1,53 @@
+// @bun
+// src/static.ts
+import { join, normalize, sep } from "path";
+function normalizePrefix(prefix) {
+  const withLeading = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  return withLeading.endsWith("/") ? withLeading.slice(0, -1) : withLeading;
+}
+function staticMiddleware2(options) {
+  const prefix = normalizePrefix(options.prefix ?? "/");
+  const index = options.index ?? "index.html";
+  const useEtag = options.etag ?? true;
+  const cacheControl = options.maxAge === undefined ? undefined : `max-age=${options.maxAge}${options.immutable ? ", immutable" : ""}`;
+  return async (request, next) => {
+    if (request.method !== "GET" && request.method !== "HEAD")
+      return next();
+    let pathname;
+    try {
+      pathname = decodeURIComponent(new URL(request.url).pathname);
+    } catch {
+      return next();
+    }
+    if (prefix !== "" && pathname !== prefix && !pathname.startsWith(`${prefix}/`))
+      return next();
+    const relative = normalize(pathname.slice(prefix.length));
+    if (relative.includes("\x00") || relative === ".." || relative.startsWith(`..${sep}`))
+      return next();
+    const base = join(options.dir, relative);
+    const candidates = pathname.endsWith("/") ? [join(base, index)] : [base, join(base, index)];
+    let file;
+    for (const candidate of candidates) {
+      const found = Bun.file(candidate);
+      if (await found.exists()) {
+        file = found;
+        break;
+      }
+    }
+    if (file === undefined)
+      return next();
+    const headers = new Headers;
+    if (cacheControl !== undefined)
+      headers.set("cache-control", cacheControl);
+    if (useEtag) {
+      const etag = `"${file.size.toString(16)}-${Math.floor(file.lastModified).toString(16)}"`;
+      headers.set("etag", etag);
+      if (request.headers.get("if-none-match") === etag) {
+        return new Response(null, { status: 304, headers });
+      }
+    }
+    return new Response(file, { headers });
+  };
+}
+
+export { staticMiddleware2 };

package/dist/rhythm-router-yj4ffyyg.js

@@ -0,0 +1,70 @@
+// @bun
+// src/context.ts
+class RhythmResponse2 {
+  status = 200;
+  statusText = undefined;
+  headers = new Headers;
+  body = null;
+}
+var STATUS_TEXT = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  410: "Gone",
+  413: "Payload Too Large",
+  415: "Unsupported Media Type",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+function createHttpContext2(request) {
+  const response = new RhythmResponse2;
+  return {
+    request,
+    response,
+    json(data, status) {
+      if (status !== undefined)
+        response.status = status;
+      response.headers.set("content-type", "application/json; charset=utf-8");
+      response.body = JSON.stringify(data);
+    },
+    text(body, status) {
+      if (status !== undefined)
+        response.status = status;
+      response.headers.set("content-type", "text/plain; charset=utf-8");
+      response.body = body;
+    },
+    html(body, status) {
+      if (status !== undefined)
+        response.status = status;
+      response.headers.set("content-type", "text/html; charset=utf-8");
+      response.body = body;
+    },
+    error(status, message) {
+      response.status = status;
+      response.headers.set("content-type", "text/plain; charset=utf-8");
+      response.body = message ?? STATUS_TEXT[status] ?? `Error ${status}`;
+    },
+    redirect(url, status = 302) {
+      response.status = status;
+      response.headers.set("location", url);
+      response.body = null;
+    }
+  };
+}
+function toResponse2(response) {
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+
+export { RhythmResponse2, createHttpContext2, toResponse2 };

package/dist/rhythm-router.d.ts

@@ -1,40 +1,39 @@
-import { t as RhythmHttpContext } from "./context-ChHlG-q0.js";
-import { DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
-//#region src/rhythm-router.d.ts
+import type { DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
+import type { RhythmHttpContext } from "./context";
 export interface RhythmRouterContext {
-  readonly params: Readonly<Record<string, string>>;
+    readonly params: Readonly<Record<string, string>>;
 }
 export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 export interface RhythmRouterOptions {
-  prefix?: string;
+    prefix?: string;
 }
 export type RouterEntry = {
-  readonly kind: "middleware";
-  readonly fn: Middleware<any>;
+    readonly kind: "middleware";
+    readonly fn: Middleware<any>;
 } | {
-  readonly kind: "route";
-  readonly method: HttpMethod;
-  readonly path: string;
-  readonly handlers: readonly Middleware<any>[];
+    readonly kind: "route";
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly handlers: readonly Middleware<any>[];
 };
 type RouteHandler<TContext> = Middleware<TContext & RhythmRouterContext>;
 export declare function joinPath(prefix: string, path: string): string;
 export declare class RhythmRouter<TContext extends RhythmHttpContext = RhythmHttpContext> {
-  #private;
-  constructor(options?: RhythmRouterOptions);
-  get entries(): readonly RouterEntry[];
-  use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): RhythmRouter<TContext & TExtra>;
-  use(fn: Middleware<TContext>): this;
-  get<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
-  get(path: string, ...handlers: RouteHandler<TContext>[]): this;
-  post<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
-  post(path: string, ...handlers: RouteHandler<TContext>[]): this;
-  put<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
-  put(path: string, ...handlers: RouteHandler<TContext>[]): this;
-  patch<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
-  patch(path: string, ...handlers: RouteHandler<TContext>[]): this;
-  delete<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
-  delete(path: string, ...handlers: RouteHandler<TContext>[]): this;
-  middleware(): Middleware<TContext>;
+    #private;
+    constructor(options?: RhythmRouterOptions);
+    get entries(): readonly RouterEntry[];
+    use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): RhythmRouter<TContext & TExtra>;
+    use(fn: Middleware<TContext>): this;
+    get<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
+    get(path: string, ...handlers: RouteHandler<TContext>[]): this;
+    post<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
+    post(path: string, ...handlers: RouteHandler<TContext>[]): this;
+    put<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
+    put(path: string, ...handlers: RouteHandler<TContext>[]): this;
+    patch<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
+    patch(path: string, ...handlers: RouteHandler<TContext>[]): this;
+    delete<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;
+    delete(path: string, ...handlers: RouteHandler<TContext>[]): this;
+    middleware(): Middleware<TContext>;
 }
-//#endregion
+export {};