@rhythmjs/router 0.0.16 → 0.0.17

package/README.md

@@ -1,48 +1,56 @@
 # @rhythmjs/router
 
-The HTTP layer of Rhythm, the Bun-native backend framework: web-standard (`Request`/`Response`) routing on top of the `@rhythmjs/rhythm` kernel, served on `Bun.serve`. `RhythmRouter` matches routes with [rou3](https://github.com/h3js/rou3), the router that powers h3 (a static segment always wins over a `:param` segment, regardless of registration order), supports prefixes and nested routers, and mounts flat into a parent `Rhythm` app via `.use(router.middleware())`, so an unmatched request correctly falls through to whatever's registered after it.
+The HTTP layer of Rhythm, the Bun-native backend framework: web-standard (`Request`/`Response`) routing on top of the `@rhythmjs/rhythm` kernel, served on `Bun.serve`. `RhythmRouter` matches routes with [rou3](https://github.com/h3js/rou3), the router that powers h3 (a static segment always wins over a `:param` segment, regardless of registration order).
 
-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.
+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 URI-decoded; a malformed escape does not match.
 
-`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.
+`RhythmRouter` is a `Pipeline`, like `Rhythm`: it has request-time `use()` middleware and routes, but no startup phase. Startup work (`register`, `decorate`, `include`) belongs to the `Rhythm` app that mounts it with `mount(router)`.
 
 ## Example
 
 ```ts
-import { Rhythm } from "@rhythmjs/rhythm";
+import { Rhythm, decorate, derive, mount } from "@rhythmjs/rhythm";
 import { RhythmRouter } from "@rhythmjs/router";
 import { toFetchHandler } from "@rhythmjs/router/fetch";
-import type { RhythmHttpContext } from "@rhythmjs/router/context";
 
-const usersRouter = new RhythmRouter({ prefix: "/users" }).get("/:id", (ctx) => {
-  ctx.json({ id: ctx.params.id });
-});
+const users = new RhythmRouter({ name: "users" })
+  .get("/users/:id", (ctx) => ctx.json({ id: ctx.params.id }))
+  .post(
+    "/users",
+    derive(async (ctx) => ({ body: await ctx.request.json() })),
+    (ctx) => ctx.json(ctx.body, 201),
+  );
+
+const app = new Rhythm()
+  .register(decorate(() => ({ startedAt: Date.now() })))
+  .use(derive(() => ({ requestId: crypto.randomUUID() })))
+  .use(mount(users));
 
-const app = new Rhythm<RhythmHttpContext>().use(usersRouter.middleware());
 Bun.serve({ port: 3000, fetch: toFetchHandler(app) });
 ```
 
-A fuller runnable version, including nested prefixes and a fallback route, is at [`examples/router`](../../examples/router).
-
 ## Concepts
 
-- **`ctx.response`** is a plain mutable object (`status`, `statusText`, `headers`, `body`): set it directly rather than constructing a `Response` yourself. The adapter converts it to a real `Response` at the end.
-- **Response helpers**: `ctx.json(data, status?)`, `ctx.text(body, status?)`, `ctx.html(body, status?)`, `ctx.error(status, message?)`, and `ctx.redirect(url, status = 302)` (status must be 301, 302, 303, 307 or 308; the URL is used as given, so never pass a user-supplied `next`/`returnTo` value without checking it against an allowlist or requiring a same-origin path) set the content type, body, and status on `ctx.response` in one call. `error()` defaults the message from the status code (`ctx.error(404)` → `"Not Found"`). They're sugar over `ctx.response`, so mixing both styles is fine, and later writes win.
-- **`ctx.params`**: captured `:name` path segments, added once a route matches.
-- **Nesting is `.use(child.middleware())`**: a router mounts into another router (or into the app) as a compiled middleware. The mount is opaque, so the parent's prefix is **not** applied to the child's routes: the child carries its own absolute prefix (`new RhythmRouter({ prefix: "/api/users" })`). On a miss the child falls through to `next()`, so the parent's later middleware and routes still run, and the child keeps working standalone.
-- **Registration order is execution order**: a `.use()` middleware wraps only the routes registered after it, 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()`.
-- **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())`.
+- **Mounting.** A router mounts into a `Rhythm` app (or into another router) with `mount(router)`. After the router handles a request, the parent continues with `next()`, so later middleware still runs; check `ctx.params` or the response state if it should only act on unmatched requests. Give each router its full paths (there is no prefix option); to mount conditionally pass a second argument: `mount(router, (ctx) => ...)`.
+- **Request-time only.** `router.use(middleware)` wraps the router's routes and runs only when one of them matches the method and path, so a guard in one router never answers another's requests. Startup values live on the parent app's context and are on every request.
+- **`derive` as a route handler.** `derive(fn)` can be the first handler of a route (or `use()`), and widens the context type for the handlers after it.
+- **`ctx.response`** is a plain mutable object (`status`, `statusText`, `headers`, `body`): set it directly rather than constructing a `Response` yourself. `toFetchHandler` converts it to a real `Response` at the end, and answers `404` if nothing touched it.
+- **Response helpers**: `ctx.json(data, status?)`, `ctx.text(body, status?)`, `ctx.html(body, status?)`, `ctx.error(status, message?)`, and `ctx.redirect(url, status = 302)` (status must be 301, 302, 303, 307 or 308; the URL is used as given, so never pass a user-supplied `next`/`returnTo` value without checking it against an allowlist or requiring a same-origin path) set the content type, body, and status on `ctx.response` in one call. `error()` defaults the message from the status code (`ctx.error(404)` is `"Not Found"`). They're sugar over `ctx.response`, so mixing both styles is fine, and later writes win.
+- **`ctx.params`**: captured path params, typed from the path: `/users/:id` gives `params.id: string`, `:id?` is `string | undefined`, and reading a name that is not in the path is a compile error. In `use()` middleware, params are an untyped `Record<string, string>`, since several routes may match.
+- **Strict context.** Like `Rhythm`, the route context only has what was added: `ctx.nope` is a compile error, and `derive()` (router-level or as a route's first handler) is how you widen it. A route-level `derive` only affects that route.
+- **Apps and the fetch handler.** Inside an app's own middleware, `ctx.request`/`ctx.response` are typed only if the app declares them as input: `new Rhythm<{}, RhythmHttpContext>()`. `toFetchHandler(app)` rejects, at compile time, an app that requires any other input.
+- **Errors.** A route that throws makes the handler reject; mounted plugins wrap failures as `mounted router "name" failed` with the original as `cause`. `errorToResponse` looks through the `cause` chain for a declared status.
 
 ## API
 
-- `new RhythmRouter(options?)`: `options.prefix`.
-- `.get/.post/.put/.patch/.delete(path, ...handlers)`: register a route; `path` may contain `:param` segments.
-- `.use(fn)`: plain middleware; it takes only functions, so a nested router mounts as `.use(child.middleware())`.
-- `.middleware()`: this router compiled to a plain middleware: the one form that mounts anywhere, into a `Rhythm` app or into another router. Because the compiled form is opaque, the mounting router's prefix is not applied to it, so give the child its full prefix.
-- `.entries`: a read-only snapshot of registered middlewares and routes, in order. `.middleware()` is tagged with the router as its source, so a parent module lists it in `sources`.
-- `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.
+- `new RhythmRouter<I, D>(options?)`: `I` is context the router needs from the parent (checked by `mount()`), `D` is what its own `derive()` calls add; both are usually inferred. `options.name` labels failures (`type` defaults to `"router"`).
+- `.get/.post/.put/.patch/.delete(path, ...handlers)`: register a route; handlers are `(ctx, next)` middleware, and the first may be `derive()`.
+- `.use(middleware)`: router-level middleware; `derive()` extends the context type.
+- `.callback()`: the router as a `(ctx) => Promise<ctx>` function, used by `mount()` and `toFetchHandler()`.
+- `.sources` / `.parent` / `.options`: inherited from `Pipeline`.
+- `createHttpContext(request)` / `toResponse(response)` (`@rhythmjs/router/context`): the request context and its conversion to a `Response`.
+- `toFetchHandler(app)` (`@rhythmjs/router/fetch`): bridges a `Rhythm` app (or router) to a Web-standard `(Request) => Promise<Response>` handler. Errors reject.
+- `errorToResponse(error)` (`@rhythmjs/router/fetch`): maps a thrown error to a `Response`.
 
 ## Serving: your Bun.serve, no wrapper
 

package/dist/fetch.d.ts

@@ -1,4 +1,4 @@
-import type { Rhythm } from "@rhythmjs/rhythm";
+import type { Mountable } from "@rhythmjs/rhythm";
 import { type RhythmHttpContext } from "./context";
-export declare function toFetchHandler<TContext extends RhythmHttpContext>(app: Rhythm<RhythmHttpContext, any, TContext>): (request: Request) => Promise<Response>;
+export declare function toFetchHandler<I extends object = any>(app: Mountable<I> & (RhythmHttpContext extends I ? unknown : never)): (request: Request) => Promise<Response>;
 export declare function errorToResponse(error: unknown): Response;

package/dist/fetch.js

@@ -1,29 +1,54 @@
 // @bun
 import {
+  RhythmResponse2,
   STATUS_TEXT2,
-  createHttpContext2
+  createHttpContext2,
+  toResponse2
 } from "./rhythm-router-48zw4cyy.js";
 
 // src/fetch.ts
+function isUntouched(response) {
+  return response.status === 200 && response.statusText === undefined && response.body === null && [...response.headers].length === 0;
+}
 function toFetchHandler(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
-    });
+    const base = createHttpContext2(request);
+    const result = await run(base);
+    const response = result?.response ?? base.response;
+    if (isUntouched(response)) {
+      const fallback = new RhythmResponse2;
+      fallback.status = 404;
+      fallback.headers.set("content-type", "text/plain; charset=utf-8");
+      fallback.body = STATUS_TEXT2[404];
+      return toResponse2(fallback);
+    }
+    return toResponse2(response);
   };
 }
+function declaredStatus(error) {
+  const { status, statusCode } = error ?? {};
+  const declared = status ?? statusCode;
+  return Number.isInteger(declared) && declared >= 400 && declared <= 599 ? declared : undefined;
+}
+function rootCause(error) {
+  for (let current = error, depth = 0;depth < 16; depth++) {
+    if (declaredStatus(current) !== undefined)
+      return current;
+    const cause = current?.cause;
+    if (cause === undefined)
+      return current;
+    current = cause;
+  }
+  return error;
+}
 function errorToResponse(error) {
-  const declared = error.status ?? error.statusCode;
-  const status = Number.isInteger(declared) && declared >= 400 && declared <= 599 ? declared : 500;
+  const source = rootCause(error);
+  const status = declaredStatus(source) ?? 500;
   if (status >= 500)
     console.error(error);
-  const expose = status < 500 && error.expose !== false;
-  const message = expose ? error instanceof Error ? error.message : String(error) : status >= 500 ? "Internal Server Error" : STATUS_TEXT2[status] ?? `Error ${status}`;
+  const expose = status < 500 && source.expose !== false;
+  const message = expose ? source instanceof Error ? source.message : String(source) : status >= 500 ? "Internal Server Error" : STATUS_TEXT2[status] ?? `Error ${status}`;
   return new Response(message, {
     status,
     headers: { "content-type": "text/plain; charset=utf-8" }

package/dist/rhythm-router.d.ts

@@ -1,41 +1,30 @@
-import type { Condition, DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
-import { type RouterContext } from "rou3";
+import { type InferRouteParams } from "rou3";
+import { Pipeline, type ExtensionMiddleware, type Middleware, type Next, type PipelineOptions } from "@rhythmjs/rhythm";
 import type { RhythmHttpContext } from "./context";
-export interface RhythmRouterContext {
-    readonly params: Readonly<Record<string, string>>;
-}
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-export interface RhythmRouterOptions {
-    prefix?: string;
-}
-export type RouterEntry = {
-    readonly kind: "middleware";
-    readonly fn: Middleware<any>;
-} | {
-    readonly kind: "route";
-    readonly method: HttpMethod;
-    readonly path: string;
-    readonly handlers: readonly Middleware<any>[];
+export type RouterContext<T extends object> = T & RhythmHttpContext;
+export type UseContext<T extends object> = RouterContext<T> & {
+    readonly params: Record<string, string>;
+};
+export type RouteContext<T extends object, P extends string> = RouterContext<T> & {
+    params: InferRouteParams<P>;
 };
-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> {
+export type RouteHandler<T extends object, P extends string> = (ctx: RouteContext<T, P>, next: Next) => unknown | Promise<unknown>;
+export type RouteHandlers<T extends object, P extends string> = [RouteHandler<T, P>, ...RouteHandler<T, P>[]];
+export declare class RhythmRouter<I extends object = {}, D extends object = {}> extends Pipeline<UseContext<I & D>> {
     #private;
-    constructor(options?: RhythmRouterOptions);
-    get entries(): readonly RouterEntry[];
-    use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): RhythmRouter<TContext & TExtra, TInput>;
-    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;
-    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<TInput>;
+    readonly "~input"?: I;
+    constructor(options?: PipelineOptions);
+    use<U extends object>(middleware: ExtensionMiddleware<UseContext<I & D>, U>): RhythmRouter<I, D & U>;
+    use(middleware: Middleware<UseContext<I & D>>): this;
+    get<P extends string, U extends object>(path: P, middleware: ExtensionMiddleware<RouteContext<I & D, P>, U>, ...handlers: RouteHandler<I & D & U, P>[]): this;
+    get<P extends string>(path: P, ...handlers: RouteHandlers<I & D, P>): this;
+    post<P extends string, U extends object>(path: P, middleware: ExtensionMiddleware<RouteContext<I & D, P>, U>, ...handlers: RouteHandler<I & D & U, P>[]): this;
+    post<P extends string>(path: P, ...handlers: RouteHandlers<I & D, P>): this;
+    put<P extends string, U extends object>(path: P, middleware: ExtensionMiddleware<RouteContext<I & D, P>, U>, ...handlers: RouteHandler<I & D & U, P>[]): this;
+    put<P extends string>(path: P, ...handlers: RouteHandlers<I & D, P>): this;
+    patch<P extends string, U extends object>(path: P, middleware: ExtensionMiddleware<RouteContext<I & D, P>, U>, ...handlers: RouteHandler<I & D & U, P>[]): this;
+    patch<P extends string>(path: P, ...handlers: RouteHandlers<I & D, P>): this;
+    delete<P extends string, U extends object>(path: P, middleware: ExtensionMiddleware<RouteContext<I & D, P>, U>, ...handlers: RouteHandler<I & D & U, P>[]): this;
+    delete<P extends string>(path: P, ...handlers: RouteHandlers<I & D, P>): this;
+    callback(): (input: RouterContext<I>) => Promise<RouterContext<I & D>>;
 }
-export {};

package/dist/rhythm-router.js

@@ -1,11 +1,72 @@
 // @bun
+// src/rhythm-router.ts
+import { addRoute, createRouter, findRoute } from "rou3";
 import {
-  joinPath2,
-  mountedRoutes2,
-  RhythmRouter2
-} from "./rhythm-router-wmzh62d5.js";
+  Pipeline,
+  compose
+} from "@rhythmjs/rhythm";
+function decodeParams(params) {
+  const decoded = {};
+  try {
+    for (const [key, value] of Object.entries(params ?? {})) {
+      decoded[key] = decodeURIComponent(value);
+    }
+  } catch {
+    return;
+  }
+  return decoded;
+}
+
+class RhythmRouter extends Pipeline {
+  #routes = createRouter();
+  constructor(options) {
+    super({ type: "router", ...options });
+  }
+  use(middleware) {
+    return super.use(middleware);
+  }
+  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);
+  }
+  callback() {
+    const run = this.chain();
+    return async (input) => {
+      const ctx = input;
+      const match = this.#match(ctx);
+      if (!match)
+        return ctx;
+      Object.assign(ctx, { params: match.params });
+      await run(ctx, () => match.route(ctx));
+      return ctx;
+    };
+  }
+  #match(ctx) {
+    const found = findRoute(this.#routes, ctx.request.method, new URL(ctx.request.url).pathname);
+    if (!found)
+      return;
+    const params = decodeParams(found.params);
+    if (!params)
+      return;
+    return { route: found.data, params };
+  }
+  #route(method, path, handlers) {
+    const chain = compose(handlers);
+    addRoute(this.#routes, method, path, (ctx) => chain(ctx));
+    return this;
+  }
+}
 export {
-  RhythmRouter2 as RhythmRouter,
-  joinPath2 as joinPath,
-  mountedRoutes2 as mountedRoutes
+  RhythmRouter
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.16",
-  "description": "Bun-native HTTP router for the Rhythm middleware kernel, matching with rou3 and serving with Bun.serve.",
+  "version": "0.0.17",
+  "description": "Bun-native HTTP router for Rhythm: RhythmRouter plus a fetch handler for Bun.serve, matching with rou3.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
   "repository": {
@@ -27,22 +27,14 @@
       "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"
-    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "rou3": "^0.11.0",
-    "@rhythmjs/rhythm": "0.0.16"
+    "@rhythmjs/rhythm": "0.0.17",
+    "rou3": "^1.0.0"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",
@@ -53,7 +45,7 @@
     "bun": ">=1.2.0"
   },
   "scripts": {
-    "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",
+    "build": "rm -rf dist && 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",
     "typecheck": "tsc --noEmit",
     "test": "bun test"
   }

package/dist/match.d.ts

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

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

@@ -1,133 +0,0 @@
-// @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-88dtq5mx.js

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

@@ -1,53 +0,0 @@
-// @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-wmzh62d5.js

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

@@ -1,132 +0,0 @@
-// @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-yj4ffyyg.js

@@ -1,70 +0,0 @@
-// @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/serve.d.ts

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

package/dist/serve.js

@@ -1,67 +0,0 @@
-// @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 = {}) {
-  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);
-      }
-    }
-  });
-}
-export {
-  errorToResponse,
-  serve
-};

package/dist/static.d.ts

@@ -1,13 +0,0 @@
-export interface ServeStaticOptions {
-    dir: string;
-    /** URL mount point (default the site root). */
-    prefix?: string;
-    /** Directory index filename served for trailing-slash requests (default "index.html"). */
-    index?: string;
-    /** Emit `Cache-Control: max-age=<n>`, with ", immutable" appended when `immutable` is set. */
-    maxAge?: number;
-    immutable?: boolean;
-}
-/** A Response for a hit, null for a miss — chain with `??` into your app handler. */
-export type StaticHandler = (request: Request) => Promise<Response | null>;
-export declare function serveStatic(options: ServeStaticOptions): StaticHandler;

package/dist/static.js

@@ -1,67 +0,0 @@
-// @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 serveStatic(options) {
-  const prefix = normalizePrefix(options.prefix ?? "/");
-  const index = options.index ?? "index.html";
-  const cacheControl = options.maxAge === undefined ? undefined : `max-age=${options.maxAge}${options.immutable ? ", immutable" : ""}`;
-  return async (request) => {
-    if (request.method !== "GET" && request.method !== "HEAD")
-      return null;
-    let pathname;
-    try {
-      pathname = decodeURIComponent(new URL(request.url).pathname);
-    } catch {
-      return null;
-    }
-    if (prefix !== "" && pathname !== prefix && !pathname.startsWith(`${prefix}/`))
-      return null;
-    const relative = normalize(pathname.slice(prefix.length));
-    if (relative.includes("\x00") || relative === ".." || relative.startsWith(`..${sep}`))
-      return null;
-    const path = pathname.endsWith("/") ? join(options.dir, relative, index) : join(options.dir, relative);
-    const file = Bun.file(path);
-    if (!await file.exists())
-      return null;
-    const size = file.size;
-    const mtime = Math.floor(file.lastModified);
-    const etag = `W/"${size.toString(16)}-${mtime.toString(16)}"`;
-    const headers = new Headers({
-      etag,
-      "last-modified": new Date(mtime).toUTCString(),
-      "accept-ranges": "bytes"
-    });
-    if (cacheControl !== undefined)
-      headers.set("cache-control", cacheControl);
-    const ifNoneMatch = request.headers.get("if-none-match");
-    if (ifNoneMatch !== null) {
-      if (ifNoneMatch.split(/\s*,\s*/).includes(etag))
-        return new Response(null, { status: 304, headers });
-    } else {
-      const ifModifiedSince = request.headers.get("if-modified-since");
-      if (ifModifiedSince !== null && Date.parse(ifModifiedSince) >= mtime - mtime % 1000) {
-        return new Response(null, { status: 304, headers });
-      }
-    }
-    const range = request.method === "GET" ? request.headers.get("range") : null;
-    const match = range === null ? null : /^bytes=(\d*)-(\d*)$/.exec(range);
-    if (match !== null && (match[1] !== "" || match[2] !== "")) {
-      const start = match[1] === "" ? Math.max(size - Number(match[2]), 0) : Number(match[1]);
-      const end = match[1] !== "" && match[2] !== "" ? Math.min(Number(match[2]), size - 1) : size - 1;
-      if (start >= size || start > end) {
-        headers.set("content-range", `bytes */${size}`);
-        return new Response(null, { status: 416, headers });
-      }
-      headers.set("content-range", `bytes ${start}-${end}/${size}`);
-      return new Response(file.slice(start, end + 1), { status: 206, headers });
-    }
-    return new Response(file, { headers });
-  };
-}
-export {
-  serveStatic
-};