@rhythmjs/router 0.0.8 → 0.0.10

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,16 +29,16 @@ 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.
+- `.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.
 
@@ -77,15 +79,19 @@ Everything above (`RhythmRouter`, `ctx.response`, etc.) is runtime-agnostic. Two
 
 ## Deploying per runtime
 
-One app definition; each runtime has its own adapter under `@rhythmjs/router/adapters/*`, hono-style: import `handle` from your target's adapter and export what the platform expects.
+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**
+**Node** — `getRequestListener` returns a listener for your own `node:http` server:
 
 ```ts
 import { createServer } from "node:http";
-import { handle } from "@rhythmjs/router/adapters/node";
+import { getRequestListener } from "@rhythmjs/router/adapters/node";
 
-createServer(handle(app, { maxRequestBodySize: 1024 * 1024 })).listen(3000);
+createServer(getRequestListener(app, { maxRequestBodySize: 1024 * 1024 })).listen(3000);
 ```
 
 (Or skip the adapter entirely and use `serve(app, { port: 3000 })`.)

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

@@ -1,7 +1,8 @@
-import { RhythmHttpContext } from "../context.js";
+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>): AWSLambdaHandler;
+export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: AdapterOptions): AWSLambdaHandler;
 //#endregion
-export type { AWSLambdaHandler };
+export type { AWSLambdaHandler, AdapterOptions };

package/dist/adapters/aws-lambda.js

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

package/dist/adapters/bun.d.ts

@@ -1,5 +1,5 @@
-import { RhythmHttpContext } from "../context.js";
-import { Rhythm } from "@rhythmjs/rhythm";
+import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
 //#region src/adapters/bun.d.ts
-export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request) => Promise<Response>;
-//#endregion
+export declare const handle: FetchAdapter<[server?: unknown]>;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/bun.js

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

package/dist/adapters/cloudflare.d.ts

@@ -1,5 +1,5 @@
-import { RhythmHttpContext } from "../context.js";
-import { Rhythm } from "@rhythmjs/rhythm";
+import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
 //#region src/adapters/cloudflare.d.ts
-export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request, env?: unknown, context?: unknown) => Promise<Response>;
-//#endregion
+export declare const handle: FetchAdapter<[env?: unknown, context?: unknown]>;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/cloudflare.js

@@ -1,20 +1,13 @@
-import { toFetchHandler } from "../fetch.js";
+import { n as setRuntime, t as createFetchAdapter } from "../base-BMFEzT_g.js";
 //#region src/adapters/cloudflare.ts
-function handle(app) {
-	const handler = toFetchHandler(app);
-	return (request, env, context) => {
-		if (env !== void 0 || context !== void 0) Object.defineProperty(request, "runtime", {
-			value: {
-				name: "cloudflare",
-				cloudflare: {
-					env,
-					context
-				}
-			},
-			configurable: true
-		});
-		return handler(request);
-	};
-}
+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 +1,5 @@
-import { RhythmHttpContext } from "../context.js";
-import { Rhythm } from "@rhythmjs/rhythm";
+import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
 //#region src/adapters/deno.d.ts
-export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request) => Promise<Response>;
-//#endregion
+export declare const handle: FetchAdapter<[info?: unknown]>;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/deno.js

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

package/dist/adapters/netlify.d.ts

@@ -1,5 +1,5 @@
-import { RhythmHttpContext } from "../context.js";
-import { Rhythm } from "@rhythmjs/rhythm";
+import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
 //#region src/adapters/netlify.d.ts
-export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request, context?: unknown) => Promise<Response>;
-//#endregion
+export declare const handle: FetchAdapter<[context?: unknown]>;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/netlify.js

@@ -1,17 +1,10 @@
-import { toFetchHandler } from "../fetch.js";
+import { n as setRuntime, t as createFetchAdapter } from "../base-BMFEzT_g.js";
 //#region src/adapters/netlify.ts
-function handle(app) {
-	const handler = toFetchHandler(app);
-	return (request, context) => {
-		if (context !== void 0) Object.defineProperty(request, "runtime", {
-			value: {
-				name: "netlify",
-				netlify: { context }
-			},
-			configurable: true
-		});
-		return handler(request);
-	};
-}
+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,9 +1,11 @@
-import { RhythmHttpContext } from "../context.js";
-import { NodeHttpHandler } from "srvx";
+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 {
+export interface NodeHandlerOptions extends AdapterOptions {
   maxRequestBodySize?: number;
 }
-export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>, options?: NodeHandlerOptions): NodeHttpHandler;
+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,17 +1,9 @@
-import { toFetchHandler } from "../fetch.js";
-import { errorToResponse } from "../serve.js";
+import { t as createFetchAdapter } from "../base-BMFEzT_g.js";
 import { toNodeHandler } from "srvx/node";
 //#region src/adapters/node.ts
-function handle(app, options = {}) {
-	const handler = toFetchHandler(app);
-	const safeHandler = async (request) => {
-		try {
-			return await handler(request);
-		} catch (error) {
-			return errorToResponse(error);
-		}
-	};
-	return toNodeHandler(safeHandler, options);
+const fetchHandle = createFetchAdapter();
+function getRequestListener(app, options = {}) {
+	return toNodeHandler(fetchHandle(app, options), options);
 }
 //#endregion
-export { handle };
+export { getRequestListener };

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

@@ -1,9 +1,11 @@
-import { RhythmHttpContext } from "../context.js";
+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>): (event: FetchEventLike) => void;
-//#endregion
+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,7 +1,8 @@
-import { toFetchHandler } from "../fetch.js";
+import { t as createFetchAdapter } from "../base-BMFEzT_g.js";
 //#region src/adapters/service-worker.ts
-function handle(app) {
-	const handler = toFetchHandler(app);
+const fetchHandle = createFetchAdapter();
+function handle(app, options = {}) {
+	const handler = fetchHandle(app, options);
 	return (event) => {
 		event.respondWith(handler(event.request));
 	};

package/dist/adapters/vercel.d.ts

@@ -1,5 +1,5 @@
-import { RhythmHttpContext } from "../context.js";
-import { Rhythm } from "@rhythmjs/rhythm";
+import { n as FetchAdapter, t as AdapterOptions } from "../base-DwJhCkwZ.js";
 //#region src/adapters/vercel.d.ts
-export declare function handle<TContext extends RhythmHttpContext, TProviders extends object = {}>(app: Rhythm<RhythmHttpContext, TContext, TProviders>): (request: Request) => Promise<Response>;
-//#endregion
+export declare const handle: FetchAdapter;
+//#endregion
+export type { AdapterOptions };

package/dist/adapters/vercel.js

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

package/dist/base-BMFEzT_g.js

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,24 @@
+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 };

package/dist/context.d.ts

@@ -1,20 +1,2 @@
-//#region src/context.d.ts
-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;
-//#endregion
+import { a as createHttpContext, i as RhythmRuntime, n as RhythmResponse, o as getRuntime, r as RhythmResponseBody, s as toResponse, t as RhythmHttpContext } from "./context-ChHlG-q0.js";
+export { RhythmHttpContext, RhythmResponse, RhythmResponseBody, RhythmRuntime, createHttpContext, getRuntime, toResponse };

package/dist/context.js

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

package/dist/fetch.d.ts

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

package/dist/rhythm-router.d.ts

@@ -1,4 +1,4 @@
-import { RhythmHttpContext } from "./context.js";
+import { t as RhythmHttpContext } from "./context-ChHlG-q0.js";
 import { DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
 //#region src/rhythm-router.d.ts
 export interface RhythmRouterContext {
@@ -18,6 +18,7 @@ export type RouterEntry = {
   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);

package/dist/rhythm-router.js

@@ -1,6 +1,10 @@
-import { createNode, insertRoute, joinPath, lookupRoute } from "./radix-tree.js";
 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}`}`;
+}
 var RhythmRouter = class {
 	#options;
 	#entries = [];
@@ -48,14 +52,14 @@ var RhythmRouter = class {
 	#compile() {
 		const dispatchFor = (tree) => {
 			return async (ctx, next) => {
-				const match = lookupRoute(tree, ctx.request.method, new URL(ctx.request.url).pathname);
+				const match = findRoute(tree, ctx.request.method, new URL(ctx.request.url).pathname);
 				if (!match) {
 					await next();
 					return;
 				}
-				await match.payload({
+				await match.data({
 					...ctx,
-					params: match.params
+					params: match.params ?? {}
 				}, next);
 			};
 		};
@@ -68,11 +72,11 @@ var RhythmRouter = class {
 				i++;
 				continue;
 			}
-			const tree = createNode();
+			const tree = createRouter();
 			while (i < this.#entries.length) {
 				const route = this.#entries[i];
 				if (route.kind !== "route") break;
-				insertRoute(tree, route.method, route.path, compose(route.handlers));
+				addRoute(tree, route.method, route.path, compose(route.handlers));
 				i++;
 			}
 			stack.push(dispatchFor(tree));
@@ -87,4 +91,4 @@ var RhythmRouter = class {
 	}
 };
 //#endregion
-export { RhythmRouter };
+export { RhythmRouter, joinPath };

package/dist/serve.d.ts

@@ -1,4 +1,4 @@
-import { RhythmHttpContext } from "./context.js";
+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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.8",
-  "description": "Radix-tree HTTP router for the Rhythm middleware kernel, with Bun, Node, and Deno adapters.",
+  "version": "0.0.10",
+  "description": "HTTP router for the Rhythm middleware kernel, matching with rou3, with Bun, Node, and Deno adapters.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
   "repository": {
@@ -19,10 +19,6 @@
       "types": "./dist/rhythm-router.d.ts",
       "default": "./dist/rhythm-router.js"
     },
-    "./radix-tree": {
-      "types": "./dist/radix-tree.d.ts",
-      "default": "./dist/radix-tree.js"
-    },
     "./context": {
       "types": "./dist/context.d.ts",
       "default": "./dist/context.js"
@@ -77,8 +73,9 @@
     "access": "public"
   },
   "dependencies": {
+    "rou3": "^0.11.0",
     "srvx": "^1.0.5",
-    "@rhythmjs/rhythm": "0.0.8"
+    "@rhythmjs/rhythm": "0.0.10"
   },
   "devDependencies": {
     "@types/node": "^26.6.3",

package/dist/radix-tree.d.ts

@@ -1,18 +0,0 @@
-//#region src/radix-tree.d.ts
-export declare class TreeNode<TMethod extends string = string, TPayload = unknown> {
-  path: string;
-  indices: string;
-  children: TreeNode<TMethod, TPayload>[];
-  paramChild: TreeNode<TMethod, TPayload> | null;
-  paramName: string;
-  wildcardChild: TreeNode<TMethod, TPayload> | null;
-  methods: Map<TMethod, TPayload> | null;
-}
-export declare function createNode<TMethod extends string = string, TPayload = unknown>(): TreeNode<TMethod, TPayload>;
-export declare function insertRoute<TMethod extends string, TPayload>(root: TreeNode<TMethod, TPayload>, method: TMethod, path: string, payload: TPayload): void;
-export declare function lookupRoute<TMethod extends string, TPayload>(root: TreeNode<TMethod, TPayload>, method: string, pathname: string): {
-  payload: TPayload;
-  params: Record<string, string>;
-} | null;
-export declare function joinPath(prefix: string, path: string): string;
-//#endregion

package/dist/radix-tree.js

@@ -1,150 +0,0 @@
-//#region src/radix-tree.ts
-var TreeNode = class {
-	path = "";
-	indices = "";
-	children = [];
-	paramChild = null;
-	paramName = "";
-	wildcardChild = null;
-	methods = null;
-};
-function createNode() {
-	return new TreeNode();
-}
-function commonPrefixLength(a, b) {
-	const max = a.length < b.length ? a.length : b.length;
-	let i = 0;
-	while (i < max && a.charCodeAt(i) === b.charCodeAt(i)) i++;
-	return i;
-}
-function splitChild(node, at) {
-	const tail = new TreeNode();
-	tail.path = node.path.slice(at);
-	tail.indices = node.indices;
-	tail.children = node.children;
-	tail.paramChild = node.paramChild;
-	tail.paramName = node.paramName;
-	tail.wildcardChild = node.wildcardChild;
-	tail.methods = node.methods;
-	node.path = node.path.slice(0, at);
-	node.children = [tail];
-	node.indices = tail.path.charAt(0);
-	node.paramChild = null;
-	node.paramName = "";
-	node.wildcardChild = null;
-	node.methods = null;
-}
-function insertAt(node, path, method, payload) {
-	if (path.length === 0) {
-		if (!node.methods) node.methods = /* @__PURE__ */ new Map();
-		node.methods.set(method, payload);
-		return;
-	}
-	if (path.charCodeAt(0) === 58) {
-		const slashIndex = path.indexOf("/");
-		const name = slashIndex === -1 ? path.slice(1) : path.slice(1, slashIndex);
-		const rest = slashIndex === -1 ? "" : path.slice(slashIndex);
-		if (!node.paramChild) {
-			node.paramChild = new TreeNode();
-			node.paramChild.paramName = name;
-		}
-		insertAt(node.paramChild, rest, method, payload);
-		return;
-	}
-	if (path.charCodeAt(0) === 42) {
-		if (path.length !== 1) throw new Error("wildcard \"*\" is only allowed at the end of a path");
-		if (!node.wildcardChild) node.wildcardChild = new TreeNode();
-		if (!node.wildcardChild.methods) node.wildcardChild.methods = /* @__PURE__ */ new Map();
-		node.wildcardChild.methods.set(method, payload);
-		return;
-	}
-	const colonIndex = path.indexOf(":");
-	const starIndex = path.indexOf("*");
-	let staticEnd = path.length;
-	if (colonIndex !== -1) staticEnd = colonIndex;
-	if (starIndex !== -1 && starIndex < staticEnd) staticEnd = starIndex;
-	const staticPart = path.slice(0, staticEnd);
-	const firstChar = path.charAt(0);
-	for (let i = 0; i < node.children.length; i++) {
-		if (node.indices.charAt(i) !== firstChar) continue;
-		const child = node.children[i];
-		const cpl = commonPrefixLength(staticPart, child.path);
-		if (cpl === 0) continue;
-		if (cpl < child.path.length) splitChild(child, cpl);
-		insertAt(child, path.slice(cpl), method, payload);
-		return;
-	}
-	const child = new TreeNode();
-	child.path = staticPart;
-	node.children.push(child);
-	node.indices += firstChar;
-	insertAt(child, path.slice(staticPart.length), method, payload);
-}
-function expandOptionalParams(path) {
-	if (!path.includes("?")) return [path];
-	const segments = path.split("/");
-	let firstOptional = -1;
-	for (let i = 0; i < segments.length; i++) {
-		const segment = segments[i];
-		const isOptional = segment.length > 2 && segment.charCodeAt(0) === 58 && segment.endsWith("?");
-		if (!isOptional && segment.includes("?")) throw new Error(`"?" is only allowed to mark an optional param like ":name?" (in "${path}")`);
-		if (firstOptional !== -1 && !isOptional) throw new Error(`only optional params may follow an optional param (in "${path}")`);
-		if (isOptional && firstOptional === -1) firstOptional = i;
-	}
-	const variants = [];
-	for (let end = firstOptional; end <= segments.length; end++) {
-		const parts = segments.slice(0, end).map((segment) => segment.endsWith("?") ? segment.slice(0, -1) : segment);
-		variants.push(parts.join("/") || "/");
-	}
-	return variants;
-}
-function insertRoute(root, method, path, payload) {
-	for (const variant of expandOptionalParams(path)) insertAt(root, variant, method, payload);
-}
-function search(node, method, path) {
-	if (path.length === 0) {
-		const payload = node.methods?.get(method);
-		if (payload !== void 0) return {
-			payload,
-			params: {}
-		};
-	} else {
-		const firstChar = path.charAt(0);
-		for (let i = 0; i < node.children.length; i++) {
-			if (node.indices.charAt(i) !== firstChar) continue;
-			const child = node.children[i];
-			if (!path.startsWith(child.path)) continue;
-			const result = search(child, method, path.slice(child.path.length));
-			if (result) return result;
-		}
-		if (node.paramChild) {
-			const slashIndex = path.indexOf("/");
-			const value = slashIndex === -1 ? path : path.slice(0, slashIndex);
-			if (value.length > 0) {
-				const rest = slashIndex === -1 ? "" : path.slice(slashIndex);
-				const result = search(node.paramChild, method, rest);
-				if (result) {
-					result.params[node.paramChild.paramName] = decodeURIComponent(value);
-					return result;
-				}
-			}
-		}
-	}
-	if (node.wildcardChild) {
-		const payload = node.wildcardChild.methods?.get(method);
-		if (payload !== void 0) return {
-			payload,
-			params: { "*": decodeURIComponent(path) }
-		};
-	}
-	return null;
-}
-function lookupRoute(root, method, pathname) {
-	return search(root, method, pathname);
-}
-function joinPath(prefix, path) {
-	if (!prefix) return path;
-	return `${prefix.endsWith("/") ? prefix.slice(0, -1) : prefix}${path.startsWith("/") ? path : `/${path}`}`;
-}
-//#endregion
-export { TreeNode, createNode, insertRoute, joinPath, lookupRoute };