@dunx/http 2.4.0 → 3.0.0

package/dist/client/module.d.ts

@@ -41,13 +41,8 @@ export declare class HttpModule {
      */
     static forRoot(init?: HttpClientOptionsInit): DynamicModule;
     /**
-     * `forRoot` with the options behind a factory, which is the one thing a
-     * zero-argument `forRoot` cannot do: read the base url or the timeout off
-     * `ConfigService`.
-     *
-     * There is no separate async machinery - the container resolves eagerly and
-     * awaits factories before any constructor runs, so awaited config is settled by
-     * the time anything is built.
+     * `forRoot` with the options behind a factory, so the base url or the timeout
+     * can come off `ConfigService`.
      *
      * ```ts
      * HttpModule.forRootAsync({

package/dist/client/options.d.ts

@@ -24,6 +24,17 @@ export interface HttpClientOptionsInit {
      * @default true
      */
     readonly propagateRequestId?: boolean | string;
+    /**
+     * Forward W3C Trace Context upstream as `traceparent`, so the callee's spans
+     * join this request's trace.
+     *
+     * 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.
+     *
+     * @default true
+     */
+    readonly propagateTrace?: boolean;
     /** Bound as its own token, so a second client can be injected by name. */
     readonly name?: string;
     /**
@@ -51,6 +62,7 @@ export declare class HttpClientOptions {
     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>>;
     constructor(init?: HttpClientOptionsInit);

package/dist/client/service.d.ts

@@ -43,18 +43,12 @@ 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.
+ * 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.
  *
- * `fetch` and nothing else: it is a Web standard Bun implements natively, so there
- * is no client dependency to justify - which is also why `axios` and `node-fetch`
- * are banned repo-wide. What this adds over calling `fetch` yourself is the parts
- * every caller otherwise reimplements slightly differently: the timeout, the
- * retry policy, `Retry-After`, url building, and a failure that says which call
- * failed.
- *
- * Extends `UrlHelper` from `@arkv/shared`, so `buildUrl` and `interpolate` are
- * available on the service, and there is one implementation of them across the
- * owner's projects rather than a fork per repo.
+ * Extends `UrlHelper` from `@arkv/shared` for `buildUrl` and `interpolate`.
  */
 export declare class HttpService extends UrlHelper {
     private readonly options;
@@ -83,18 +77,13 @@ export declare class HttpService extends UrlHelper {
         readonly method?: 'GET' | 'POST';
     }): AsyncGenerator<string>;
     /**
-     * Resolves the target, accepting the three forms a caller actually reaches for:
-     * an absolute url, a path relative to `baseUrl`, or `baseUrl` plus an explicit
-     * `path`.
-     *
-     * `get('/users')` is the one worth calling out. A relative first argument is what
-     * every HTTP client takes once a base url exists, and passing it straight to
-     * `buildUrl` throws `ERR_INVALID_URL` from inside `new URL()` - a message naming
-     * neither the call nor the missing base. So a first argument that is not an
-     * absolute url is treated as the path, which is what it reads as.
+     * Resolves the target: an absolute url, a path relative to `baseUrl`, or
+     * `baseUrl` plus an explicit `path`.
      *
-     * `URL.canParse` decides, rather than a regex over `//` or `:` - it is the same
-     * parser `new URL` uses, so the two cannot disagree.
+     * A relative first argument reaching `buildUrl` throws `ERR_INVALID_URL` from
+     * inside `new URL()`, naming neither the call nor the missing base, so one that
+     * is not absolute is treated as the path. `URL.canParse` decides rather than a
+     * regex, so it cannot disagree with `new URL`.
      */
     private urlFor;
     /** `serialised` is what a `headerFactory` signs, and is `''` for no body. */

package/dist/client.d.ts

@@ -6,8 +6,14 @@
  * `@dunx/http` does not load any of this.
  */
 export { FetchError, FetchTransportError } from './client/errors.js';
-export { isJsonBody, isPlainObject, safeStringify } from './client/json.js';
 export { DEFAULT_REQUEST_ID_HEADER, HttpClientOptions, type HttpClientOptionsInit, } from './client/options.js';
-export { backoffDelay, executeWithRetry, isRetryableStatus, retryAfterMs, type BackoffOptions, type RetryOptions, } from './client/retry.js';
+export type { BackoffOptions, RetryOptions } from './client/retry.js';
 export { httpClient, HttpModule } from './client/module.js';
 export { HttpService, type HeaderFactory, type RequestConfig, type RequestMethod, } from './client/service.js';
+/**
+ * The client's own plumbing, still reachable here and moving out in 4.0.
+ * Import it from `@dunx/http/internal`, which carries no stability promise.
+ *
+ * @deprecated Import from `@dunx/http/internal`. Removed in 4.0.
+ */
+export { backoffDelay, executeWithRetry, isJsonBody, isPlainObject, isRetryableStatus, retryAfterMs, safeStringify, } from './internal.js';

package/dist/client.js

@@ -1,71 +1,19 @@
 // @bun
 import {
-  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: "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/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 isPlainObject = (value) => {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-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));
-};
+  TRACEPARENT_HEADER,
+  TraceContext
+} from "./chunk-25g22350.js";
+import {
+  FetchError,
+  FetchTransportError,
+  backoffDelay,
+  executeWithRetry,
+  isJsonBody,
+  isPlainObject,
+  isRetryableStatus,
+  retryAfterMs,
+  safeStringify
+} from "./chunk-ywdpxbkf.js";
 // src/client/options.ts
 var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
 
@@ -75,6 +23,7 @@ class HttpClientOptions {
   headers;
   retry;
   requestIdHeader;
+  propagateTrace;
   name;
   fetchOptions;
   constructor(init = {}) {
@@ -83,6 +32,7 @@ class HttpClientOptions {
     this.headers = init.headers ?? {};
     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([
@@ -94,71 +44,7 @@ class HttpClientOptions {
     ].filter(([, value]) => value !== undefined));
   }
 }
-Object.defineProperty(HttpClientOptions, Symbol.for("dunx.deps"), {
-  value: () => [{ unresolved: "init: HttpClientOptionsInit = {}" }]
-});
-// 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;
-};
+Object.defineProperty(HttpClientOptions, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "init: HttpClientOptionsInit = {}", optional: true }] });
 // src/client/module.ts
 import {
   Logger as Logger2,
@@ -328,11 +214,19 @@ class HttpService extends UrlHelper {
   }
   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"
+        })
+      } : {},
       ...config.headerFactory?.({
         timestamp: Math.floor(Date.now() / 1000),
         method: config.method,
@@ -360,9 +254,7 @@ class HttpService extends UrlHelper {
     }
   }
 }
-Object.defineProperty(HttpService, Symbol.for("dunx.deps"), {
-  value: () => [HttpClientOptions, Logger, RequestContext]
-});
+Object.defineProperty(HttpService, Symbol.for("dunx.deps"), { value: () => [HttpClientOptions, Logger, RequestContext] });
 var urlOf = (url) => url === undefined ? {} : { url };
 var readBody = async (response) => {
   const text = await response.text().catch(() => "");
@@ -460,6 +352,3 @@ export {
   retryAfterMs,
   safeStringify
 };
-
-//# debugId=9448CCC7AF6FC82264756E2164756E21
-//# sourceMappingURL=client.js.map

package/dist/compression/compression.d.ts

@@ -0,0 +1,25 @@
+import type { BunRequest } from 'bun';
+import type { RouteContext } from '../server/context.js';
+import type { Middleware, Next } from '../server/middleware.js';
+import { CompressionOptions } from './options.js';
+/**
+ * Response compression, on Bun's own compressors. Not installed by default, and
+ * registered by the app rather than a module:
+ *
+ * ```ts
+ * const app = await HttpFactory.create(AppModule, { imports: [CompressionModule.forRoot()] });
+ * app.use(Compression);
+ * ```
+ *
+ * An app that never registers it pays nothing. Position is the app's: compression
+ * belongs inside request logging and outside anything reading the body it made.
+ *
+ * Two encoders. A known length under `BUFFER_LIMIT` goes through the sync
+ * compressors, which keep an accurate `content-length`; anything larger or
+ * streamed goes through `CompressionStream` and loses the header.
+ */
+export declare class Compression implements Middleware {
+    #private;
+    constructor(options: CompressionOptions);
+    handle(req: BunRequest, _ctx: RouteContext, next: Next): Promise<Response>;
+}

package/dist/compression/module.d.ts

@@ -0,0 +1,20 @@
+import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type CompressionOptionsInit } from './options.js';
+/**
+ * Binds `Compression` and its options. Like `StaticModule`, importing it does not
+ * install anything - the app decides where in the chain it goes:
+ *
+ * ```ts
+ * const app = await HttpFactory.create(AppModule, {
+ *   imports: [CompressionModule.forRoot({ threshold: 2048 })],
+ * });
+ * app.use(Compression);
+ * ```
+ */
+export declare class CompressionModule {
+    static forRoot(init?: CompressionOptionsInit): DynamicModule;
+    /** `forRoot` with the options read off the container - a config value, usually. */
+    static forRootAsync<const D extends Deps>(config: FactoryProvider<CompressionOptionsInit, D> & {
+        readonly imports?: DynamicModule['imports'];
+    }): DynamicModule;
+}

package/dist/compression/negotiate.d.ts

@@ -0,0 +1,12 @@
+import type { CompressionEncoding } from './options.js';
+/**
+ * The coding to encode with, or `undefined` for none.
+ *
+ * `offered` is the server's preference order and breaks a tie, which is what
+ * makes `['zstd', 'gzip']` meaningful against a browser that sends both at the
+ * same q. An explicit `q=0` refuses a coding, `*` supplies a default for the ones
+ * not named, and an absent header means the client said nothing - answered with
+ * no encoding, because a client that cannot decode is worse than one that reads
+ * a few more bytes.
+ */
+export declare const negotiate: (header: string | null, offered: readonly CompressionEncoding[]) => CompressionEncoding | undefined;

package/dist/compression/options.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The content codings this package produces.
+ *
+ * Brotli is absent on measurement: 6,344 us to encode a 6.4 KB JSON body against
+ * gzip's 23 us, and the `level` argument that would fix it is accepted and
+ * ignored. It belongs on a build artefact, not a per-request response.
+ *
+ * `deflate` is absent because Bun's two encoders disagree: `Bun.deflateSync` emits
+ * raw DEFLATE while `CompressionStream('deflate')` emits zlib, which is what the
+ * header is defined as. Nothing reconciles them, so offering it would flip wire
+ * format at the buffering threshold. Measured on Bun 1.4.0; see docs/bun-apis.md.
+ */
+export declare const CompressionEncoding: Readonly<{
+    readonly ZSTD: 'zstd';
+    readonly GZIP: 'gzip';
+}>;
+export type CompressionEncoding = (typeof CompressionEncoding)[keyof typeof CompressionEncoding];
+/**
+ * Whether a `content-type` is worth encoding.
+ *
+ * An already-compressed payload - a JPEG, an MP4, a zip - comes out of a second
+ * pass slightly larger, having spent the CPU to get there. The default answers
+ * no to anything it does not recognise, so a new binary type is skipped rather
+ * than wasted on.
+ */
+export declare const isCompressibleType: (contentType: string | null) => boolean;
+export interface CompressionOptionsInit {
+    /**
+     * The codings offered, most preferred first. A tie in the client's q-values is
+     * broken by this order.
+     *
+     * `zstd` leads for speed: 7.7 us to 372 bytes on a 6.4 KB JSON body where gzip
+     * takes 16.1 us to reach 576. On a 116 KB document the sizes land within 0.2%,
+     * so the size advantage narrows with the body while the time one does not.
+     *
+     * @default ['zstd', 'gzip']
+     */
+    readonly encodings?: readonly CompressionEncoding[];
+    /**
+     * Bodies below this many bytes are sent as they are.
+     *
+     * Only applied when the response declares a `content-length`. A short JSON body
+     * grows under gzip - the header and trailer alone are 18 bytes - and the round
+     * trip through a compressor is time spent to send more.
+     *
+     * @default 1024
+     */
+    readonly threshold?: number;
+    /** Which `content-type`s to encode. @default isCompressibleType */
+    readonly filter?: (contentType: string | null) => boolean;
+}
+/**
+ * A class, not an interface, so it is a runtime value `@dunx/transform` can record
+ * at an injection site - the same reason `StaticOptions` and `ThrottleOptions` are.
+ */
+export declare class CompressionOptions {
+    readonly encodings: readonly CompressionEncoding[];
+    readonly threshold: number;
+    readonly filter: (contentType: string | null) => boolean;
+    constructor(init?: CompressionOptionsInit);
+}

package/dist/health/indicators.d.ts

@@ -22,17 +22,12 @@ export declare class MemoryOptions {
     constructor(init: MemoryOptionsInit);
 }
 /**
- * Resident set size against a ceiling.
+ * Resident set size against a ceiling. `process.memoryUsage()` costs 5.96 us,
+ * which is what makes it safe on an endpoint scraped every two seconds;
+ * `jsc.heapStats()` is 2.2 ms and up and `v8.getHeapStatistics()` 1 to 7.6 ms.
  *
- * `process.memoryUsage()` costs 5.96 us, which is what makes it safe on an endpoint
- * scraped every two seconds. The alternatives were measured and rejected:
- * `jsc.heapStats()` walks every live object at 2.2 ms and up,
- * `v8.getHeapStatistics()` is 1 to 7.6 ms, and `Bun.generateHeapSnapshot()` is
- * hundreds of milliseconds and megabytes. None belongs on this path.
- *
- * Not critical: a process near its ceiling is worth seeing, and shedding traffic
- * from it does not make it use less memory. Liveness is where a ceiling belongs, so
- * the orchestrator restarts it.
+ * Not critical: shedding traffic from a process near its ceiling does not make it
+ * use less memory. A ceiling belongs on liveness, where it restarts.
  */
 export declare class MemoryIndicator extends HealthIndicator {
     private readonly options;

package/dist/index.d.ts

@@ -1,44 +1,48 @@
 export { Controller, Delete, Get, Patch, Post, Put, } from './route/decorators.js';
-export { discoverRoutes, joinPath, type DiscoveredRoute, } from './route/discover.js';
-export type { HttpMethod, RouteMeta, RoutePath } from './route/marker.js';
-export { ApiHidden, guardsOf, HIDDEN, meta, metaKey, metaOf, mergeMeta, Public, PUBLIC, Roles, ROLES, UNMATCHED, UseGuards, type MetaKey, type MetaRecord, } from './route/metadata.js';
-export type { InferOutput, Input, JsonSchema, RouteInput, RouteSchemas, StandardSchemaIssue, StandardSchemaResult, StandardSchemaV1, } from './route/schema.js';
-export { gatewaysOf, routesOf, type GatewayHandler, type GatewayNode, type RouteInputs, type RouteNode, } from './inspect.js';
+export type { HttpMethod, RoutePath } from './route/marker.js';
+export { ApiHidden, HIDDEN, meta, metaKey, metaOf, mergeMeta, Public, PUBLIC, Roles, ROLES, UNMATCHED, UseGuards, type MetaKey, type MetaRecord, } from './route/metadata.js';
+export type { InferOutput, Input, JsonSchema, ResponseMap, Returns, RouteInput, RouteSchemas, StandardSchemaIssue, StandardSchemaResult, StandardSchemaV1, } from './route/schema.js';
 export { ClientAddress } from './server/client-address.js';
-export { buildContext, type RouteContext } from './server/context.js';
-export { preflight, withCors, type CorsOptions, type CorsOrigin, } from './server/cors.js';
-export { defaultErrorMapper, ErrorFilter, errorMapper, HttpError, isErrorFilter, toErrorMapper, ValidationError, type ErrorHandler, type ErrorMapper, type HttpErrorOptions, type InputSource, type ValidationIssue, } from './server/errors.js';
+export type { RouteContext } from './server/context.js';
+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 { REQUEST_ID_HEADER } from './server/request-id.js';
+export { TRACEPARENT_HEADER, TRACESTATE_HEADER, TraceContext, type Trace, } from './server/trace-context.js';
 export { RequestLoggingMiddleware, type RequestLoggingOptions, } from './server/request-logging.js';
-export { compose, type Middleware, type Next, type RouteHandler, } from './server/middleware.js';
-export { assertNoCollisions, assertNoGatewayCollisions, buildRoutes, withUpgradeRoutes, type BunRoutes, type GuardResolver, type RouteMethod, type ServeRoutes, } from './server/routes.js';
+export type { Middleware, Next, RouteHandler } from './server/middleware.js';
 export type { AppSettings } from './server/settings.js';
 export { StaticFiles } from './static/files.js';
 export { StaticModule } from './static/module.js';
-export { normalizePrefix, StaticOptions, type StaticOptionsInit, } from './static/options.js';
+export { StaticOptions, type StaticOptionsInit } from './static/options.js';
+export { Compression } from './compression/compression.js';
+export { CompressionModule } from './compression/module.js';
+export { CompressionEncoding, CompressionOptions, type CompressionOptionsInit, } from './compression/options.js';
 export { SKIP_THROTTLE, SkipThrottle, THROTTLE, Throttle, type ThrottleLimit, } from './throttle/decorators.js';
 export { ThrottleGuard } from './throttle/guard.js';
 export { ThrottleModule } from './throttle/module.js';
 export { ThrottleOptions, type ThrottleOptionsInit, } from './throttle/options.js';
 export { MemoryThrottleStore, RedisThrottleStore, ThrottleStore, type ThrottleRedis, } from './throttle/store.js';
 export { HttpStatusCode, type HttpStatusName } from './server/status.js';
-export { buildWebSocket, type UpgradeHandler, type WebSocketRuntime, } from './ws/adapter.js';
 export { Gateway, OnClose, OnDrain, OnMessage, OnOpen, OnPing, OnPong, OnUpgrade, } from './ws/decorators.js';
-export { discoverGateway, discoverGateways, normalizePath, type DiscoveredGateway, type DiscoveredHandler, type Invoke, } from './ws/discover.js';
-export { decode, encode, type Envelope } from './ws/envelope.js';
-export { composeSocket, observe, type SocketContext, type SocketDispatch, type SocketFrame, type SocketMiddleware, type SocketNext, } from './ws/middleware.js';
+export type { Envelope } from './ws/envelope.js';
+export type { SocketContext, SocketDispatch, SocketFrame, SocketMiddleware, SocketNext, } from './ws/middleware.js';
 export { SocketLoggingMiddleware, type SocketLoggingOptions, } from './ws/logging.js';
-export { HandlerKind, isGateway, type HandlerMeta } from './ws/marker.js';
 export { PubSub } from './ws/pubsub.js';
-export { defaultRelayUrl, RedisRelay, type RedisRelayOptions, } from './ws/redis-relay.js';
-export { decodeRelay, DEFAULT_RELAY_CHANNEL, encodeRelay, type PubSubRelay, type RelayFrame, type RelayOptions, type RelayPhase, } from './ws/relay.js';
-export { buildGateways, buildRuntime, type GatewayRuntime, } from './ws/runtime.js';
+export { RedisRelay, type RedisRelayOptions } from './ws/redis-relay.js';
+export { DEFAULT_RELAY_CHANNEL, type PubSubRelay, type RelayOptions, } from './ws/relay.js';
 export type { Socket, SocketData, SocketErrorHandler, SocketOptions, } from './ws/socket.js';
 export { HealthIndicator, PingProbe, QueryProbe, type ProbeResult, type ProbeState, } from './health/contracts.js';
-export { HealthController, HiddenHealthController, } from './health/controller.js';
+export { HealthController } from './health/controller.js';
 export { DatabaseIndicator, DiskIndicator, DiskOptions, MemoryIndicator, MemoryOptions, RedisIndicator, type DiskOptionsInit, type MemoryOptionsInit, } from './health/indicators.js';
 export { HealthModule } from './health/module.js';
 export { HEALTH_REPORT_SCHEMA } from './health/report-schema.js';
 export { Readiness, ReadinessOptions } from './health/readiness.js';
 export { HealthOptions, HealthRegistry, type HealthCheckReport, type HealthOptionsInit, type HealthReport, } from './health/registry.js';
+/**
+ * The framework's own plumbing, still reachable here and moving out in 4.0.
+ * Import it from `@dunx/http/internal`, which carries no stability promise.
+ *
+ * @deprecated Import from `@dunx/http/internal`. Removed in 4.0.
+ */
+export { assertNoCollisions, assertNoGatewayCollisions, buildContext, buildGateways, buildRoutes, buildRuntime, buildWebSocket, compose, composeSocket, decode, decodeRelay, defaultRelayUrl, defaultStatusFor, discoverGateway, discoverGateways, discoverRoutes, encode, encodeRelay, gatewaysOf, guardsOf, HandlerKind, HiddenHealthController, isCompressibleType, isErrorFilter, isGateway, joinPath, negotiate, normalizePath, normalizePrefix, observe, preflight, routesOf, toErrorMapper, withCors, withUpgradeRoutes, type BunRoutes, type DefaultStatus, type DiscoveredGateway, type DiscoveredHandler, type DiscoveredRoute, type GatewayHandler, type GatewayNode, type GatewayRuntime, type GuardResolver, type HandlerMeta, type Invoke, type RelayFrame, type RelayPhase, type RouteInputs, type RouteMeta, type RouteMethod, type RouteNode, type ServeRoutes, type UpgradeHandler, type WebSocketRuntime, } from './internal.js';