@dunx/http 2.4.0 → 2.5.0

package/dist/index.js

@@ -1,17 +1,21 @@
 // @bun
 import {
   HttpStatusCode,
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
+  TraceContext,
   __decorateElement,
   __decoratorMetadata,
   __decoratorStart,
   __privateAdd,
   __privateGet,
   __runInitializers
-} from "./chunk-sz4pvqxy.js";
+} from "./chunk-jh7jk0bn.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 });
@@ -1036,6 +1040,7 @@ class RequestLoggingMiddleware {
   #ignorePrefix;
   #correlateIgnored;
   #correlate;
+  #trace;
   constructor(logger, context, options = {}) {
     this.logger = logger;
     this.context = context;
@@ -1046,6 +1051,7 @@ class RequestLoggingMiddleware {
     this.#ignorePrefix = options.ignorePrefix ?? [];
     this.#correlateIgnored = options.correlateIgnored ?? false;
     this.#correlate = options.correlate ?? true;
+    this.#trace = options.trace ?? false;
   }
   #ignored(path) {
     if (this.#ignore.size > 0 && this.#ignore.has(path))
@@ -1071,6 +1077,14 @@ class RequestLoggingMiddleware {
       flow: "http",
       context: `${ctx.controller}.${ctx.handler}`
     };
+    if (this.#trace) {
+      const trace = TraceContext.adopt(req, requestId);
+      scope.traceId = trace.traceId;
+      scope.spanId = trace.spanId;
+      if (trace.parentSpanId !== undefined) {
+        scope.parentSpanId = trace.parentSpanId;
+      }
+    }
     return this.#correlate ? this.context.runWithContext(scope, () => this.#begin(req, ctx, url, mark, path, requestId, started, next, undefined)) : this.#begin(req, ctx, url, mark, path, requestId, started, next, scope);
   }
   #begin(req, ctx, url, mark, path, requestId, started, next, scope) {
@@ -1319,7 +1333,7 @@ var toResponse = (value, status) => {
   }
   return Response.json(value, { status });
 };
-var statusFor = (route) => route.options?.status ?? (route.method === "POST" ? HttpStatusCode.CREATED : HttpStatusCode.OK);
+var statusFor = (route) => route.options?.status ?? defaultStatusFor(route.method);
 var assertNoCollisions = (discovered) => {
   const owners = new Map;
   for (const route of discovered) {
@@ -1810,6 +1824,274 @@ StaticModule = __decorateElement(_init, 0, "StaticModule", _dec, StaticModule);
 __runInitializers(_init, 1, StaticModule);
 __decoratorMetadata(_init, StaticModule);
 let _StaticModule = StaticModule;
+// src/compression/negotiate.ts
+var quality = (params) => {
+  for (const param of params) {
+    const [key, value] = param.split("=");
+    if (key?.trim().toLowerCase() !== "q")
+      continue;
+    const q = Number.parseFloat(value ?? "");
+    return Number.isFinite(q) && q >= 0 && q <= 1 ? q : 1;
+  }
+  return 1;
+};
+var negotiate = (header, offered) => {
+  if (header === null)
+    return;
+  const accepted = new Map;
+  for (const element of header.split(",")) {
+    const [name, ...params] = element.split(";");
+    const token = name?.trim().toLowerCase();
+    if (token === undefined || token === "")
+      continue;
+    accepted.set(token, quality(params));
+  }
+  const wildcard = accepted.get("*");
+  let best;
+  let bestQuality = 0;
+  for (const encoding of offered) {
+    const q = accepted.get(encoding) ?? wildcard ?? 0;
+    if (q > bestQuality) {
+      best = encoding;
+      bestQuality = q;
+    }
+  }
+  return best;
+};
+
+// src/compression/options.ts
+var CompressionEncoding = Object.freeze({
+  ZSTD: "zstd",
+  GZIP: "gzip"
+});
+var COMPRESSIBLE = new Set([
+  "application/graphql",
+  "application/graphql-response+json",
+  "application/javascript",
+  "application/json",
+  "application/manifest+json",
+  "application/wasm",
+  "application/x-javascript",
+  "application/x-ndjson",
+  "application/xml",
+  "image/svg+xml"
+]);
+var isCompressibleType = (contentType) => {
+  if (contentType === null)
+    return false;
+  const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (type.startsWith("text/"))
+    return true;
+  if (type.endsWith("+json") || type.endsWith("+xml"))
+    return true;
+  return COMPRESSIBLE.has(type);
+};
+var encodable = (encoding) => {
+  const sync = encoding === CompressionEncoding.ZSTD ? Bun.zstdCompressSync : Bun.gzipSync;
+  if (typeof sync !== "function")
+    return false;
+  try {
+    new CompressionStream(encoding);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+class CompressionOptions {
+  encodings;
+  threshold;
+  filter;
+  constructor(init = {}) {
+    this.encodings = init.encodings ?? [
+      CompressionEncoding.ZSTD,
+      CompressionEncoding.GZIP
+    ];
+    const missing = this.encodings.filter((encoding) => !encodable(encoding));
+    if (missing.length > 0) {
+      throw new Error(`Bun ${Bun.version} cannot encode ${missing.join(", ")}. ` + "Pass `encodings` without it, or upgrade Bun.");
+    }
+    this.threshold = init.threshold ?? 1024;
+    this.filter = init.filter ?? isCompressibleType;
+  }
+}
+Object.defineProperty(CompressionOptions, Symbol.for("dunx.deps"), {
+  value: () => [{ unresolved: "init: CompressionOptionsInit = {}" }]
+});
+
+// src/compression/compression.ts
+var BODYLESS = new Set([204, 205, 304]);
+var BUFFER_LIMIT = 1024 * 1024;
+var buffer = async (body, limit) => {
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+    size += value.byteLength;
+    if (size > limit) {
+      return {
+        rest: new ReadableStream({
+          start: (controller) => {
+            for (const chunk of chunks)
+              controller.enqueue(chunk);
+          },
+          pull: async (controller) => {
+            const next = await reader.read();
+            if (next.done)
+              controller.close();
+            else
+              controller.enqueue(next.value);
+          },
+          cancel: (reason) => reader.cancel(reason)
+        })
+      };
+    }
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { bytes };
+};
+var declaredLength = (headers) => {
+  const raw = headers.get("content-length");
+  if (raw === null)
+    return;
+  const length = Number.parseInt(raw, 10);
+  return Number.isFinite(length) ? length : undefined;
+};
+var weakenETag = (headers) => {
+  const etag = headers.get("etag");
+  if (etag !== null && !etag.startsWith("W/"))
+    headers.set("etag", `W/${etag}`);
+};
+var varyOnEncoding = (headers) => {
+  const existing = headers.get("vary");
+  if (existing === null) {
+    headers.set("vary", "accept-encoding");
+    return;
+  }
+  if (existing.trim() === "*")
+    return;
+  const listed = existing.split(",").some((field) => field.trim().toLowerCase() === "accept-encoding");
+  if (!listed)
+    headers.set("vary", `${existing}, accept-encoding`);
+};
+var encodeSync = (encoding, data) => {
+  switch (encoding) {
+    case CompressionEncoding.ZSTD:
+      return Bun.zstdCompressSync(data);
+    case CompressionEncoding.GZIP:
+      return Bun.gzipSync(data);
+  }
+};
+
+class Compression {
+  #options;
+  constructor(options) {
+    this.#options = options;
+  }
+  #considers(res) {
+    if (BODYLESS.has(res.status) || res.status === 206)
+      return false;
+    if (res.headers.has("content-encoding"))
+      return false;
+    if (res.headers.get("cache-control")?.includes("no-transform") === true) {
+      return false;
+    }
+    return this.#options.filter(res.headers.get("content-type"));
+  }
+  async handle(req, _ctx, next) {
+    const res = await next();
+    const body = res.body;
+    if (body === null || !this.#considers(res))
+      return res;
+    varyOnEncoding(res.headers);
+    const encoding = negotiate(req.headers.get("accept-encoding"), this.#options.encodings);
+    if (encoding === undefined)
+      return res;
+    const declared = declaredLength(res.headers);
+    if (declared !== undefined && declared < this.#options.threshold)
+      return res;
+    const headers = new Headers(res.headers);
+    headers.set("content-encoding", encoding);
+    weakenETag(headers);
+    const source = declared !== undefined && declared > BUFFER_LIMIT ? { rest: body } : await buffer(body, BUFFER_LIMIT);
+    if ("rest" in source) {
+      headers.delete("content-length");
+      return new Response(source.rest.pipeThrough(new CompressionStream(encoding)), { status: res.status, statusText: res.statusText, headers });
+    }
+    if (source.bytes.byteLength < this.#options.threshold) {
+      const passthrough = new Headers(res.headers);
+      passthrough.set("content-length", String(source.bytes.byteLength));
+      return new Response(source.bytes, {
+        status: res.status,
+        statusText: res.statusText,
+        headers: passthrough
+      });
+    }
+    const encoded = encodeSync(encoding, source.bytes);
+    headers.set("content-length", String(encoded.byteLength));
+    return new Response(encoded, {
+      status: res.status,
+      statusText: res.statusText,
+      headers
+    });
+  }
+}
+Object.defineProperty(Compression, Symbol.for("dunx.deps"), {
+  value: () => [CompressionOptions]
+});
+// src/compression/module.ts
+import {
+  Module as Module2,
+  provide as provide3
+} from "@dunx/core";
+var middleware = () => provide3(Compression, {
+  useFactory: (options) => new Compression(options),
+  inject: [CompressionOptions]
+});
+var _dec = [
+  Module2({})
+];
+var _init = __decoratorStart(undefined);
+
+class CompressionModule {
+  static forRoot(init = {}) {
+    return {
+      module: CompressionModule,
+      exports: [CompressionOptions, Compression],
+      providers: [
+        provide3(CompressionOptions, { useValue: new CompressionOptions(init) }),
+        middleware()
+      ]
+    };
+  }
+  static forRootAsync(config) {
+    return {
+      module: CompressionModule,
+      ...config.imports && { imports: config.imports },
+      exports: [CompressionOptions, Compression],
+      providers: [
+        provide3(CompressionOptions, {
+          useFactory: async (...deps) => new CompressionOptions(await config.useFactory(...deps)),
+          inject: config.inject ?? []
+        }),
+        middleware()
+      ]
+    };
+  }
+}
+CompressionModule = __decorateElement(_init, 0, "CompressionModule", _dec, CompressionModule);
+__runInitializers(_init, 1, CompressionModule);
+__decoratorMetadata(_init, CompressionModule);
+let _CompressionModule = CompressionModule;
 // src/throttle/decorators.ts
 var THROTTLE = metaKey("throttle");
 var SKIP_THROTTLE = metaKey("skip-throttle");
@@ -1995,20 +2277,20 @@ Object.defineProperty(ThrottleGuard, Symbol.for("dunx.deps"), {
 // src/throttle/module.ts
 import {
   Logger as Logger6,
-  Module as Module2,
-  provide as provide3
+  Module as Module3,
+  provide as provide4
 } from "@dunx/core";
 var EXPORTS = [ThrottleOptions, ThrottleStore, ThrottleGuard];
-var guard = () => provide3(ThrottleGuard, {
+var guard = () => provide4(ThrottleGuard, {
   useFactory: (options, store, address, logger) => new ThrottleGuard(options, store, address, logger),
   inject: [ThrottleOptions, ThrottleStore, ClientAddress, Logger6]
 });
-var store = () => provide3(ThrottleStore, {
+var store = () => provide4(ThrottleStore, {
   useFactory: (options) => options.store ?? new MemoryThrottleStore,
   inject: [ThrottleOptions]
 });
 var _dec = [
-  Module2({})
+  Module3({})
 ];
 var _init = __decoratorStart(undefined);
 
@@ -2019,7 +2301,7 @@ class ThrottleModule {
       global: true,
       exports: EXPORTS,
       providers: [
-        provide3(ThrottleOptions, { useValue: new ThrottleOptions(init) }),
+        provide4(ThrottleOptions, { useValue: new ThrottleOptions(init) }),
         store(),
         guard()
       ]
@@ -2032,7 +2314,7 @@ class ThrottleModule {
       ...config.imports && { imports: config.imports },
       exports: EXPORTS,
       providers: [
-        provide3(ThrottleOptions, {
+        provide4(ThrottleOptions, {
           useFactory: async (...deps) => new ThrottleOptions(await config.useFactory(...deps)),
           inject: config.inject ?? []
         }),
@@ -2471,8 +2753,8 @@ Object.defineProperty(DiskIndicator, Symbol.for("dunx.deps"), {
 });
 // src/health/module.ts
 import {
-  Module as Module3,
-  provide as provide4
+  Module as Module4,
+  provide as provide5
 } from "@dunx/core";
 
 // src/health/readiness.ts
@@ -2519,15 +2801,15 @@ Object.defineProperty(Readiness, Symbol.for("dunx.deps"), {
 // src/health/module.ts
 var wiring = (options) => [
   ...options,
-  provide4(ReadinessOptions, {
+  provide5(ReadinessOptions, {
     useFactory: (opts) => new ReadinessOptions({ drainDelayMs: opts.drainDelayMs }),
     inject: [HealthOptions]
   }),
-  provide4(Readiness, {
+  provide5(Readiness, {
     useFactory: (opts) => new Readiness(opts),
     inject: [ReadinessOptions]
   }),
-  provide4(HealthRegistry, {
+  provide5(HealthRegistry, {
     useFactory: (opts, readiness) => new HealthRegistry(opts, readiness),
     inject: [HealthOptions, Readiness]
   })
@@ -2535,7 +2817,7 @@ var wiring = (options) => [
 var surface = [HealthOptions, HealthRegistry, Readiness];
 var controllerFor = (documented) => documented ? HealthController : HiddenHealthController;
 var _dec = [
-  Module3({})
+  Module4({})
 ];
 var _init = __decoratorStart(undefined);
 
@@ -2546,7 +2828,7 @@ class HealthModule {
       module: HealthModule,
       ...options.routes ? { controllers: [controllerFor(options.documented)] } : {},
       exports: surface,
-      providers: wiring([provide4(HealthOptions, { useValue: options })])
+      providers: wiring([provide5(HealthOptions, { useValue: options })])
     };
   }
   static forRootAsync(config) {
@@ -2556,7 +2838,7 @@ class HealthModule {
       ...config.routes ?? true ? { controllers: [controllerFor(config.documented ?? true)] } : {},
       exports: surface,
       providers: wiring([
-        provide4(HealthOptions, {
+        provide5(HealthOptions, {
           useFactory: async (...deps) => new HealthOptions(await config.useFactory(...deps)),
           inject: config.inject ?? []
         })
@@ -2571,6 +2853,10 @@ let _HealthModule = HealthModule;
 export {
   ApiHidden,
   ClientAddress,
+  Compression,
+  CompressionEncoding,
+  CompressionModule,
+  CompressionOptions,
   Controller,
   DEFAULT_RELAY_CHANNEL,
   DatabaseIndicator,
@@ -2626,11 +2912,14 @@ export {
   StaticModule,
   StaticOptions,
   THROTTLE,
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
   Throttle,
   ThrottleGuard,
   ThrottleModule,
   ThrottleOptions,
   ThrottleStore,
+  TraceContext,
   UNMATCHED,
   UseGuards,
   ValidationError,
@@ -2647,6 +2936,7 @@ export {
   decodeRelay,
   defaultErrorMapper,
   defaultRelayUrl,
+  defaultStatusFor,
   discoverGateway,
   discoverGateways,
   discoverRoutes,
@@ -2655,6 +2945,7 @@ export {
   errorMapper,
   gatewaysOf,
   guardsOf,
+  isCompressibleType,
   isErrorFilter,
   isGateway,
   joinPath,
@@ -2662,6 +2953,7 @@ export {
   meta,
   metaKey,
   metaOf,
+  negotiate,
   normalizePath,
   normalizePrefix,
   observe,
@@ -2671,6 +2963,3 @@ export {
   withCors,
   withUpgradeRoutes
 };
-
-//# debugId=1A8278039B82BC0664756E2164756E21
-//# sourceMappingURL=index.js.map

package/dist/route/decorators.d.ts

@@ -1,10 +1,10 @@
 import { type RoutePath } from './marker.js';
-import type { Input, RouteSchemas } from './schema.js';
+import type { Input, Returns, RouteSchemas } from './schema.js';
 type ControllerTarget = abstract new (...args: never[]) => object;
 export declare const Controller: (prefix?: string) => <T extends ControllerTarget>(target: T) => T;
-export declare const Get: <const O extends RouteSchemas>(path?: RoutePath, options?: O) => <M extends (input: Input<O>) => unknown>(value: M, _context: ClassMethodDecoratorContext) => M;
-export declare const Post: <const O extends RouteSchemas>(path?: RoutePath, options?: O) => <M extends (input: Input<O>) => unknown>(value: M, _context: ClassMethodDecoratorContext) => M;
-export declare const Put: <const O extends RouteSchemas>(path?: RoutePath, options?: O) => <M extends (input: Input<O>) => unknown>(value: M, _context: ClassMethodDecoratorContext) => M;
-export declare const Patch: <const O extends RouteSchemas>(path?: RoutePath, options?: O) => <M extends (input: Input<O>) => unknown>(value: M, _context: ClassMethodDecoratorContext) => M;
-export declare const Delete: <const O extends RouteSchemas>(path?: RoutePath, options?: O) => <M extends (input: Input<O>) => unknown>(value: M, _context: ClassMethodDecoratorContext) => M;
+export declare const Get: <const O extends RouteSchemas>(path?: RoutePath, options?: O | undefined) => <H extends (input: Input<O>) => Returns<O, "GET">>(value: H, _context: ClassMethodDecoratorContext) => H;
+export declare const Post: <const O extends RouteSchemas>(path?: RoutePath, options?: O | undefined) => <H extends (input: Input<O>) => Returns<O, "POST">>(value: H, _context: ClassMethodDecoratorContext) => H;
+export declare const Put: <const O extends RouteSchemas>(path?: RoutePath, options?: O | undefined) => <H extends (input: Input<O>) => Returns<O, "PUT">>(value: H, _context: ClassMethodDecoratorContext) => H;
+export declare const Patch: <const O extends RouteSchemas>(path?: RoutePath, options?: O | undefined) => <H extends (input: Input<O>) => Returns<O, "PATCH">>(value: H, _context: ClassMethodDecoratorContext) => H;
+export declare const Delete: <const O extends RouteSchemas>(path?: RoutePath, options?: O | undefined) => <H extends (input: Input<O>) => Returns<O, "DELETE">>(value: H, _context: ClassMethodDecoratorContext) => H;
 export {};

package/dist/route/marker.d.ts

@@ -1,5 +1,18 @@
+import { HttpStatusCode } from '../server/status.js';
 import type { RouteSchemas } from './schema.js';
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * The success status a route answers with when `options.status` is absent.
+ * `buildRoutes` and `@dunx/openapi`'s `statusOf` both read it, so the rule is
+ * stated once rather than in each of them.
+ */
+export declare const defaultStatusFor: (method: HttpMethod) => number;
+/**
+ * The type-level twin of {@link defaultStatusFor}, derived from the same constants
+ * so the two cannot drift. `Returns` needs it to know which `response` entry a
+ * handler is being held to.
+ */
+export type DefaultStatus<M extends HttpMethod> = M extends 'POST' ? typeof HttpStatusCode.CREATED : typeof HttpStatusCode.OK;
 /**
  * A literal path, or a thunk read at **discovery** rather than at decoration.
  *

package/dist/route/schema.d.ts

@@ -1,4 +1,5 @@
 import type { BunRequest } from 'bun';
+import type { DefaultStatus, HttpMethod } from './marker.js';
 /**
  * Standard Schema v1, restated rather than depended on. The spec is an
  * *interface*, not a runtime: `@standard-schema/spec` ships nothing but these
@@ -65,11 +66,13 @@ export interface RouteSchemas {
      * } as const satisfies RouteSchemas;
      * ```
      *
-     * **Never validated.** It documents the response; it does not enforce it.
-     * Running a validation pass over every response body would be a per-request
-     * cost paid for a documentation feature, which is the wrong trade - the
-     * handler's own return type is what checks the answer, at compile time and for
-     * free. Nothing in the request path reads this key.
+     * **Never validated at runtime, checked at compile time.** Running a validation
+     * pass over every response body would be a per-request cost paid for a
+     * documentation feature. The handler's own return type carries the check
+     * instead: the verb decorators constrain it against the entry for the success
+     * status, so a handler answering with a different shape is a `TS1241` naming
+     * the mismatched property. See {@link Returns}. Nothing in the request path
+     * reads this key.
      *
      * A plain {@link JsonSchema} is accepted here too, and only here: a JSON Schema
      * needs no conversion, so documenting a response costs no validator. `$id` names
@@ -83,8 +86,10 @@ export interface RouteSchemas {
      * }
      * ```
      */
-    readonly response?: Readonly<Record<number, StandardSchemaV1 | JsonSchema>>;
+    readonly response?: ResponseMap;
 }
+/** `response` keyed by status code. Named so {@link Returns} can constrain it. */
+export type ResponseMap = Readonly<Record<number, StandardSchemaV1 | JsonSchema>>;
 /**
  * The handler's parameter type, derived from its own options object. It has to be
  * written out - a standard method decorator can *check* a parameter's type but
@@ -118,6 +123,58 @@ export type Input<O extends RouteSchemas> = {
 } ? {
     readonly params: InferOutput<P>;
 } : unknown);
+/**
+ * The status a handler's return type is held to: an explicit `options.status`,
+ * else the verb's default. Widened to `number` without `as const`, which is what
+ * turns the check off rather than misapplying it.
+ */
+type SuccessStatus<O extends RouteSchemas, M extends HttpMethod> = O extends {
+    status: infer S extends number;
+} ? S : DefaultStatus<M>;
+/**
+ * A plain {@link JsonSchema} carries no type to infer, so it becomes `unknown` and
+ * absorbs whatever the handler returns. That is the escape hatch for a response
+ * whose shape no schema value describes.
+ */
+type Declared<S> = [InferOutput<S>] extends [never] ? unknown : Serialised<InferOutput<S>>;
+/**
+ * The declared shape as JSON will present it, which is the same shape with every
+ * array made readonly.
+ *
+ * `z.array()` infers a mutable `T[]`, and `readonly T[]` is not assignable to it -
+ * so a repository method returning `readonly User[]`, the correct signature for
+ * something that must not be mutated, would fail against a document it satisfies.
+ * Mutability does not survive `Response.json`, so it is not part of the contract.
+ *
+ * Only arrays need the rewrite; TypeScript already ignores a property's `readonly`
+ * modifier when checking assignability. The object branch is how nested arrays are
+ * reached, and functions are returned untouched because mapping over one would
+ * discard its call signature.
+ */
+type Serialised<T> = T extends readonly (infer E)[] ? readonly Serialised<E>[] : T extends (...args: never[]) => unknown ? T : T extends object ? {
+    readonly [K in keyof T]: Serialised<T[K]>;
+} : T;
+/**
+ * What a handler may return, given its own options object and its verb.
+ *
+ * A route decorator can *check* a handler's type but cannot *infer* it
+ * (docs/architecture/constraints.md), and that cuts both ways: this is the return
+ * half of the same guarantee `Input<O>` gives the parameter. Declaring
+ * `response: { 200: User }` stops being documentation a handler can contradict.
+ *
+ * `Response` is always allowed - it is the escape hatch `buildRoutes` passes
+ * through untouched. So is a promise of either. Nothing is checked when the
+ * success status has no `response` entry.
+ */
+export type Returns<O extends RouteSchemas, M extends HttpMethod> = SuccessBody<O, M> | Response | Promise<SuccessBody<O, M> | Response>;
+/**
+ * `infer R extends ResponseMap` is load bearing: without the constraint the
+ * narrowed `O` inside the branch is `{ response: R } & O`, whose `response` no
+ * longer satisfies `RouteSchemas`, and `SuccessStatus<O, M>` fails with `TS2344`.
+ */
+type SuccessBody<O extends RouteSchemas, M extends HttpMethod> = O extends {
+    response: infer R extends ResponseMap;
+} ? SuccessStatus<O, M> extends keyof R ? Declared<R[SuccessStatus<O, M>]> : unknown : unknown;
 /** What the framework actually hands a handler; `Input<O>` is its typed view. */
 export interface RouteInput {
     readonly req: BunRequest;
@@ -125,3 +182,4 @@ export interface RouteInput {
     readonly query?: unknown;
     readonly params?: unknown;
 }
+export {};

package/dist/server/request-logging.d.ts

@@ -97,6 +97,20 @@ export interface RequestLoggingOptions {
      * is for.
      */
     readonly correlate?: boolean;
+    /**
+     * Adopt W3C Trace Context, so `traceId`, `spanId` and `parentSpanId` join
+     * `requestId` on every line the request writes. Default **`false`**.
+     *
+     * On, an inbound `traceparent` is honoured and this service becomes a child
+     * span of the caller's; off, nothing reads the header and nothing is minted.
+     * It costs a header read and 8 random bytes per request, which is not worth
+     * paying in a service with nothing to correlate against - and `requestId`
+     * already spans two dunx services on its own.
+     *
+     * `@dunx/http/client` sends the adopted trace upstream, so turning this on at
+     * both ends is what makes one trace cover both.
+     */
+    readonly trace?: boolean;
 }
 /**
  * One structured entry per request, carrying the request and its response.

package/dist/server/routes.d.ts

@@ -1,6 +1,6 @@
 import { type Ctor, type ModuleRef } from '@dunx/core';
 import type { DiscoveredRoute } from '../route/discover.js';
-import type { HttpMethod } from '../route/marker.js';
+import { type HttpMethod } from '../route/marker.js';
 import type { UpgradeHandler } from '../ws/adapter.js';
 import { type CorsOptions } from './cors.js';
 import { type ErrorMapper } from './errors.js';