@rhythmjs/router 0.0.10 → 0.0.11

package/README.md

@@ -39,21 +39,34 @@ 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; 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`).
+- `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
 
-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):
+Two primitives turn an app into a server, both coupled to [Bun](https://bun.com) on purpose:
 
-- **`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(app, options)`** (`@rhythmjs/router/serve`) — starts the app on `Bun.serve` and returns Bun's `Server` (`server.port`, `server.url`, `server.publish`, `server.stop()`).
+- **`toFetchHandler(app)`** (`@rhythmjs/router/fetch`) — the raw `(Request) => Promise<Response>` handler, for composing and testing without 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`.
+`serve()` passes the server fields through to `Bun.serve` — `port`, `hostname`, `unix`, `tls`, `reusePort`, `idleTimeout`, `development`, `maxRequestBodySize` (an over-limit body is rejected without crashing) — plus the extension points below. Every request gets a lazy `request.ip` (from `server.requestIP()`), the field `@rhythmjs/security`'s rate limit and `@rhythmjs/http`'s proxy key off. 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`.
+
+### Static assets
+
+The `static` option serves files with `Bun.file` before the app runs; a request no folder answers falls through to your routes. It takes one folder config or an array — folders are probed in order, first match wins:
+
+```ts
+serve(app, {
+  port: 3000,
+  static: [{ dir: "dist/client", maxAge: 31536000, immutable: true }, { dir: "public" }],
+});
+```
+
+Each entry (`StaticMiddlewareOptions`, also exported from `@rhythmjs/router/static`) takes `dir`, `prefix` (mount point, default the site root), `index` (default `index.html`, served for directory paths), `maxAge`/`immutable` cache control, and `ETag` revalidation with `304`s (`etag`, on by default). Content types come from `Bun.file`. Path traversal is normalized away. `middleware` you pass runs before and wraps the static handlers, so CORS or logging cover asset responses too.
 
 ### 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:
+- **`middleware`** — serve middlewares (`(request, next) => Response`) run around the whole app, the natural place for CORS, logging, or auth gates:
 
   ```ts
   serve(app, {
@@ -69,90 +82,14 @@ Everything above (`RhythmRouter`, `ctx.response`, etc.) is runtime-agnostic. Two
   });
   ```
 
-- **`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`):
+- **`upgrade` + `websocket`** — the seams for Bun's native WebSockets, shaped for [`@rhythmjs/ws`](https://github.com/rhythmjs/ws). Requests with an `upgrade: websocket` header divert to `upgrade(request, server)` before the app runs (return a `Response` to reject, or `undefined` after `server.upgrade()`); `websocket` is Bun's behavior object, passed through:
 
   ```ts
-  serve(app, { plugins: [(server) => wireWebSockets(server)] });
+  import { websocket } from "@rhythmjs/ws";
+
+  serve(app, { upgrade: ws.upgrade, websocket: websocket() });
   ```
 
 - **`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`:
-
-```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`.
+Anything else fetch-shaped composes with the raw primitive: `toFetchHandler(app)` from `@rhythmjs/router/fetch`.

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,3 @@
-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

package/dist/fetch.js

@@ -1,16 +1,8 @@
-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 };
+// @bun
+import {
+  toFetchHandler2
+} from "./rhythm-router-88dtq5mx.js";
+import"./rhythm-router-yj4ffyyg.js";
+export {
+  toFetchHandler2 as 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 {};

package/dist/rhythm-router.js

@@ -1,94 +1,92 @@
+// @bun
+// src/rhythm-router.ts
 import { compose } from "@rhythmjs/rhythm/compose";
 import { addRoute, createRouter, findRoute } from "rou3";
-//#region src/rhythm-router.ts
 function joinPath(prefix, path) {
-	if (!prefix) return path;
-	return `${prefix.endsWith("/") ? prefix.slice(0, -1) : prefix}${path.startsWith("/") ? path : `/${path}`}`;
+  if (!prefix)
+    return path;
+  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${trimmedPrefix}${normalizedPath}`;
 }
-var RhythmRouter = class {
-	#options;
-	#entries = [];
-	constructor(options = {}) {
-		this.#options = options;
-	}
-	get #prefix() {
-		return this.#options.prefix ?? "";
-	}
-	get entries() {
-		return [...this.#entries];
-	}
-	use(fn) {
-		if (typeof fn !== "function") throw new TypeError("middleware must be a function!");
-		this.#entries.push({
-			kind: "middleware",
-			fn
-		});
-		return this;
-	}
-	#route(method, path, handlers) {
-		this.#entries.push({
-			kind: "route",
-			method,
-			path: joinPath(this.#prefix, path),
-			handlers
-		});
-		return this;
-	}
-	get(path, ...handlers) {
-		return this.#route("GET", path, handlers);
-	}
-	post(path, ...handlers) {
-		return this.#route("POST", path, handlers);
-	}
-	put(path, ...handlers) {
-		return this.#route("PUT", path, handlers);
-	}
-	patch(path, ...handlers) {
-		return this.#route("PATCH", path, handlers);
-	}
-	delete(path, ...handlers) {
-		return this.#route("DELETE", path, handlers);
-	}
-	#compile() {
-		const dispatchFor = (tree) => {
-			return async (ctx, next) => {
-				const match = findRoute(tree, ctx.request.method, new URL(ctx.request.url).pathname);
-				if (!match) {
-					await next();
-					return;
-				}
-				await match.data({
-					...ctx,
-					params: match.params ?? {}
-				}, next);
-			};
-		};
-		const stack = [];
-		let i = 0;
-		while (i < this.#entries.length) {
-			const entry = this.#entries[i];
-			if (entry.kind === "middleware") {
-				stack.push(entry.fn);
-				i++;
-				continue;
-			}
-			const tree = createRouter();
-			while (i < this.#entries.length) {
-				const route = this.#entries[i];
-				if (route.kind !== "route") break;
-				addRoute(tree, route.method, route.path, compose(route.handlers));
-				i++;
-			}
-			stack.push(dispatchFor(tree));
-		}
-		return compose(stack);
-	}
-	middleware() {
-		const fn = this.#compile();
-		return async (ctx, next) => {
-			await fn(ctx, next);
-		};
-	}
+
+class RhythmRouter {
+  #options;
+  #entries = [];
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  get #prefix() {
+    return this.#options.prefix ?? "";
+  }
+  get entries() {
+    return [...this.#entries];
+  }
+  use(fn) {
+    if (typeof fn !== "function")
+      throw new TypeError("middleware must be a function!");
+    this.#entries.push({ kind: "middleware", fn });
+    return this;
+  }
+  #route(method, path, handlers) {
+    this.#entries.push({ kind: "route", method, path: joinPath(this.#prefix, path), handlers });
+    return this;
+  }
+  get(path, ...handlers) {
+    return this.#route("GET", path, handlers);
+  }
+  post(path, ...handlers) {
+    return this.#route("POST", path, handlers);
+  }
+  put(path, ...handlers) {
+    return this.#route("PUT", path, handlers);
+  }
+  patch(path, ...handlers) {
+    return this.#route("PATCH", path, handlers);
+  }
+  delete(path, ...handlers) {
+    return this.#route("DELETE", path, handlers);
+  }
+  #compile() {
+    const dispatchFor = (tree) => {
+      return async (ctx, next) => {
+        const match = findRoute(tree, ctx.request.method, new URL(ctx.request.url).pathname);
+        if (!match) {
+          await next();
+          return;
+        }
+        await match.data({ ...ctx, params: match.params ?? {} }, next);
+      };
+    };
+    const stack = [];
+    let i = 0;
+    while (i < this.#entries.length) {
+      const entry = this.#entries[i];
+      if (entry.kind === "middleware") {
+        stack.push(entry.fn);
+        i++;
+        continue;
+      }
+      const tree = createRouter();
+      while (i < this.#entries.length) {
+        const route = this.#entries[i];
+        if (route.kind !== "route")
+          break;
+        addRoute(tree, route.method, route.path, compose(route.handlers));
+        i++;
+      }
+      stack.push(dispatchFor(tree));
+    }
+    return compose(stack);
+  }
+  middleware() {
+    const fn = this.#compile();
+    return async (ctx, next) => {
+      await fn(ctx, next);
+    };
+  }
+}
+export {
+  RhythmRouter,
+  joinPath
 };
-//#endregion
-export { RhythmRouter, joinPath };

package/dist/serve.d.ts

@@ -1,9 +1,31 @@
-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">;
+import type { Rhythm } from "@rhythmjs/rhythm";
+import type { RhythmHttpContext } from "./context";
+import { type StaticMiddlewareOptions } from "./static";
+export type { StaticMiddlewareOptions };
+export type Server = Bun.Server<unknown>;
+export type ErrorHandler = (error: unknown) => Response | Promise<Response>;
+export type ServeMiddleware = (request: Request, next: () => Promise<Response>) => Response | Promise<Response>;
+export type UpgradeHandler = (request: Request, server: Server) => Response | undefined | null | Promise<Response | undefined> | null;
+export interface RhythmServeOptions {
+    port?: number;
+    hostname?: string;
+    unix?: string;
+    reusePort?: boolean;
+    idleTimeout?: number;
+    development?: boolean;
+    maxRequestBodySize?: number;
+    tls?: Bun.TLSOptions;
+    error?: ErrorHandler;
+    middleware?: ServeMiddleware[];
+    static?: StaticMiddlewareOptions | StaticMiddlewareOptions[];
+    /** Bun websocket behavior; pair with `upgrade` to accept connections. */
+    websocket?: Bun.WebSocketHandler<never>;
+    /**
+     * Called for websocket upgrade requests — `RhythmWs.upgrade` fits directly.
+     * A Response rejects, undefined means `server.upgrade()` succeeded, and
+     * null falls through to the HTTP app.
+     */
+    upgrade?: UpgradeHandler;
+}
 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

@@ -1,21 +1,67 @@
-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" }
-	});
+// @bun
+import"./rhythm-router-yj4ffyyg.js";
+import {
+  toFetchHandler2
+} from "./rhythm-router-88dtq5mx.js";
+import {
+  staticMiddleware2
+} from "./rhythm-router-n08cmxbj.js";
+
+// src/serve.ts
+var 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)
-	});
+  const {
+    static: staticOptions,
+    middleware = [],
+    error = errorToResponse,
+    websocket,
+    upgrade,
+    ...bunOptions
+  } = options;
+  const assets = staticOptions === undefined ? [] : [staticOptions].flat().map(staticMiddleware2);
+  const chain = [...middleware, ...assets];
+  const handler = toFetchHandler2(app);
+  const dispatch = (request) => {
+    let index = -1;
+    const next = async (step) => {
+      if (step <= index)
+        throw new Error("next() called multiple times");
+      index = step;
+      return step < chain.length ? chain[step](request, () => next(step + 1)) : handler(request);
+    };
+    return next(0);
+  };
+  return Bun.serve({
+    ...bunOptions,
+    ...websocket === undefined ? {} : { websocket },
+    async fetch(request, server) {
+      try {
+        Object.defineProperty(request, "ip", {
+          configurable: true,
+          get: () => server.requestIP(request)?.address
+        });
+        if (upgrade !== undefined && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+          const result = await upgrade(request, server);
+          if (result !== null)
+            return result;
+        }
+        return await dispatch(request);
+      } catch (thrown) {
+        return error(thrown);
+      }
+    }
+  });
 }
-//#endregion
-export { errorToResponse, serve };
+export {
+  errorToResponse,
+  serve
+};

package/dist/static.d.ts

@@ -0,0 +1,10 @@
+import type { ServeMiddleware } from "./serve";
+export interface StaticMiddlewareOptions {
+    dir: string;
+    prefix?: string;
+    index?: string;
+    maxAge?: number;
+    immutable?: boolean;
+    etag?: boolean;
+}
+export declare function staticMiddleware(options: StaticMiddlewareOptions): ServeMiddleware;

package/dist/static.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  staticMiddleware2
+} from "./rhythm-router-n08cmxbj.js";
+export {
+  staticMiddleware2 as staticMiddleware
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.10",
-  "description": "HTTP router for the Rhythm middleware kernel, matching with rou3, with Bun, Node, and Deno adapters.",
+  "version": "0.0.11",
+  "description": "Bun-native HTTP router for the Rhythm middleware kernel, matching with rou3 and serving with Bun.serve.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
   "repository": {
@@ -31,37 +31,9 @@
       "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",
-      "default": "./dist/adapters/bun.js"
-    },
-    "./adapters/deno": {
-      "types": "./dist/adapters/deno.d.ts",
-      "default": "./dist/adapters/deno.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"
+    "./static": {
+      "types": "./dist/static.d.ts",
+      "default": "./dist/static.js"
     },
     "./adapters/context": {
       "types": "./dist/context.d.ts",
@@ -74,15 +46,19 @@
   },
   "dependencies": {
     "rou3": "^0.11.0",
-    "srvx": "^1.0.5",
-    "@rhythmjs/rhythm": "0.0.10"
+    "@rhythmjs/rhythm": "0.0.11"
   },
   "devDependencies": {
+    "@types/bun": "^1.2.0",
     "@types/node": "^26.6.3",
-    "typescript": "^7.0.2",
-    "vite-plus": "^1.0.0"
+    "typescript": "^7.0.2"
   },
   "engines": {
-    "node": ">=20.19.0"
+    "bun": ">=1.2.0"
+  },
+  "scripts": {
+    "build": "bun build src/rhythm-router.ts src/context.ts src/fetch.ts src/serve.ts src/static.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
   }
 }

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

@@ -1,8 +0,0 @@
-import { t as RhythmHttpContext } from "../context-ChHlG-q0.js";
-import { t as AdapterOptions } from "../base-DwJhCkwZ.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

@@ -1,9 +0,0 @@
-import { t as createFetchAdapter } from "../base-BMFEzT_g.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,5 +0,0 @@
-import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
-//#region src/adapters/bun.d.ts
-export declare const handle: FetchAdapter<[server?: unknown]>;
-//#endregion
-export type { AdapterOptions };

package/dist/adapters/bun.js

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

package/dist/adapters/cloudflare.d.ts

@@ -1,5 +0,0 @@
-import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.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

@@ -1,13 +0,0 @@
-import { n as setRuntime, t as createFetchAdapter } from "../base-BMFEzT_g.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,5 +0,0 @@
-import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
-//#region src/adapters/deno.d.ts
-export declare const handle: FetchAdapter<[info?: unknown]>;
-//#endregion
-export type { AdapterOptions };

package/dist/adapters/deno.js

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

package/dist/adapters/netlify.d.ts

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

package/dist/adapters/netlify.js

@@ -1,10 +0,0 @@
-import { n as setRuntime, t as createFetchAdapter } from "../base-BMFEzT_g.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,11 +0,0 @@
-import { t as RhythmHttpContext } from "../context-ChHlG-q0.js";
-import { t as AdapterOptions } from "../base-DwJhCkwZ.js";
-import { NodeHttp1Handler, NodeHttp2Handler } from "srvx";
-import { Rhythm } from "@rhythmjs/rhythm";
-//#region src/adapters/node.d.ts
-export interface NodeHandlerOptions extends AdapterOptions {
-  maxRequestBodySize?: number;
-}
-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,9 +0,0 @@
-import { t as createFetchAdapter } from "../base-BMFEzT_g.js";
-import { toNodeHandler } from "srvx/node";
-//#region src/adapters/node.ts
-const fetchHandle = createFetchAdapter();
-function getRequestListener(app, options = {}) {
-	return toNodeHandler(fetchHandle(app, options), options);
-}
-//#endregion
-export { getRequestListener };

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

@@ -1,11 +0,0 @@
-import { t as RhythmHttpContext } from "../context-ChHlG-q0.js";
-import { t as AdapterOptions } from "../base-DwJhCkwZ.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

@@ -1,11 +0,0 @@
-import { t as createFetchAdapter } from "../base-BMFEzT_g.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

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

package/dist/adapters/vercel.js

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

package/dist/base-BMFEzT_g.js

@@ -1,26 +0,0 @@
-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) => {
-			if (options.websocket && request.headers.get("upgrade")?.toLowerCase() === "websocket") return options.websocket.handleUpgrade(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/base-DwJhCkwZ.d.ts

@@ -1,14 +0,0 @@
-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 WebSocketUpgrader {
-  handleUpgrade(request: Request, ...extra: unknown[]): Response | undefined | Promise<Response | undefined>;
-}
-interface AdapterOptions {
-  onError?: ErrorHandler;
-  websocket?: WebSocketUpgrader;
-}
-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/context-ChHlG-q0.d.ts

@@ -1,24 +0,0 @@
-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;
-  statusText: string | undefined;
-  headers: Headers;
-  body: RhythmResponseBody;
-}
-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;
-}
-declare function createHttpContext(request: Request): RhythmHttpContext;
-declare function toResponse(response: RhythmResponse): Response;
-//#endregion
-export { createHttpContext as a, RhythmRuntime as i, RhythmResponse as n, getRuntime as o, RhythmResponseBody as r, toResponse as s, RhythmHttpContext as t };