@dunx/http 2.5.0 → 3.0.1

package/dist/{chunk-jh7jk0bn.js → chunk-sz4pvqxy.js}

@@ -105,60 +105,4 @@ var HttpStatusCode = Object.freeze({
   GATEWAY_TIMEOUT: 504
 });
 
-// src/server/trace-context.ts
-var TRACEPARENT_HEADER = "traceparent";
-var TRACESTATE_HEADER = "tracestate";
-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 TRACE = Symbol.for("dunx.http.trace");
-var mintSpanId = () => Buffer.from(crypto.getRandomValues(new Uint8Array(8))).toString("hex");
-
-class TraceContext {
-  static adopt(req, requestId) {
-    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 } : {}
-    };
-    req[TRACE] = trace;
-    return trace;
-  }
-  static of(req) {
-    return req[TRACE];
-  }
-  static header(trace) {
-    return `00-${trace.traceId}-${trace.spanId}-${trace.flags}`;
-  }
-  static sampled(trace) {
-    return (Number.parseInt(trace.flags, 16) & SAMPLED) === SAMPLED;
-  }
-  static #parse(header) {
-    if (header === null)
-      return;
-    const parts = header.split("-");
-    if (parts.length < 4)
-      return;
-    const [version, traceId, spanId, flags] = parts;
-    if (!HEX_2.test(version) || version === "ff")
-      return;
-    if (version === "00" && parts.length !== 4)
-      return;
-    if (!HEX_32.test(traceId) || traceId === ZERO_TRACE)
-      return;
-    if (!HEX_16.test(spanId) || spanId === ZERO_SPAN)
-      return;
-    if (!HEX_2.test(flags))
-      return;
-    return { traceId, spanId, flags };
-  }
-}
-
-export { __privateGet, __privateAdd, __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode, TRACEPARENT_HEADER, TRACESTATE_HEADER, TraceContext };
+export { __privateGet, __privateAdd, __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode };

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/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,7 @@
  * `@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';

package/dist/client.js

@@ -1,73 +1,16 @@
 // @bun
 import {
-  HttpStatusCode,
   TRACEPARENT_HEADER,
   TraceContext
-} from "./chunk-jh7jk0bn.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));
-};
+} from "./chunk-25g22350.js";
+import {
+  FetchError,
+  FetchTransportError,
+  executeWithRetry,
+  isJsonBody,
+  safeStringify
+} from "./chunk-b699cfes.js";
+import"./chunk-sz4pvqxy.js";
 // src/client/options.ts
 var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
 
@@ -98,71 +41,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,
@@ -372,9 +251,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(() => "");
@@ -463,12 +340,5 @@ export {
   HttpClientOptions,
   HttpModule,
   HttpService,
-  backoffDelay,
-  executeWithRetry,
-  httpClient,
-  isJsonBody,
-  isPlainObject,
-  isRetryableStatus,
-  retryAfterMs,
-  safeStringify
+  httpClient
 };

package/dist/compression/compression.d.ts

@@ -3,25 +3,20 @@ 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 by a module:**
+ * 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 - there is no branch in the request
- * path to skip. Position is the app's decision for the same reason `StaticFiles`
- * leaves it open: compression belongs inside request logging, so the logged status
- * is the real one, and outside anything that wants to read the body it produced.
+ * 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 rather than one. A body whose `content-length` is known and under
- * `BUFFER_LIMIT` goes through `Bun.zstdCompressSync`/`gzipSync`, which is faster
- * than the stream and leaves an accurate `content-length` on the response; a
- * streamed or oversized body goes through `CompressionStream` and loses the header,
- * as it must.
+ * 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;

package/dist/compression/options.d.ts

@@ -1,23 +1,14 @@
 /**
  * The content codings this package produces.
  *
- * **Brotli is absent, and that is a measurement rather than an oversight.** Bun
- * implements it - `new CompressionStream('brotli')` works - but at 6,344 us to
- * encode a 6.4 KB JSON body against gzip's 23 us and zstd's 24 us, roughly 275x.
- * The `level` argument that would fix it is accepted and ignored: `{ level: 4 }`
- * encodes in 6,345 us and produces the same 339 bytes as the default. Brotli
- * belongs on a build artefact compressed once, not on a response encoded per
- * request. Note also that the `CompressionStream` format is spelled `brotli`
- * while the HTTP token is `br`, so the two never lined up anyway.
+ * 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 for a second and worse reason: Bun's two encoders disagree
- * about what it means.** `Bun.deflateSync` emits raw DEFLATE (first bytes
- * `cb 48`), while `CompressionStream('deflate')` emits zlib (`78 9c`), which is
- * what `Content-Encoding: deflate` is defined as. No option reconciles them -
- * `library`, `windowBits` and `level` all leave `deflateSync` raw - so offering
- * the coding would flip wire format at the buffering threshold and serve bytes a
- * strict client rejects. `gzip` is taken by everything that would have accepted
- * `deflate`. Measured on Bun 1.4.0; see docs/bun-apis.md.
+ * `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';
@@ -36,14 +27,11 @@ 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, so it is a real preference and not just a filter.
+     * broken by this order.
      *
-     * The default puts `zstd` first for speed. On a 6.4 KB JSON body zstd encodes to
-     * 372 bytes in 7.7 us where gzip takes 16.1 us to reach 576; on a 116 KB OpenAPI
-     * document the two land within 0.2% of each other (9,603 against 9,587), so the
-     * size advantage narrows with the body while the time one does not. A client
-     * that does not send `zstd` in `accept-encoding` gets gzip, so the order costs
-     * nothing to state.
+     * `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']
      */

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,47 +1,39 @@
 export { Controller, Delete, Get, Patch, Post, Put, } from './route/decorators.js';
-export { discoverRoutes, joinPath, type DiscoveredRoute, } from './route/discover.js';
-export { defaultStatusFor, type DefaultStatus, type HttpMethod, type RouteMeta, type 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 { 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 { gatewaysOf, routesOf, type GatewayHandler, type GatewayNode, type RouteInputs, type RouteNode, } from './inspect.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 { negotiate } from './compression/negotiate.js';
-export { CompressionEncoding, CompressionOptions, isCompressibleType, type CompressionOptionsInit, } from './compression/options.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';