@dunx/http 2.5.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/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,73 +1,19 @@
 // @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,
+  backoffDelay,
+  executeWithRetry,
+  isJsonBody,
+  isPlainObject,
+  isRetryableStatus,
+  retryAfterMs,
+  safeStringify
+} from "./chunk-ywdpxbkf.js";
 // src/client/options.ts
 var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
 
@@ -98,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,
@@ -372,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(() => "");

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,49 +1,48 @@
 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';
 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';