@dunx/http 3.0.0 → 3.0.2

package/dist/chunk-sz4pvqxy.js

@@ -0,0 +1,108 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/server/status.ts
+var HttpStatusCode = Object.freeze({
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  IM_A_TEAPOT: 418,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+});
+
+export { __privateGet, __privateAdd, __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode };

package/dist/client/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider, type Token } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig, type Token } from '@dunx/core';
 import { type HttpClientOptionsInit } from './options.js';
 import { HttpService } from './service.js';
 /**
@@ -57,5 +57,5 @@ export declare class HttpModule {
      * token has to exist before the factory runs.
      */
     static forRootAsync(load: () => HttpClientOptionsInit | Promise<HttpClientOptionsInit>, name?: string): DynamicModule;
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<HttpClientOptionsInit, D>, name?: string): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<HttpClientOptionsInit, D>, name?: string): DynamicModule;
 }

package/dist/client.d.ts

@@ -10,10 +10,3 @@ export { DEFAULT_REQUEST_ID_HEADER, HttpClientOptions, type HttpClientOptionsIni
 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

@@ -6,14 +6,11 @@ import {
 import {
   FetchError,
   FetchTransportError,
-  backoffDelay,
   executeWithRetry,
   isJsonBody,
-  isPlainObject,
-  isRetryableStatus,
-  retryAfterMs,
   safeStringify
-} from "./chunk-ywdpxbkf.js";
+} from "./chunk-b699cfes.js";
+import"./chunk-sz4pvqxy.js";
 // src/client/options.ts
 var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
 
@@ -295,11 +292,12 @@ var serviceFrom = (target, optionsToken) => provide(target, {
   useFactory: (options, logger, context) => new HttpService(options, logger, context),
   inject: [optionsToken, Logger2, RequestContext2]
 });
-var namedModule = (name, options) => {
+var namedModule = (name, options, imports = []) => {
   const optionsToken = token(`HttpClientOptions(${name})`);
   const optionsProvider = options instanceof HttpClientOptions ? provide(optionsToken, { useValue: options }) : provide(optionsToken, options);
   return {
     module: HttpModule,
+    imports,
     exports: [optionsToken, httpClient(name)],
     providers: [optionsProvider, serviceFrom(httpClient(name), optionsToken)]
   };
@@ -322,12 +320,14 @@ class HttpModule {
   static forRootAsync(source, name) {
     const load = typeof source === "function" ? source : source.useFactory;
     const inject = typeof source === "function" ? [] : source.inject ?? [];
+    const imports = typeof source === "function" ? [] : source.imports ?? [];
     const useFactory = async (...deps) => new HttpClientOptions(await load(...deps));
     if (name !== undefined) {
-      return namedModule(name, { useFactory, inject });
+      return namedModule(name, { useFactory, inject }, imports);
     }
     return {
       module: HttpModule,
+      imports,
       exports: [HttpClientOptions, HttpService],
       providers: [
         provide(HttpClientOptions, { useFactory, inject }),
@@ -343,12 +343,5 @@ export {
   HttpClientOptions,
   HttpModule,
   HttpService,
-  backoffDelay,
-  executeWithRetry,
-  httpClient,
-  isJsonBody,
-  isPlainObject,
-  isRetryableStatus,
-  retryAfterMs,
-  safeStringify
+  httpClient
 };

package/dist/compression/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type CompressionOptionsInit } from './options.js';
 /**
  * Binds `Compression` and its options. Like `StaticModule`, importing it does not
@@ -14,7 +14,5 @@ import { type CompressionOptionsInit } from './options.js';
 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;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<CompressionOptionsInit, D>): DynamicModule;
 }

package/dist/health/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type HealthOptionsInit } from './registry.js';
 /**
  * Liveness and readiness, and the drain that makes readiness worth having.
@@ -33,8 +33,7 @@ export declare class HealthModule {
      * table is folded into one closure per route when the server binds, so it cannot
      * wait on a factory. Pass `routes: false` and mount your own if that matters.
      */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<HealthOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<HealthOptionsInit, D> & {
         readonly routes?: boolean;
         readonly documented?: boolean;
     }): DynamicModule;

package/dist/health/readiness.d.ts

@@ -1,5 +1,5 @@
 import type { OnBeforeShutdown } from '@dunx/core';
-export interface ReadinessOptionsInit {
+interface ReadinessOptionsInit {
     /**
      * How long to keep failing readiness after the drain starts, before the server
      * stops accepting. Default `0`.
@@ -49,3 +49,4 @@ export declare class Readiness implements OnBeforeShutdown {
      */
     onBeforeShutdown(): Promise<void>;
 }
+export {};

package/dist/index.d.ts

@@ -39,10 +39,3 @@ 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';

package/dist/index.js

@@ -21,7 +21,6 @@ import {
   HealthRegistry,
   HiddenHealthController,
   HttpError,
-  HttpStatusCode,
   PUBLIC,
   Patch,
   Post,
@@ -37,37 +36,19 @@ import {
   UNMATCHED,
   UseGuards,
   ValidationError,
-  __decorateElement,
-  __decoratorMetadata,
-  __decoratorStart,
-  __runInitializers,
   assertNoCollisions,
   assertNoGatewayCollisions,
-  buildContext,
   buildFallback,
-  buildGateways,
   buildRoutes,
-  buildRuntime,
   buildWebSocket,
-  compose,
-  composeSocket,
-  decode,
   decodeRelay,
   defaultErrorMapper,
   defaultRelayError,
-  defaultRelayUrl,
-  defaultStatusFor,
-  discoverGateway,
   discoverGateways,
   discoverRoutes,
   encode,
   encodeRelay,
   errorMapper,
-  gatewaysOf,
-  guardsOf,
-  isCompressibleType,
-  isErrorFilter,
-  isGateway,
   joinPath,
   markGateway,
   markHandler,
@@ -76,15 +57,17 @@ import {
   metaKey,
   metaOf,
   negotiate,
-  normalizePath,
-  normalizePrefix,
   observe,
-  preflight,
-  routesOf,
   toErrorMapper,
-  withCors,
   withUpgradeRoutes
-} from "./chunk-ywdpxbkf.js";
+} from "./chunk-f6pw36av.js";
+import {
+  HttpStatusCode,
+  __decorateElement,
+  __decoratorMetadata,
+  __decoratorStart,
+  __runInitializers
+} from "./chunk-sz4pvqxy.js";
 // src/server/client-address.ts
 import { AppError } from "@dunx/core";
 var trustedHops = (setting) => {
@@ -94,6 +77,8 @@ var trustedHops = (setting) => {
     return 0;
   return Number.isFinite(setting) ? Math.max(0, Math.trunc(setting)) : 0;
 };
+var IPV4_MAPPED = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i;
+var unmap = (address) => address === undefined ? undefined : IPV4_MAPPED.exec(address)?.[1] ?? address;
 var sources = new WeakMap;
 
 class ClientAddress {
@@ -107,9 +92,9 @@ class ClientAddress {
       const entries = (req.headers.get("x-forwarded-for") ?? "").split(",").map((entry2) => entry2.trim()).filter((entry2) => entry2.length > 0);
       const entry = entries[Math.max(0, entries.length - hops)];
       if (entry)
-        return entry;
+        return unmap(entry);
     }
-    return source.server.requestIP(req)?.address;
+    return unmap(source.server.requestIP(req)?.address);
   }
 }
 var attachAddressSource = (target, source) => {
@@ -1538,13 +1523,11 @@ export {
   Get,
   HEALTH_REPORT_SCHEMA,
   HIDDEN,
-  HandlerKind,
   HealthController,
   HealthIndicator,
   HealthModule,
   HealthOptions,
   HealthRegistry,
-  HiddenHealthController,
   HttpError,
   HttpFactory,
   HttpStatusCode,
@@ -1593,43 +1576,10 @@ export {
   UNMATCHED,
   UseGuards,
   ValidationError,
-  assertNoCollisions,
-  assertNoGatewayCollisions,
-  buildContext,
-  buildGateways,
-  buildRoutes,
-  buildRuntime,
-  buildWebSocket,
-  compose,
-  composeSocket,
-  decode,
-  decodeRelay,
   defaultErrorMapper,
-  defaultRelayUrl,
-  defaultStatusFor,
-  discoverGateway,
-  discoverGateways,
-  discoverRoutes,
-  encode,
-  encodeRelay,
   errorMapper,
-  gatewaysOf,
-  guardsOf,
-  isCompressibleType,
-  isErrorFilter,
-  isGateway,
-  joinPath,
   mergeMeta,
   meta,
   metaKey,
-  metaOf,
-  negotiate,
-  normalizePath,
-  normalizePrefix,
-  observe,
-  preflight,
-  routesOf,
-  toErrorMapper,
-  withCors,
-  withUpgradeRoutes
+  metaOf
 };

package/dist/internal.d.ts

@@ -1,9 +1,9 @@
 /**
- * What the framework calls on itself. Every symbol here is still reachable from
- * the package barrel, deprecated, and leaves it in 4.0.
+ * What the framework calls on itself, and the only place it is exported from.
  *
- * The barrel is a semver promise, and 173 of them was more than this package
- * meant to make. What stays public is the surface an app writes against:
+ * The barrel was a semver promise 173 symbols wide, which is more than this
+ * package meant to make. What stays public there is the surface an app writes
+ * against:
  * decorators, options, contracts, errors, modules and the metadata helpers a
  * user's own guard reads. What is here is route-table construction, the
  * middleware fold, the relay codec and the discovery readers - things

package/dist/internal.js

@@ -1,10 +1,12 @@
 // @bun
 import {
+  HIDDEN,
   HandlerKind,
   HiddenHealthController,
+  PUBLIC,
+  ROLES,
   assertNoCollisions,
   assertNoGatewayCollisions,
-  backoffDelay,
   buildContext,
   buildGateways,
   buildRoutes,
@@ -21,28 +23,91 @@ import {
   discoverRoutes,
   encode,
   encodeRelay,
-  executeWithRetry,
-  gatewaysOf,
   guardsOf,
   isCompressibleType,
   isErrorFilter,
   isGateway,
-  isJsonBody,
-  isPlainObject,
-  isRetryableStatus,
   joinPath,
   negotiate,
   normalizePath,
   normalizePrefix,
   observe,
   preflight,
-  retryAfterMs,
-  routesOf,
-  safeStringify,
   toErrorMapper,
   withCors,
   withUpgradeRoutes
-} from "./chunk-ywdpxbkf.js";
+} from "./chunk-f6pw36av.js";
+import {
+  backoffDelay,
+  executeWithRetry,
+  isJsonBody,
+  isPlainObject,
+  isRetryableStatus,
+  retryAfterMs,
+  safeStringify
+} from "./chunk-b699cfes.js";
+import"./chunk-sz4pvqxy.js";
+// src/inspect.ts
+import {
+  collectModules,
+  dependenciesOf,
+  readControllers
+} from "@dunx/core";
+var vendorOf = (schema) => schema?.["~standard"]?.vendor;
+var validatesIn = (options) => {
+  const body = vendorOf(options?.body);
+  const query = vendorOf(options?.query);
+  const params = vendorOf(options?.params);
+  return {
+    ...body === undefined ? {} : { body },
+    ...query === undefined ? {} : { query },
+    ...params === undefined ? {} : { params }
+  };
+};
+var rolesIn = (route) => {
+  const roles = route.meta?.get(ROLES.id);
+  if (roles === undefined || roles === null)
+    return null;
+  return (Array.isArray(roles) ? roles : [roles]).map(String);
+};
+var nodeFor = (route, module) => ({
+  method: route.method,
+  path: route.path,
+  controller: route.controller,
+  handler: route.handlerName,
+  module,
+  public: route.meta?.get(PUBLIC.id) === true,
+  roles: rolesIn(route),
+  guards: (route.guards ?? []).map((guard) => guard.name),
+  hidden: route.meta?.get(HIDDEN.id) === true,
+  validates: validatesIn(route.options),
+  status: route.options?.status ?? null,
+  responses: Object.keys(route.options?.response ?? {}).map(Number)
+});
+var routesOf = (root) => collectModules(root).flatMap((module) => readControllers(module).flatMap((controller) => {
+  const { prototype } = controller;
+  return discoverRoutes(Object.create(prototype)).map((route) => nodeFor(route, module.name));
+}));
+var gatewayFor = (ctor, module) => {
+  const { name, path, handlers } = discoverGateway(Object.create(ctor.prototype));
+  return {
+    name,
+    path,
+    module,
+    dependencies: dependenciesOf(ctor),
+    handlers: handlers.map((handler) => ({
+      kind: handler.kind,
+      event: handler.event ?? null,
+      method: handler.method
+    }))
+  };
+};
+var classOf = (entry) => {
+  if (typeof entry === "function")
+    return entry;
+  return entry.provider.kind === "class" ? entry.provider.ctor : undefined;
+};
+var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map(classOf).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
 export {
   HandlerKind,
   HiddenHealthController,

package/dist/server/client-address.d.ts

@@ -1,5 +1,5 @@
 import type { BunRequest, Server } from 'bun';
-export interface AddressSource {
+interface AddressSource {
     readonly server: Server<unknown>;
     readonly trustProxy: boolean | number;
 }
@@ -8,6 +8,9 @@ export interface AddressSource {
  * right of `X-Forwarded-For` by the number of trusted hops, never from the left: a
  * client can send anything, and only the entries a proxy appended carry weight.
  *
+ * An IPv4-mapped IPv6 address is returned in its IPv4 form: `::ffff:10.0.0.1`
+ * comes back as `10.0.0.1`, from the header and from the socket alike.
+ *
  * Bound by `HttpFactory`'s global wrapper, which is not optional under module
  * scoping - an unbound class self-binds into whichever scope asks first, so a
  * second module injecting it was a boot error.
@@ -17,3 +20,4 @@ export declare class ClientAddress {
 }
 /** Internal: `listen()` hands the bound server to the resolved singleton. */
 export declare const attachAddressSource: (target: ClientAddress, source: AddressSource) => void;
+export {};

package/dist/static/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type StaticOptionsInit } from './options.js';
 /**
  * Serves a directory. Like the dashboard, it does not register itself:
@@ -46,7 +46,5 @@ import { type StaticOptionsInit } from './options.js';
 export declare class StaticModule {
     static forRoot(init: StaticOptionsInit): DynamicModule;
     /** `forRoot` with the root read off the container - a config value, usually. */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<StaticOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
-    }): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<StaticOptionsInit, D>): DynamicModule;
 }

package/dist/throttle/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type ThrottleOptionsInit } from './options.js';
 /**
  * The decorator, the guard, the counter and its options.
@@ -27,7 +27,5 @@ import { type ThrottleOptionsInit } from './options.js';
 export declare class ThrottleModule {
     static forRoot(init: ThrottleOptionsInit): DynamicModule;
     /** `forRoot` with the limit read off the container - a config value, usually. */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<ThrottleOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
-    }): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<ThrottleOptionsInit, D>): DynamicModule;
 }

package/dist/ws/adapter.d.ts

@@ -31,10 +31,11 @@ export interface WebSocketRuntime {
      */
     readonly warnings: readonly string[];
 }
-export interface GatewaySummary {
+interface GatewaySummary {
     readonly name: string;
     readonly path: string;
     /** `@OnMessage('name')` events. A raw catch-all has no name to report. */
     readonly events: readonly string[];
 }
 export declare const buildWebSocket: (discovered: readonly DiscoveredGateway[], options?: SocketOptions, middleware?: readonly SocketMiddleware[]) => WebSocketRuntime;
+export {};

package/dist/ws/discover.d.ts

@@ -1,4 +1,4 @@
-import { type Ctor, type InjectionToken, type ResolvedModule } from '@dunx/core';
+import { type InjectionToken, type ResolvedModule } from '@dunx/core';
 import { type HandlerKind } from './marker.js';
 /**
  * A discovered handler, already bound to its instance. Every kind has a different
@@ -26,12 +26,6 @@ export declare const normalizePath: (path: string) => string;
  * handler is bound off the instance.
  */
 export declare const discoverGateway: (instance: object) => DiscoveredGateway;
-/**
- * The name of the first handler a class declares, without constructing it. A
- * provider that declares one but is not a gateway would silently never receive a
- * frame, so that becomes a boot error naming the method.
- */
-export declare const findHandlerMethod: (ctor: Ctor<unknown>) => string | undefined;
 /**
  * Gateways are declared in `@Module({ providers })` like any other injectable and
  * found here by their marker - the same discovery-by-inspection controllers get,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -62,7 +62,7 @@
     "@dunx/core": "workspace:*"
   },
   "peerDependencies": {
-    "@dunx/core": "^3.0.0",
+    "@dunx/core": "^3.0.2",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {