@rhythmjs/router 0.0.14 → 0.0.16

package/README.md

@@ -4,7 +4,7 @@ The HTTP layer of Rhythm, the Bun-native backend framework: web-standard (`Reque
 
 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`, `derive`; `next()` takes no arguments, extend the context with `derive()`), but has no a startup `context` or `register()`, and it can't be served on its own: a `Rhythm` app is always the host that owns the lifecycle and the adapters.
+`RhythmRouter` is not an app and does not extend `Rhythm`; it is a controller that compiles routes and middleware down to a single middleware (`.middleware()`). It shares the core middleware contract (`compose`, `Middleware`, `derive`; `next()` takes no arguments, extend the context with `derive()`), but has no startup `context` 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
 
@@ -31,7 +31,8 @@ A fuller runnable version, including nested prefixes and a fallback route, is at
 - **`ctx.params`**: captured `:name` path segments, added once a route matches.
 - **Nesting is `.use(child.middleware())`**: a router mounts into another router (or into the app) as a compiled middleware. The mount is opaque, so the parent's prefix is **not** applied to the child's routes: the child carries its own absolute prefix (`new RhythmRouter({ prefix: "/api/users" })`). On a miss the child falls through to `next()`, so the parent's later middleware and routes still run, and the child keeps working standalone.
 - **Registration order is execution order**: a `.use()` middleware wraps only the routes registered after it, and runs only when one of them matches the request's method and path (so a guard in a `/projects` router never answers `/docs`); a mounted router (`.use(child.middleware())`) always runs; 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 a startup `context` 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())`.
+- **Conditional middleware**: `.use(fn, condition)` also needs `condition(ctx)` to return true (sync or async); the second callback only narrows, so a middleware registered after every route still never runs. `@rhythmjs/router/match` provides ready-made predicates: `matches("/api/**")` (patterns, `exclude`, `methods`) and `routed(module)` (true only for requests the module's own routers serve), e.g. `app.use(audit(), routed(usersModule))`.
+- **A router is a controller, not a module**: it has no startup `context` 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
 

package/dist/match.d.ts

@@ -0,0 +1,14 @@
+import type { HttpMethod } from "./rhythm-router";
+export type RoutePattern = string | readonly string[];
+export interface RouteMatchOptions {
+    include?: RoutePattern;
+    exclude?: RoutePattern;
+    methods?: readonly HttpMethod[];
+}
+export type RequestPredicate = (ctx: {
+    readonly request: Request;
+}) => boolean;
+export declare function matches(spec: RoutePattern | RouteMatchOptions): RequestPredicate;
+export declare function routed(module: {
+    readonly sources: readonly object[];
+}): RequestPredicate;

package/dist/match.js

@@ -0,0 +1,53 @@
+// @bun
+import {
+  mountedRoutes2,
+  RhythmRouter2
+} from "./rhythm-router-wmzh62d5.js";
+
+// src/match.ts
+import { addRoute, createRouter, findRoute } from "rou3";
+var toList = (pattern) => pattern === undefined ? [] : typeof pattern === "string" ? [pattern] : pattern;
+var pathnameOf = (request) => new URL(request.url).pathname;
+function treeOf(patterns, methods) {
+  const tree = createRouter();
+  for (const pattern of patterns) {
+    if (methods && methods.length > 0)
+      for (const method of methods)
+        addRoute(tree, method, pattern, true);
+    else
+      addRoute(tree, undefined, pattern, true);
+  }
+  return tree;
+}
+function matches(spec) {
+  const options = typeof spec === "string" || Array.isArray(spec) ? { include: spec } : spec;
+  const include = toList(options.include);
+  const includeTree = include.length > 0 ? treeOf(include, options.methods) : undefined;
+  const excludeTree = toList(options.exclude).length > 0 ? treeOf(toList(options.exclude), options.methods) : undefined;
+  const methodsOnly = !includeTree && options.methods && options.methods.length > 0 ? new Set(options.methods) : undefined;
+  return ({ request }) => {
+    const path = pathnameOf(request);
+    if (excludeTree && findRoute(excludeTree, request.method, path, { params: false }))
+      return false;
+    if (includeTree)
+      return !!findRoute(includeTree, request.method, path, { params: false });
+    return methodsOnly ? methodsOnly.has(request.method) : true;
+  };
+}
+function routed(module) {
+  let tree;
+  return ({ request }) => {
+    if (!tree) {
+      tree = createRouter();
+      const seen = new Set;
+      for (const source of module.sources)
+        if (source instanceof RhythmRouter2)
+          mountedRoutes2(source, tree, seen);
+    }
+    return !!findRoute(tree, request.method, pathnameOf(request), { params: false });
+  };
+}
+export {
+  matches,
+  routed
+};

package/dist/rhythm-router-1w0gr0r3.js

@@ -0,0 +1,133 @@
+// @bun
+// src/rhythm-router.ts
+import { compose, gate } from "@rhythmjs/rhythm/compose";
+import { sourceOf, withSource } from "@rhythmjs/rhythm/source";
+import { addRoute, createRouter, findRoute } from "rou3";
+function joinPath2(prefix, path) {
+  if (!prefix)
+    return path;
+  if (path === "/" || path === "")
+    return prefix;
+  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${trimmedPrefix}${normalizedPath}`;
+}
+function mountedRoutes2(router, tree, seen = new Set) {
+  if (seen.has(router))
+    return;
+  seen.add(router);
+  for (const entry of router.entries) {
+    if (entry.kind === "route")
+      addRoute(tree, entry.method, entry.path, true);
+    else {
+      const child = sourceOf(entry.fn);
+      if (child instanceof RhythmRouter2)
+        mountedRoutes2(child, tree, seen);
+    }
+  }
+}
+
+class RhythmRouter2 {
+  #options;
+  #entries = [];
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  get #prefixPath() {
+    return this.#options.prefix ?? "";
+  }
+  get entries() {
+    return [...this.#entries];
+  }
+  use(fn, when) {
+    if (typeof fn !== "function")
+      throw new TypeError("middleware must be a function!");
+    if (when !== undefined && typeof when !== "function")
+      throw new TypeError("when must be a function!");
+    const source = sourceOf(fn);
+    const wrapped = when ? gate(fn, when) : fn;
+    this.#entries.push({ kind: "middleware", fn: when && source ? withSource(wrapped, source) : wrapped });
+    return this;
+  }
+  #route(method, path, handlers) {
+    this.#entries.push({ kind: "route", method, path: joinPath2(this.#prefixPath, 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 trees = [];
+    const reaches = (ctx, from) => {
+      const method = ctx.request.method;
+      const pathname = new URL(ctx.request.url).pathname;
+      for (let t = from;t < trees.length; t++)
+        if (findRoute(trees[t], method, pathname))
+          return true;
+      return false;
+    };
+    const stack = [];
+    let i = 0;
+    while (i < this.#entries.length) {
+      const entry = this.#entries[i];
+      if (entry.kind === "middleware") {
+        const { fn } = entry;
+        const source = sourceOf(fn);
+        if (source) {
+          if (source instanceof RhythmRouter2) {
+            const tree = createRouter();
+            mountedRoutes2(source, tree);
+            trees.push(tree);
+          }
+          stack.push(fn);
+        } else {
+          const from = trees.length;
+          stack.push((ctx, next) => reaches(ctx, from) ? fn(ctx, next) : next());
+        }
+        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++;
+      }
+      trees.push(tree);
+      stack.push(dispatchFor(tree));
+    }
+    return compose(stack);
+  }
+  middleware() {
+    const fn = this.#compile();
+    return withSource(async (ctx, next) => {
+      await fn(ctx, next);
+    }, this);
+  }
+}
+
+export { joinPath2, mountedRoutes2, RhythmRouter2 };

package/dist/rhythm-router-wmzh62d5.js

@@ -0,0 +1,133 @@
+// @bun
+// src/rhythm-router.ts
+import { compose, gate } from "@rhythmjs/rhythm/compose";
+import { sourceOf, withSource } from "@rhythmjs/rhythm/source";
+import { addRoute, createRouter, findRoute } from "rou3";
+function joinPath2(prefix, path) {
+  if (!prefix)
+    return path;
+  if (path === "/" || path === "")
+    return prefix;
+  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${trimmedPrefix}${normalizedPath}`;
+}
+function mountedRoutes2(router, tree, seen = new Set) {
+  if (seen.has(router))
+    return;
+  seen.add(router);
+  for (const entry of router.entries) {
+    if (entry.kind === "route")
+      addRoute(tree, entry.method, entry.path, true);
+    else {
+      const child = sourceOf(entry.fn);
+      if (child instanceof RhythmRouter2)
+        mountedRoutes2(child, tree, seen);
+    }
+  }
+}
+
+class RhythmRouter2 {
+  #options;
+  #entries = [];
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  get #prefixPath() {
+    return this.#options.prefix ?? "";
+  }
+  get entries() {
+    return [...this.#entries];
+  }
+  use(fn, condition) {
+    if (typeof fn !== "function")
+      throw new TypeError("middleware must be a function!");
+    if (condition !== undefined && typeof condition !== "function")
+      throw new TypeError("condition must be a function!");
+    const source = sourceOf(fn);
+    const wrapped = condition ? gate(fn, condition) : fn;
+    this.#entries.push({ kind: "middleware", fn: condition && source ? withSource(wrapped, source) : wrapped });
+    return this;
+  }
+  #route(method, path, handlers) {
+    this.#entries.push({ kind: "route", method, path: joinPath2(this.#prefixPath, 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 trees = [];
+    const reaches = (ctx, from) => {
+      const method = ctx.request.method;
+      const pathname = new URL(ctx.request.url).pathname;
+      for (let t = from;t < trees.length; t++)
+        if (findRoute(trees[t], method, pathname))
+          return true;
+      return false;
+    };
+    const stack = [];
+    let i = 0;
+    while (i < this.#entries.length) {
+      const entry = this.#entries[i];
+      if (entry.kind === "middleware") {
+        const { fn } = entry;
+        const source = sourceOf(fn);
+        if (source) {
+          if (source instanceof RhythmRouter2) {
+            const tree = createRouter();
+            mountedRoutes2(source, tree);
+            trees.push(tree);
+          }
+          stack.push(fn);
+        } else {
+          const from = trees.length;
+          stack.push((ctx, next) => reaches(ctx, from) ? fn(ctx, next) : next());
+        }
+        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++;
+      }
+      trees.push(tree);
+      stack.push(dispatchFor(tree));
+    }
+    return compose(stack);
+  }
+  middleware() {
+    const fn = this.#compile();
+    return withSource(async (ctx, next) => {
+      await fn(ctx, next);
+    }, this);
+  }
+}
+
+export { joinPath2, mountedRoutes2, RhythmRouter2 };

package/dist/rhythm-router-wpdgx942.js

@@ -0,0 +1,132 @@
+// @bun
+// src/rhythm-router.ts
+import { compose, gate } from "@rhythmjs/rhythm/compose";
+import { sourceOf, withSource } from "@rhythmjs/rhythm/source";
+import { addRoute, createRouter, findRoute } from "rou3";
+function joinPath2(prefix, path) {
+  if (!prefix)
+    return path;
+  if (path === "/" || path === "")
+    return prefix;
+  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${trimmedPrefix}${normalizedPath}`;
+}
+function mountedRoutes2(router, tree, seen = new Set) {
+  if (seen.has(router))
+    return;
+  seen.add(router);
+  for (const entry of router.entries) {
+    if (entry.kind === "route")
+      addRoute(tree, entry.method, entry.path, true);
+    else {
+      const child = sourceOf(entry.fn);
+      if (child instanceof RhythmRouter2)
+        mountedRoutes2(child, tree, seen);
+    }
+  }
+}
+
+class RhythmRouter2 {
+  #options;
+  #entries = [];
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  get #prefixPath() {
+    return this.#options.prefix ?? "";
+  }
+  get entries() {
+    return [...this.#entries];
+  }
+  use(fn, when) {
+    if (typeof fn !== "function")
+      throw new TypeError("middleware must be a function!");
+    if (when !== undefined && typeof when !== "function")
+      throw new TypeError("when must be a function!");
+    this.#entries.push(when ? { kind: "middleware", fn, when } : { kind: "middleware", fn });
+    return this;
+  }
+  #route(method, path, handlers) {
+    this.#entries.push({ kind: "route", method, path: joinPath2(this.#prefixPath, 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 trees = [];
+    const reaches = (ctx, from) => {
+      const method = ctx.request.method;
+      const pathname = new URL(ctx.request.url).pathname;
+      for (let t = from;t < trees.length; t++)
+        if (findRoute(trees[t], method, pathname))
+          return true;
+      return false;
+    };
+    const stack = [];
+    let i = 0;
+    while (i < this.#entries.length) {
+      const entry = this.#entries[i];
+      if (entry.kind === "middleware") {
+        const { fn, when } = entry;
+        const guarded = when ? gate(fn, when) : fn;
+        const source = sourceOf(fn);
+        if (source) {
+          if (source instanceof RhythmRouter2) {
+            const tree = createRouter();
+            mountedRoutes2(source, tree);
+            trees.push(tree);
+          }
+          stack.push(guarded);
+        } else {
+          const from = trees.length;
+          stack.push((ctx, next) => reaches(ctx, from) ? guarded(ctx, next) : next());
+        }
+        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++;
+      }
+      trees.push(tree);
+      stack.push(dispatchFor(tree));
+    }
+    return compose(stack);
+  }
+  middleware() {
+    const fn = this.#compile();
+    return withSource(async (ctx, next) => {
+      await fn(ctx, next);
+    }, this);
+  }
+}
+
+export { joinPath2, mountedRoutes2, RhythmRouter2 };

package/dist/rhythm-router.d.ts

@@ -1,4 +1,5 @@
-import type { DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
+import type { Condition, DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
+import { type RouterContext } from "rou3";
 import type { RhythmHttpContext } from "./context";
 export interface RhythmRouterContext {
     readonly params: Readonly<Record<string, string>>;
@@ -18,12 +19,13 @@ export type RouterEntry = {
 };
 type RouteHandler<TContext> = Middleware<TContext & RhythmRouterContext>;
 export declare function joinPath(prefix: string, path: string): string;
+export declare function mountedRoutes(router: RhythmRouter<any, any>, tree: RouterContext<any>, seen?: Set<object>): void;
 export declare class RhythmRouter<TContext extends RhythmHttpContext = RhythmHttpContext, TInput extends RhythmHttpContext = TContext> {
     #private;
     constructor(options?: RhythmRouterOptions);
     get entries(): readonly RouterEntry[];
     use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): RhythmRouter<TContext & TExtra, TInput>;
-    use(fn: Middleware<TContext>): this;
+    use(fn: Middleware<TContext>, condition?: Condition<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;

package/dist/rhythm-router.js

@@ -1,131 +1,11 @@
 // @bun
-// src/rhythm-router.ts
-import { compose } from "@rhythmjs/rhythm/compose";
-import { sourceOf, withSource } from "@rhythmjs/rhythm/source";
-import { addRoute, createRouter, findRoute } from "rou3";
-function joinPath(prefix, path) {
-  if (!prefix)
-    return path;
-  if (path === "/" || path === "")
-    return prefix;
-  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-  return `${trimmedPrefix}${normalizedPath}`;
-}
-function mountedRoutes(router, tree, seen = new Set) {
-  if (seen.has(router))
-    return;
-  seen.add(router);
-  for (const entry of router.entries) {
-    if (entry.kind === "route")
-      addRoute(tree, entry.method, entry.path, true);
-    else {
-      const child = sourceOf(entry.fn);
-      if (child instanceof RhythmRouter)
-        mountedRoutes(child, tree, seen);
-    }
-  }
-}
-
-class RhythmRouter {
-  #options;
-  #entries = [];
-  constructor(options = {}) {
-    this.#options = options;
-  }
-  get #prefixPath() {
-    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.#prefixPath, 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 trees = [];
-    const reaches = (ctx, from) => {
-      const method = ctx.request.method;
-      const pathname = new URL(ctx.request.url).pathname;
-      for (let t = from;t < trees.length; t++)
-        if (findRoute(trees[t], method, pathname))
-          return true;
-      return false;
-    };
-    const stack = [];
-    let i = 0;
-    while (i < this.#entries.length) {
-      const entry = this.#entries[i];
-      if (entry.kind === "middleware") {
-        const { fn } = entry;
-        const source = sourceOf(fn);
-        if (source) {
-          if (source instanceof RhythmRouter) {
-            const tree = createRouter();
-            mountedRoutes(source, tree);
-            trees.push(tree);
-          }
-          stack.push(fn);
-        } else {
-          const from = trees.length;
-          stack.push((ctx, next) => reaches(ctx, from) ? fn(ctx, next) : next());
-        }
-        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++;
-      }
-      trees.push(tree);
-      stack.push(dispatchFor(tree));
-    }
-    return compose(stack);
-  }
-  middleware() {
-    const fn = this.#compile();
-    return withSource(async (ctx, next) => {
-      await fn(ctx, next);
-    }, this);
-  }
-}
+import {
+  joinPath2,
+  mountedRoutes2,
+  RhythmRouter2
+} from "./rhythm-router-wmzh62d5.js";
 export {
-  RhythmRouter,
-  joinPath
+  RhythmRouter2 as RhythmRouter,
+  joinPath2 as joinPath,
+  mountedRoutes2 as mountedRoutes
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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",
@@ -27,6 +27,10 @@
       "types": "./dist/fetch.d.ts",
       "default": "./dist/fetch.js"
     },
+    "./match": {
+      "types": "./dist/match.d.ts",
+      "default": "./dist/match.js"
+    },
     "./adapters/context": {
       "types": "./dist/context.d.ts",
       "default": "./dist/context.js"
@@ -38,7 +42,7 @@
   },
   "dependencies": {
     "rou3": "^0.11.0",
-    "@rhythmjs/rhythm": "0.0.15"
+    "@rhythmjs/rhythm": "0.0.16"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",
@@ -49,7 +53,7 @@
     "bun": ">=1.2.0"
   },
   "scripts": {
-    "build": "bun build src/rhythm-router.ts src/context.ts src/fetch.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
+    "build": "bun build src/rhythm-router.ts src/context.ts src/fetch.ts src/match.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   }