@rhythmjs/router 0.0.9 → 0.0.11

package/README.md

@@ -1,8 +1,10 @@
 # @rhythmjs/router
 
-Web-standard HTTP routing on top of `@rhythmjs/rhythm`. `RhythmRouter` matches routes with a compressed radix tree (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.routes())`, so an unmatched request correctly falls through to whatever's registered after it.
+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.
 
-`RhythmRouter` is not an app and does not extend `Rhythm` — it is a controller that compiles routes and middleware down to a single middleware (`.routes()`). 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.
+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.
 
 ## Example
 
@@ -27,31 +29,44 @@ A fuller runnable version, including nested prefixes and a fallback route, is at
 - **`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.
-- **Prefixes compose across nesting** — a child router mounted into a prefixed parent via `.use(child)` gets the parent's prefix joined onto every one of its routes, at any nesting depth. Mounting copies the child's routes and middleware at that moment; routes added to the child afterwards don't appear in the parent, 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 radix tree 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.routes())`.
+- **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. `.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 `@rhythmjs/router/context`).
+- `.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 (`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 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()` 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
 
-- **`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.
+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" }],
+});
+```
 
-`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`.
+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, {
@@ -67,88 +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`.
-
-**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,39 +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 {};