@dunx/http 2.3.1 → 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 });
@@ -281,6 +285,7 @@ var buildContext = (route) => {
     handler: route.handlerName,
     method: route.method,
     path: route.path,
+    parsesBody: route.options?.body !== undefined,
     get: (key) => record.get(key.id)
   });
 };
@@ -970,6 +975,25 @@ import {
   RequestContext as RequestContext2
 } from "@dunx/core";
 
+// src/server/raw-body.ts
+var WANTED = Symbol.for("dunx.http.rawBody.wanted");
+var TEXT = Symbol.for("dunx.http.rawBody.text");
+
+class RawBody {
+  static want(req) {
+    req[WANTED] = true;
+  }
+  static wanted(req) {
+    return req[WANTED] === true;
+  }
+  static record(req, text) {
+    req[TEXT] = text;
+  }
+  static read(req) {
+    return req[TEXT];
+  }
+}
+
 // src/server/request-id.ts
 var REQUEST_ID_HEADER = "x-request-id";
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -1016,6 +1040,7 @@ class RequestLoggingMiddleware {
   #ignorePrefix;
   #correlateIgnored;
   #correlate;
+  #trace;
   constructor(logger, context, options = {}) {
     this.logger = logger;
     this.context = context;
@@ -1026,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))
@@ -1051,14 +1077,22 @@ class RequestLoggingMiddleware {
       flow: "http",
       context: `${ctx.controller}.${ctx.handler}`
     };
-    return this.#correlate ? this.context.runWithContext(scope, () => this.#begin(req, url, mark, path, requestId, started, next, undefined)) : this.#begin(req, url, mark, path, requestId, started, next, scope);
+    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, url, mark, path, requestId, started, next, scope) {
+  #begin(req, ctx, url, mark, path, requestId, started, next, scope) {
     const request = {};
     if (mark !== -1) {
       request["query"] = Object.fromEntries(new URLSearchParams(url.slice(mark + 1)));
     }
-    const body = this.#body(req);
+    const body = this.#body(req, ctx);
     if (body === undefined) {
       request["userAgent"] = req.headers.get("user-agent");
       return this.#dispatch(req, path, requestId, started, request, next, scope);
@@ -1070,6 +1104,18 @@ class RequestLoggingMiddleware {
       return this.#dispatch(req, path, requestId, started, request, next, scope);
     });
   }
+  #shared(req, request) {
+    if (!this.#requestBody)
+      return;
+    if (request["body"] !== undefined)
+      return;
+    const text = RawBody.read(req);
+    if (text === undefined)
+      return;
+    const value = parse(text, this.#limit);
+    if (value !== undefined)
+      request["body"] = value;
+  }
   #correlated(req, ctx, path, next) {
     const requestId = RequestIds.assign(req);
     const stamp = (response) => {
@@ -1100,6 +1146,7 @@ class RequestLoggingMiddleware {
     });
   }
   #failed(req, path, started, request, error, scope) {
+    this.#shared(req, request);
     const status = error instanceof HttpError ? error.status : HttpStatusCode.INTERNAL_SERVER_ERROR;
     const entry = {
       ...scope,
@@ -1116,6 +1163,7 @@ class RequestLoggingMiddleware {
     }
   }
   #succeeded(req, path, requestId, started, request, response, scope) {
+    this.#shared(req, request);
     const body = this.#responseFields(response);
     if (body === undefined) {
       this.logger.info(`${req.method} ${path} ${response.status}`, {
@@ -1139,7 +1187,7 @@ class RequestLoggingMiddleware {
       return response;
     });
   }
-  #body(req) {
+  #body(req, ctx) {
     if (!this.#requestBody)
       return;
     if (req.method === "GET" || req.method === "HEAD")
@@ -1147,6 +1195,10 @@ class RequestLoggingMiddleware {
     if (!(req.headers.get("content-type") ?? "").includes("application/json")) {
       return;
     }
+    if (ctx.parsesBody) {
+      RawBody.want(req);
+      return;
+    }
     return req.clone().text().then((text) => parse(text, this.#limit));
   }
   #responseFields(response) {
@@ -1230,7 +1282,11 @@ var bodyFill = (schema) => (draft) => {
   if (parse2 === undefined) {
     throw new HttpError(HttpStatusCode.UNSUPPORTED_MEDIA_TYPE, `Unsupported content type "${media}". Declared bodies accept ` + "application/json, application/x-www-form-urlencoded, multipart/form-data or text/*.");
   }
-  return parse2(draft.req).then((value) => fillWith(draft, "body", schema, value), (error) => {
+  const read = parse2 === asJson && RawBody.wanted(draft.req) ? draft.req.text().then((text) => {
+    RawBody.record(draft.req, text);
+    return JSON.parse(text);
+  }) : parse2(draft.req);
+  return read.then((value) => fillWith(draft, "body", schema, value), (error) => {
     throw new HttpError(HttpStatusCode.BAD_REQUEST, `Malformed ${media} body`, { cause: error });
   });
 };
@@ -1277,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) {
@@ -1309,6 +1365,7 @@ var unmatchedContext = (req, isPublic) => Object.freeze({
   handler: "(none)",
   method: req.method,
   path: new URL(req.url).pathname,
+  parsesBody: false,
   get: (key) => {
     if (key.id === UNMATCHED.id)
       return true;
@@ -1767,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");
@@ -1952,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);
 
@@ -1976,7 +2301,7 @@ class ThrottleModule {
       global: true,
       exports: EXPORTS,
       providers: [
-        provide3(ThrottleOptions, { useValue: new ThrottleOptions(init) }),
+        provide4(ThrottleOptions, { useValue: new ThrottleOptions(init) }),
         store(),
         guard()
       ]
@@ -1989,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 ?? []
         }),
@@ -2128,6 +2453,50 @@ class QueryProbe {
 // src/health/controller.ts
 import { inject } from "@dunx/core";
 
+// src/health/report-schema.ts
+var state = {
+  type: "string",
+  enum: ["up", "down", "unknown"],
+  description: "`unknown` is not `down`: a probe that timed out has told you nothing."
+};
+var HEALTH_REPORT_SCHEMA = Object.freeze({
+  $id: "HealthReport",
+  type: "object",
+  description: "What the probe found. `up` answers 200 and anything else answers 503.",
+  properties: {
+    status: state,
+    draining: {
+      type: "boolean",
+      description: "The process is shutting down, or something holds it out."
+    },
+    uptimeMs: {
+      type: "integer",
+      description: "Measured on a monotonic clock, so it never goes backwards."
+    },
+    checks: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          state,
+          critical: {
+            type: "boolean",
+            description: "A failure here sheds traffic. Memory and disk do not."
+          },
+          ms: { type: "integer", description: "How long the check took." },
+          detail: {
+            type: "string",
+            description: "A latency, a version, or a failure message."
+          }
+        },
+        required: ["name", "state", "critical", "ms"]
+      }
+    }
+  },
+  required: ["status", "draining", "uptimeMs", "checks"]
+});
+
 // src/health/registry.ts
 var bounded = async (indicator, timeoutMs) => {
   let timer;
@@ -2162,12 +2531,14 @@ class HealthOptions {
   readiness;
   timeoutMs;
   routes;
+  documented;
   drainDelayMs;
   constructor(init = {}) {
     this.liveness = init.liveness ?? [];
     this.readiness = init.readiness ?? [];
     this.timeoutMs = init.timeoutMs ?? 2000;
     this.routes = init.routes ?? true;
+    this.documented = init.documented ?? true;
     this.drainDelayMs = Math.max(0, init.drainDelayMs ?? 0);
   }
 }
@@ -2230,18 +2601,20 @@ Object.defineProperty(HealthRegistry, Symbol.for("dunx.deps"), {
 });
 
 // src/health/controller.ts
+var probeResponses = {
+  response: { 200: HEALTH_REPORT_SCHEMA, 503: HEALTH_REPORT_SCHEMA }
+};
 var answer = (report) => Response.json(report, { status: report.status === "up" ? 200 : 503 });
 var _dec = [
-  Controller("health"),
-  ApiHidden()
+  Controller("health")
 ];
 var _dec2 = [
   Public(),
-  Get("/live")
+  Get("/live", probeResponses)
 ];
 var _dec3 = [
   Public(),
-  Get("/ready")
+  Get("/ready", probeResponses)
 ];
 var _health = new WeakMap;
 var _init = __decoratorStart(undefined);
@@ -2264,6 +2637,18 @@ HealthController = __decorateElement(_init, 0, "HealthController", _dec, HealthC
 __runInitializers(_init, 1, HealthController);
 __decoratorMetadata(_init, HealthController);
 let _HealthController = HealthController;
+var _dec = [
+  ApiHidden()
+];
+var _base = HealthController;
+var _init = __decoratorStart(_base);
+
+class HiddenHealthController extends _base {
+}
+HiddenHealthController = __decorateElement(_init, 0, "HiddenHealthController", _dec, HiddenHealthController);
+__runInitializers(_init, 1, HiddenHealthController);
+__decoratorMetadata(_init, HiddenHealthController);
+let _HiddenHealthController = HiddenHealthController;
 // src/health/indicators.ts
 import { statfs } from "fs/promises";
 var ms = (started) => Math.round(performance.now() - started);
@@ -2368,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
@@ -2416,22 +2801,23 @@ 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]
   })
 ];
 var surface = [HealthOptions, HealthRegistry, Readiness];
+var controllerFor = (documented) => documented ? HealthController : HiddenHealthController;
 var _dec = [
-  Module3({})
+  Module4({})
 ];
 var _init = __decoratorStart(undefined);
 
@@ -2440,19 +2826,19 @@ class HealthModule {
     const options = new HealthOptions(init);
     return {
       module: HealthModule,
-      ...options.routes ? { controllers: [HealthController] } : {},
+      ...options.routes ? { controllers: [controllerFor(options.documented)] } : {},
       exports: surface,
-      providers: wiring([provide4(HealthOptions, { useValue: options })])
+      providers: wiring([provide5(HealthOptions, { useValue: options })])
     };
   }
   static forRootAsync(config) {
     return {
       module: HealthModule,
       ...config.imports ? { imports: config.imports } : {},
-      ...config.routes ?? true ? { controllers: [HealthController] } : {},
+      ...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 ?? []
         })
@@ -2467,6 +2853,10 @@ let _HealthModule = HealthModule;
 export {
   ApiHidden,
   ClientAddress,
+  Compression,
+  CompressionEncoding,
+  CompressionModule,
+  CompressionOptions,
   Controller,
   DEFAULT_RELAY_CHANNEL,
   DatabaseIndicator,
@@ -2476,6 +2866,7 @@ export {
   ErrorFilter,
   Gateway,
   Get,
+  HEALTH_REPORT_SCHEMA,
   HIDDEN,
   HandlerKind,
   HealthController,
@@ -2483,6 +2874,7 @@ export {
   HealthModule,
   HealthOptions,
   HealthRegistry,
+  HiddenHealthController,
   HttpError,
   HttpFactory,
   HttpStatusCode,
@@ -2520,11 +2912,14 @@ export {
   StaticModule,
   StaticOptions,
   THROTTLE,
+  TRACEPARENT_HEADER,
+  TRACESTATE_HEADER,
   Throttle,
   ThrottleGuard,
   ThrottleModule,
   ThrottleOptions,
   ThrottleStore,
+  TraceContext,
   UNMATCHED,
   UseGuards,
   ValidationError,
@@ -2541,6 +2936,7 @@ export {
   decodeRelay,
   defaultErrorMapper,
   defaultRelayUrl,
+  defaultStatusFor,
   discoverGateway,
   discoverGateways,
   discoverRoutes,
@@ -2549,6 +2945,7 @@ export {
   errorMapper,
   gatewaysOf,
   guardsOf,
+  isCompressibleType,
   isErrorFilter,
   isGateway,
   joinPath,
@@ -2556,6 +2953,7 @@ export {
   meta,
   metaKey,
   metaOf,
+  negotiate,
   normalizePath,
   normalizePrefix,
   observe,
@@ -2565,6 +2963,3 @@ export {
   withCors,
   withUpgradeRoutes
 };
-
-//# debugId=30A653C61AAD581564756E2164756E21
-//# sourceMappingURL=index.js.map