@dunx/http 3.1.3 → 3.2.1

package/README.md

@@ -1,8 +1,9 @@
 # @dunx/http
 
-`Bun.serve` adapter for [dunx](https://github.com/petarzarkov/dunx). Class-based
-controllers **and WebSocket gateways**, standard decorators, and no JavaScript
-router - Bun's native `routes` does path params and per-method dispatch in Zig.
+`Bun.serve` adapter for [dunx](https://github.com/petarzarkov/dunx): class-based
+controllers, **WebSocket gateways**, and standard decorators. There is no
+JavaScript router - Bun's native `routes` does path params and per-method
+dispatch in Zig.
 
 `Bun.serve` takes `routes` and `websocket` in one call, so both live here: one
 `listen()`, one server, one port. No `express`, no `ws`, no `socket.io`.
@@ -62,6 +63,8 @@ The guide is canonical for every row; this table is the index.
 | Middleware and guards   | One extension point, `@UseGuards`, `@Roles`, `@Public`      | [Middleware and guards](../../docs/guide/08-middleware-and-guards.md) |
 | WebSocket gateways      | `@Gateway`, handlers, `PubSub`, multi-node relay            | [WebSockets](../../docs/guide/09-websockets.md)                   |
 | Request logging         | One structured entry per request, on by default             | [Logging](../../docs/guide/13-logging.md)                         |
+| Trace context           | W3C `traceparent` adopted and propagated, on by default     | [Logging](../../docs/guide/13-logging.md)                         |
+| Metrics                 | Per-route counts and timings, off by default                | [Metrics](../../docs/guide/22-metrics.md)                         |
 | Health and draining     | `/health/live`, `/health/ready`, readiness during a rollout | [Health checks](../../docs/guide/20-health-checks.md)             |
 | Throttling              | `@Throttle`, `@SkipThrottle`, memory and Redis counters     | [Middleware and guards](../../docs/guide/08-middleware-and-guards.md) |
 | Static files            | `Bun.file` behind a mount, with a cache policy              | [Deployment](../../docs/guide/19-deployment.md)                   |
@@ -89,7 +92,14 @@ from, and it may change in any release.
 - Handlers may return a `Response`, any JSON-serialisable value, or `undefined`
   for a 204.
 - Schemas, parsers and the status resolve at boot into the same closure the
-  middleware chain folds into, so a request reads no metadata and does no lookup.
+  middleware chain folds into. A request reads no metadata and does no lookup.
+- Every request adopts W3C Trace Context, so `traceId`, `spanId`, `parentSpanId`
+  and `traceFlags` reach every line it writes and `traceresponse` goes out on the
+  response. `requestLogging: { trace: false }` removes both;
+  `{ traceResponse: false }` keeps the trace and drops the header, which is ~500
+  ns. W3C Trace Context is the only correlation id; there is no second one.
+- `metrics: true` adds per-route counts and a nanosecond histogram at +35.2 ns a
+  request, folded into the `.then` request logging already allocates.
 
 ## License
 

package/dist/{chunk-25g22350.js → chunk-3j2n1n11.js}

@@ -2,27 +2,32 @@
 // src/server/trace-context.ts
 var TRACEPARENT_HEADER = "traceparent";
 var TRACESTATE_HEADER = "tracestate";
+var TRACERESPONSE_HEADER = "traceresponse";
 var HEX_32 = /^[0-9a-f]{32}$/;
 var HEX_16 = /^[0-9a-f]{16}$/;
 var HEX_2 = /^[0-9a-f]{2}$/;
 var ZERO_TRACE = "0".repeat(32);
 var ZERO_SPAN = "0".repeat(16);
 var SAMPLED = 1;
+var DEFAULT_FLAGS = "01";
 var TRACE = Symbol.for("dunx.http.trace");
-var mintSpanId = () => Buffer.from(crypto.getRandomValues(new Uint8Array(8))).toString("hex");
+var EXPOSE = Symbol.for("dunx.http.trace.expose");
+var mint = (bytes) => crypto.getRandomValues(new Uint8Array(bytes)).toHex();
 
 class TraceContext {
-  static adopt(req, requestId) {
+  static adopt(req, expose = true) {
     const inbound = TraceContext.#parse(req.headers.get(TRACEPARENT_HEADER));
     const state = req.headers.get(TRACESTATE_HEADER);
-    const trace = {
-      traceId: inbound?.traceId ?? requestId.replaceAll("-", ""),
-      spanId: mintSpanId(),
-      ...inbound === undefined ? {} : { parentSpanId: inbound.spanId },
-      flags: inbound?.flags ?? "01",
-      ...inbound !== undefined && state !== null ? { state } : {}
+    const trace = inbound === undefined ? { traceId: mint(16), spanId: mint(8), flags: DEFAULT_FLAGS } : {
+      traceId: inbound.traceId,
+      spanId: mint(8),
+      parentSpanId: inbound.spanId,
+      flags: inbound.flags,
+      ...state === null ? {} : { state }
     };
     req[TRACE] = trace;
+    if (expose)
+      req[EXPOSE] = true;
     return trace;
   }
   static of(req) {
@@ -31,6 +36,14 @@ class TraceContext {
   static header(trace) {
     return `00-${trace.traceId}-${trace.spanId}-${trace.flags}`;
   }
+  static stamp(response, req) {
+    const traced = req;
+    const trace = traced[TRACE];
+    if (trace !== undefined && traced[EXPOSE] === true) {
+      response.headers.set(TRACERESPONSE_HEADER, TraceContext.header(trace));
+    }
+    return response;
+  }
   static sampled(trace) {
     return (Number.parseInt(trace.flags, 16) & SAMPLED) === SAMPLED;
   }
@@ -55,4 +68,4 @@ class TraceContext {
   }
 }
 
-export { TRACEPARENT_HEADER, TRACESTATE_HEADER, TraceContext };
+export { TRACEPARENT_HEADER, TRACESTATE_HEADER, TRACERESPONSE_HEADER, TraceContext };

package/dist/chunk-3nbj06q8.js

@@ -0,0 +1,174 @@
+// @bun
+import {
+  HttpStatusCode
+} from "./chunk-sz4pvqxy.js";
+
+// src/route/marker.ts
+var ROUTE = Symbol.for("dunx.route");
+var CONTROLLER = Symbol.for("dunx.controller");
+var defaultStatusFor = (method) => method === "POST" ? HttpStatusCode.CREATED : HttpStatusCode.OK;
+var resolvePath = (path) => typeof path === "function" ? path() : path;
+var markRoute = (target, meta) => {
+  Object.defineProperty(target, ROUTE, { value: meta, configurable: true });
+};
+var routeMetaOf = (value) => typeof value === "function" ? value[ROUTE] : undefined;
+var markController = (target, prefix) => {
+  Object.defineProperty(target, CONTROLLER, {
+    value: prefix,
+    configurable: true
+  });
+};
+var prefixOf = (target) => target[CONTROLLER] ?? "";
+
+// src/route/metadata.ts
+var META = Symbol.for("dunx.meta");
+var GUARDS = Symbol.for("dunx.guards");
+var metaKey = (name) => ({
+  name,
+  id: Symbol(name)
+});
+var write = (target, key, value) => {
+  const record = new Map(target[META]);
+  record.set(key.id, value);
+  Object.defineProperty(target, META, { value: record, configurable: true });
+};
+var meta = (key, value) => (target) => {
+  write(target, key, value);
+  return target;
+};
+var ROLES = metaKey("roles");
+var PUBLIC = metaKey("public");
+var HIDDEN = metaKey("hidden");
+var UNMATCHED = metaKey("unmatched");
+var Roles = (...roles) => meta(ROLES, roles);
+var Public = () => meta(PUBLIC, true);
+var ApiHidden = () => meta(HIDDEN, true);
+var UseGuards = (...guards) => (target) => {
+  const existing = target[GUARDS] ?? [];
+  const merged = Object.hasOwn(target, GUARDS) ? [...guards, ...existing] : [...existing, ...guards];
+  Object.defineProperty(target, GUARDS, {
+    value: merged,
+    configurable: true
+  });
+  return target;
+};
+var guardsOf = (target) => target[GUARDS] ?? [];
+var metaOf = (target) => target[META];
+var mergeMeta = (...targets) => {
+  const merged = new Map;
+  for (const target of targets) {
+    const record = target[META];
+    if (record)
+      for (const [id, value] of record)
+        merged.set(id, value);
+  }
+  return merged;
+};
+
+// src/route/discover.ts
+import { markedMethods } from "@dunx/core";
+var joinPath = (prefix, path) => {
+  const joined = `/${prefix}/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var discoverRoutes = (instance) => {
+  const klass = instance.constructor;
+  const prefix = prefixOf(klass);
+  const classGuards = guardsOf(klass);
+  const members = instance;
+  return markedMethods(Object.getPrototypeOf(instance), routeMetaOf).map(({ name, meta: meta2, value: marked }) => ({
+    method: meta2.method,
+    path: joinPath(prefix, resolvePath(meta2.path)),
+    controller: klass.name,
+    handlerName: name,
+    handler: members[name].bind(instance),
+    options: meta2.options,
+    meta: mergeMeta(klass, marked),
+    classMeta: metaOf(klass),
+    guards: [...classGuards, ...guardsOf(marked)]
+  }));
+};
+
+// src/ws/marker.ts
+var HANDLER = Symbol.for("dunx.ws.handler");
+var GATEWAY = Symbol.for("dunx.ws.gateway");
+var HandlerKind = Object.freeze({
+  UPGRADE: "upgrade",
+  OPEN: "open",
+  MESSAGE: "message",
+  CLOSE: "close",
+  DRAIN: "drain",
+  PING: "ping",
+  PONG: "pong"
+});
+var markHandler = (target, meta2) => {
+  Object.defineProperty(target, HANDLER, { value: meta2, configurable: true });
+};
+var handlerMetaOf = (value) => typeof value === "function" ? value[HANDLER] : undefined;
+var markGateway = (target, path) => {
+  Object.defineProperty(target, GATEWAY, { value: path, configurable: true });
+};
+var gatewayPathOf = (target) => target[GATEWAY] ?? "/";
+var isGateway = (target) => target[GATEWAY] !== undefined;
+
+// src/server/context.ts
+var EMPTY = new Map;
+var buildContext = (route) => {
+  const record = route.meta ?? EMPTY;
+  return Object.freeze({
+    controller: route.controller,
+    handler: route.handlerName,
+    method: route.method,
+    path: route.path,
+    parsesBody: route.options?.body !== undefined,
+    get: (key) => record.get(key.id)
+  });
+};
+
+// src/ws/discover.ts
+import {
+  AppError,
+  classOf,
+  markedMethods as markedMethods2
+} from "@dunx/core";
+var normalizePath = (path) => {
+  const joined = `/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : "/";
+};
+var eachHandler = (start) => markedMethods2(start, handlerMetaOf);
+var discoverGateway = (instance) => {
+  const klass = instance.constructor;
+  const members = instance;
+  return {
+    name: klass.name,
+    path: normalizePath(gatewayPathOf(klass)),
+    handlers: eachHandler(Object.getPrototypeOf(instance)).map(({ name, meta: meta2 }) => ({
+      kind: meta2.kind,
+      event: meta2.event,
+      method: name,
+      invoke: members[name].bind(instance)
+    }))
+  };
+};
+var findHandlerMethod = (ctor) => eachHandler(ctor.prototype)[0]?.name;
+var discoverGateways = (modules, resolve) => {
+  const discovered = [];
+  for (const module of modules) {
+    for (const entry of module.options.providers ?? []) {
+      const candidate = classOf(entry);
+      if (!candidate)
+        continue;
+      if (isGateway(candidate.ctor)) {
+        discovered.push(discoverGateway(resolve(candidate.token)));
+        continue;
+      }
+      const orphan = findHandlerMethod(candidate.ctor);
+      if (orphan !== undefined) {
+        throw new AppError(`${candidate.ctor.name}.${orphan}() is a websocket handler, but ` + `${candidate.ctor.name} is not a gateway. Decorate the class with ` + "@Gateway(path), or drop the handler decorator.");
+      }
+    }
+  }
+  return discovered;
+};
+
+export { defaultStatusFor, markRoute, markController, metaKey, meta, ROLES, PUBLIC, HIDDEN, UNMATCHED, Roles, Public, ApiHidden, UseGuards, metaOf, mergeMeta, joinPath, discoverRoutes, HandlerKind, markHandler, markGateway, isGateway, discoverGateway, discoverGateways, buildContext };

package/dist/client/options.d.ts

@@ -16,21 +16,17 @@ export interface HttpClientOptionsInit {
     /** Sent on every request, under anything a call sets itself. */
     readonly headers?: Readonly<Record<string, string>>;
     readonly retry?: RetryOptions<unknown>;
-    /**
-     * Forward the inbound request id to the upstream, so one trace spans both
-     * services. `true` uses `x-request-id`; a string names the header. Read from
-     * `RequestContext`, so it only carries when there is a request in scope.
-     *
-     * @default true
-     */
-    readonly propagateRequestId?: boolean | string;
     /**
      * Forward W3C Trace Context upstream as `traceparent`, so the callee's spans
-     * join this request's trace.
+     * join this request's trace and one trace spans both services.
      *
      * Read from `RequestContext`, so it only carries when a trace is in scope -
-     * which means `requestLogging: { trace: true }` on the inbound side. With that
-     * off there is nothing to send and this costs one property read.
+     * which the inbound side puts there unless `requestLogging: { trace: false }`
+     * removed it. With that off there is nothing to send and this costs one
+     * property read.
+     *
+     * The caller's `traceFlags` are sent as they arrived, so a trace an upstream
+     * sampler declined is not re-sampled at this hop.
      *
      * @default true
      */
@@ -67,7 +63,6 @@ export interface HttpClientOptionsInit {
     /** How many redirects to follow before rejecting. */
     readonly maxRedirects?: number;
 }
-export declare const DEFAULT_REQUEST_ID_HEADER = "x-request-id";
 /**
  * The resolved options, as a class so it is both the injection token and the type
  * a factory annotates - the same trick `RedisOptions` and `ConfigService` use.
@@ -77,7 +72,6 @@ export declare class HttpClientOptions {
     readonly timeoutMs: number;
     readonly headers: Readonly<Record<string, string>>;
     readonly retry: RetryOptions<unknown>;
-    readonly requestIdHeader: string | undefined;
     readonly propagateTrace: boolean;
     readonly name: string | undefined;
     readonly fetchOptions: Readonly<Record<string, unknown>>;

package/dist/client/service.d.ts

@@ -42,8 +42,8 @@ export interface RequestConfig<TRequest = unknown, TResponse = unknown> {
 }
 type BaseOptions<TRequest, TResponse> = Omit<RequestConfig<TRequest, TResponse>, 'method' | 'url' | 'payload'>;
 /**
- * A `fetch` client with a per-request timeout, retry with backoff, request-id
- * propagation and one log line per call. `fetch` and nothing else, so there is no
+ * A `fetch` client with a per-request timeout, retry with backoff, W3C Trace
+ * Context propagation and one log line per call. `fetch` and nothing else, so there is no
  * client dependency; what it adds is the parts every caller otherwise
  * reimplements - the timeout, the retry policy, `Retry-After`, url building, and
  * a failure that says which call failed.

package/dist/client.d.ts

@@ -6,7 +6,7 @@
  * `@dunx/http` does not load any of this.
  */
 export { FetchError, FetchTransportError } from './client/errors.js';
-export { DEFAULT_REQUEST_ID_HEADER, HttpClientOptions, type HttpClientOptionsInit, } from './client/options.js';
+export { HttpClientOptions, type HttpClientOptionsInit, } from './client/options.js';
 export type { BackoffOptions, RetryOptions } from './client/retry.js';
 export { httpClient, HttpModule, type ClientTarget } from './client/module.js';
 export { HttpService, type HeaderFactory, type RequestConfig, type RequestMethod, } from './client/service.js';

package/dist/client.js

@@ -1,25 +1,53 @@
 // @bun
 import {
   TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
   TraceContext
-} from "./chunk-25g22350.js";
+} from "./chunk-3j2n1n11.js";
 import {
-  FetchError,
-  FetchTransportError,
-  executeWithRetry,
-  isJsonBody,
-  safeStringify
-} from "./chunk-7xrtwbx3.js";
-import"./chunk-sz4pvqxy.js";
-// src/client/options.ts
-var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
+  HttpStatusCode
+} from "./chunk-sz4pvqxy.js";
+
+// src/client/errors.ts
+import { AppError } from "@dunx/core";
 
+class FetchError extends AppError {
+  status;
+  statusText;
+  body;
+  response;
+  name = "FetchError";
+  constructor(status, statusText, body, response) {
+    super(`HTTP ${status} ${statusText} from ${response.method} ${response.url}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.response = response;
+  }
+}
+Object.defineProperty(FetchError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "override readonly status: number" }, { unresolved: "readonly statusText: string" }, { unresolved: "readonly body: unknown" }, { unresolved: `readonly response: {
+      readonly method: string;
+      readonly url: string;
+      readonly headers: Headers;
+    }` }] });
+
+class FetchTransportError extends AppError {
+  response;
+  aborted;
+  name = "FetchTransportError";
+  constructor(response, aborted, options) {
+    super(`${response.method} ${response.url} failed: ${aborted ? "aborted" : "transport error"}`, options);
+    this.response = response;
+    this.aborted = aborted;
+  }
+}
+Object.defineProperty(FetchTransportError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "readonly response: { readonly method: string; readonly url: string }" }, { unresolved: "readonly aborted: boolean" }, ErrorOptions] });
+// src/client/options.ts
 class HttpClientOptions {
   baseUrl;
   timeoutMs;
   headers;
   retry;
-  requestIdHeader;
   propagateTrace;
   name;
   fetchOptions;
@@ -30,8 +58,6 @@ class HttpClientOptions {
     this.retry = init.retry ?? {};
     this.name = init.name;
     this.propagateTrace = init.propagateTrace ?? true;
-    const propagate = init.propagateRequestId ?? true;
-    this.requestIdHeader = propagate === false ? undefined : propagate === true ? DEFAULT_REQUEST_ID_HEADER : propagate;
     this.fetchOptions = Object.fromEntries([
       ["proxy", init.proxy],
       ["tls", init.tls],
@@ -56,6 +82,91 @@ import {
 // src/client/service.ts
 import { Logger, RequestContext } from "@dunx/core";
 import { UrlHelper } from "@arkv/shared";
+
+// src/client/json.ts
+var safeStringify = (value) => {
+  const seen = new WeakSet;
+  return JSON.stringify(value, (_key, entry) => {
+    if (typeof entry === "object" && entry !== null) {
+      if (seen.has(entry))
+        return "[Circular]";
+      seen.add(entry);
+    }
+    return entry;
+  });
+};
+var isJsonBody = (payload) => {
+  if (payload === null || payload === undefined)
+    return false;
+  if (typeof payload !== "object")
+    return typeof payload !== "string";
+  return !(payload instanceof FormData || payload instanceof URLSearchParams || payload instanceof Blob || payload instanceof ArrayBuffer || payload instanceof ReadableStream || ArrayBuffer.isView(payload));
+};
+
+// src/client/retry.ts
+var uniform = () => {
+  const buffer = new Uint32Array(1);
+  crypto.getRandomValues(buffer);
+  return (buffer[0] ?? 0) / 2 ** 32;
+};
+var backoffDelay = (attempt, { baseMs, power = 2, jitterMs = 1000, maxMs = 30000 }) => Math.min(baseMs * power ** attempt + uniform() * jitterMs, maxMs);
+var retryAfterMs = (headers, now = Date.now()) => {
+  const header = headers.get("retry-after");
+  if (header === null)
+    return;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const at = Date.parse(header);
+  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
+};
+var isRetryableStatus = (status) => status >= HttpStatusCode.INTERNAL_SERVER_ERROR || status === HttpStatusCode.REQUEST_TIMEOUT || status === HttpStatusCode.TOO_MANY_REQUESTS;
+var decide = (error, attempt, options) => {
+  const {
+    retryDelayMs = 1000,
+    backoff,
+    shouldRetryOnStatus = isRetryableStatus,
+    respectRetryAfter = true
+  } = options;
+  const computed = backoffDelay(attempt, { baseMs: retryDelayMs, ...backoff });
+  if (error instanceof FetchTransportError) {
+    return { retry: !error.aborted, delayMs: computed };
+  }
+  if (error instanceof FetchError) {
+    if (!shouldRetryOnStatus(error.status))
+      return { retry: false, delayMs: 0 };
+    const asked = respectRetryAfter ? retryAfterMs(error.response.headers) : undefined;
+    const maxMs = backoff?.maxMs ?? 30000;
+    return {
+      retry: true,
+      delayMs: asked === undefined ? computed : Math.min(asked, maxMs)
+    };
+  }
+  return { retry: true, delayMs: computed };
+};
+var executeWithRetry = async (operation, options = {}) => {
+  const { maxRetries = 3, onAttempt, onError, onSuccess } = options;
+  let lastError;
+  for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
+    onAttempt?.(attempt + 1, attempt > 0);
+    try {
+      const result = await operation();
+      onSuccess?.(result, attempt + 1);
+      return result;
+    } catch (error) {
+      lastError = error;
+      const { retry, delayMs } = decide(error, attempt, options);
+      const willRetry = retry && attempt < maxRetries;
+      onError?.(error, attempt + 1, willRetry);
+      if (!willRetry)
+        throw error;
+      await Bun.sleep(delayMs);
+    }
+  }
+  throw lastError;
+};
+
+// src/client/service.ts
 class HttpService extends UrlHelper {
   options;
   logger;
@@ -213,19 +324,18 @@ class HttpService extends UrlHelper {
     return { body: serialised, serialised, json: true };
   }
   async send(config, url, body, serialised, accept = "application/json") {
-    const requestId = this.options.requestIdHeader === undefined ? undefined : this.requestContext.getContext().requestId;
     const trace = this.options.propagateTrace ? this.requestContext.getContext() : undefined;
     const headers = {
       accept,
       ...serialised === "" ? {} : { "content-type": "application/json" },
       ...this.options.headers,
-      ...requestId === undefined || this.options.requestIdHeader === undefined ? {} : { [this.options.requestIdHeader]: requestId },
       ...typeof trace?.traceId === "string" && typeof trace.spanId === "string" ? {
         [TRACEPARENT_HEADER]: TraceContext.header({
           traceId: trace.traceId,
           spanId: trace.spanId,
-          flags: "01"
-        })
+          flags: typeof trace.traceFlags === "string" ? trace.traceFlags : "01"
+        }),
+        ...typeof trace.traceState === "string" ? { [TRACESTATE_HEADER]: trace.traceState } : {}
       } : {},
       ...config.headerFactory?.({
         timestamp: Math.floor(Date.now() / 1000),
@@ -344,7 +454,6 @@ class HttpModule {
   }
 }
 export {
-  DEFAULT_REQUEST_ID_HEADER,
   FetchError,
   FetchTransportError,
   HttpClientOptions,

package/dist/index.d.ts

@@ -8,9 +8,9 @@ export type { CorsOptions, CorsOrigin } from './server/cors.js';
 export { defaultErrorMapper, ErrorFilter, errorMapper, HttpError, ValidationError, type ErrorHandler, type ErrorMapper, type HttpErrorOptions, type InputSource, type ValidationIssue, } from './server/errors.js';
 export { HttpFactory, type HttpApp, type HttpOptions, } from './server/factory.js';
 export { DefaultHttpOptions, HttpOptionsProvider, } from './server/options-provider.js';
-export { REQUEST_ID_HEADER } from './server/request-id.js';
-export { TRACEPARENT_HEADER, TRACESTATE_HEADER, TraceContext, type Trace, } from './server/trace-context.js';
+export { TRACEPARENT_HEADER, TRACERESPONSE_HEADER, TRACESTATE_HEADER, TraceContext, type Trace, } from './server/trace-context.js';
 export { RequestLoggingMiddleware, type RequestLoggingOptions, } from './server/request-logging.js';
+export { MetricsMiddleware, RequestMetrics, UNMATCHED_ROUTE, type HttpStatsReport, type RouteStats, } from './server/metrics.js';
 export type { Middleware, Next, RouteHandler } from './server/middleware.js';
 export type { AppSettings } from './server/settings.js';
 export { StaticFiles } from './static/files.js';