@velajs/vela 1.19.0 → 1.19.1

package/dist/decorators-C8YBFCIk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators-C8YBFCIk.js","names":[],"sources":["../src/module/decorators.ts"],"sourcesContent":["import { MetadataRegistry } from '../registry/metadata.registry';\nimport type { Constructor, DynamicModule, ModuleMetadata, ModuleOptions } from '../registry/types';\n\nexport function Global(): ClassDecorator {\n  return (target) => {\n    const ctor = target as unknown as Constructor;\n    const existing = MetadataRegistry.getModuleOptions(ctor);\n    MetadataRegistry.setModuleOptions(ctor, { ...existing, isGlobal: true });\n  };\n}\n\nexport function Module(options: ModuleOptions = {}): ClassDecorator {\n  return (target) => {\n    MetadataRegistry.setModuleOptions(target as unknown as Constructor, {\n      imports: options.imports,\n      providers: options.providers,\n      controllers: options.controllers,\n      exports: options.exports,\n      isGlobal: options.isGlobal,\n      lazy: options.lazy,\n    });\n  };\n}\n\nexport function isModule(target: Constructor): boolean {\n  return MetadataRegistry.getModuleOptions(target) !== undefined;\n}\n\n/**\n * Normalize a DynamicModule, defaulting `key` to `\"default\"`. Module authors\n * call this from `forRoot()` so the loader always sees an explicit key.\n */\nexport function defineDynamicModule(input: DynamicModule): DynamicModule {\n  return { ...input, key: input.key ?? 'default' };\n}\n\nexport function getModuleMetadata(target: Constructor): ModuleMetadata | undefined {\n  const options = MetadataRegistry.getModuleOptions(target);\n  if (!options) return undefined;\n\n  return {\n    providers: options.providers ?? [],\n    controllers: options.controllers ?? [],\n    imports: options.imports ?? [],\n    exports: options.exports ?? [],\n    isGlobal: options.isGlobal === true,\n    lazy: options.lazy === true,\n  };\n}\n"],"mappings":";;AAGA,SAAgB,SAAyB;CACvC,QAAQ,WAAW;EACjB,MAAM,OAAO;EACb,MAAM,WAAW,iBAAiB,iBAAiB,IAAI;EACvD,iBAAiB,iBAAiB,MAAM;GAAE,GAAG;GAAU,UAAU;EAAK,CAAC;CACzE;AACF;AAEA,SAAgB,OAAO,UAAyB,CAAC,GAAmB;CAClE,QAAQ,WAAW;EACjB,iBAAiB,iBAAiB,QAAkC;GAClE,SAAS,QAAQ;GACjB,WAAW,QAAQ;GACnB,aAAa,QAAQ;GACrB,SAAS,QAAQ;GACjB,UAAU,QAAQ;GAClB,MAAM,QAAQ;EAChB,CAAC;CACH;AACF;AAEA,SAAgB,SAAS,QAA8B;CACrD,OAAO,iBAAiB,iBAAiB,MAAM,MAAM,KAAA;AACvD;;;;;AAMA,SAAgB,oBAAoB,OAAqC;CACvE,OAAO;EAAE,GAAG;EAAO,KAAK,MAAM,OAAO;CAAU;AACjD;AAEA,SAAgB,kBAAkB,QAAiD;CACjF,MAAM,UAAU,iBAAiB,iBAAiB,MAAM;CACxD,IAAI,CAAC,SAAS,OAAO,KAAA;CAErB,OAAO;EACL,WAAW,QAAQ,aAAa,CAAC;EACjC,aAAa,QAAQ,eAAe,CAAC;EACrC,SAAS,QAAQ,WAAW,CAAC;EAC7B,SAAS,QAAQ,WAAW,CAAC;EAC7B,UAAU,QAAQ,aAAa;EAC/B,MAAM,QAAQ,SAAS;CACzB;AACF"}

package/dist/define-module-NOyOZNXD.js

@@ -0,0 +1,235 @@
+import { C as InjectionToken, _ as APP_GUARD, b as APP_PIPE, g as APP_FILTER, v as APP_INTERCEPTOR, y as APP_MIDDLEWARE } from "./decorate-GcSMAbKn.js";
+//#region src/module/stable-hash.ts
+/**
+* Deterministic, sync, edge-safe hash for module-instance discrimination.
+*
+* Walks values (objects/arrays/primitives/functions/class instances) into a
+* sorted, source-fingerprinting JSON string, then runs FNV-1a (32-bit) for a
+* compact 8-hex-char output.
+*
+* Functions and class instances are tolerated — they become `__fn:source` or
+* `__cls:ClassName` markers. Two distinct closures with the same source code
+* collide; module authors who care about that should pass an explicit `key`.
+*
+* Not cryptographic. Sufficient for discriminating module instances within
+* an app.
+*/
+function stableHash(value) {
+	return fnv1a(stableStringify(value));
+}
+function stableStringify(value) {
+	if (value === null || value === void 0) return JSON.stringify(value) ?? "undefined";
+	if (typeof value === "function") return `__fn:${fnv1a(value.toString())}`;
+	if (typeof value === "symbol") return `__sym:${value.description ?? ""}`;
+	if (typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return "[" + value.map(stableStringify).join(",") + "]";
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== null && proto !== Object.prototype) return `__cls:${proto?.constructor?.name ?? "AnonymousClass"}` + stringifyOwnProps(value);
+	return stringifyOwnProps(value);
+}
+function stringifyOwnProps(obj) {
+	return "{" + Object.keys(obj).sort().map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+function fnv1a(s) {
+	let h = 2166136261;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(16).padStart(8, "0");
+}
+//#endregion
+//#region src/module/define-module.ts
+const DEFAULT_EXTRAS = { isGlobal: false };
+const DEFAULT_TRANSFORM = (def, extras) => extras.isGlobal ? {
+	...def,
+	global: true
+} : def;
+const GLOBAL_SLOT_TOKENS = {
+	guards: APP_GUARD,
+	pipes: APP_PIPE,
+	interceptors: APP_INTERCEPTOR,
+	filters: APP_FILTER,
+	middleware: APP_MIDDLEWARE
+};
+/** Lower a `global:` slot to `APP_*` provider registrations. */
+function lowerGlobalSlot(slot) {
+	const out = [];
+	for (const kind of Object.keys(GLOBAL_SLOT_TOKENS)) for (const component of slot[kind] ?? []) {
+		const token = GLOBAL_SLOT_TOKENS[kind];
+		if (typeof component === "function") out.push(component, {
+			provide: token,
+			useExisting: component
+		});
+		else out.push({
+			provide: token,
+			useValue: component
+		});
+	}
+	return out;
+}
+const ASYNC_OPTION_KEYS = /* @__PURE__ */ new Set([
+	"key",
+	"imports",
+	"inject",
+	"useFactory",
+	"useClass",
+	"useExisting"
+]);
+/**
+* The one blessed module-authoring engine. Generates `forRoot` AND
+* `forRootAsync` statics with: `stableHash` key derivation (multi-instance
+* dedup that survives HMR), typed `inject` tuple inference on the async
+* factory, an `isGlobal` extra, and — the piece `ConfigurableModuleBuilder`
+* could not express — providers/controllers/imports/exports/global components
+* computed **as functions of the options**.
+*
+* ```ts
+* const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = defineModule<CorsOptions>({
+*   name: 'Cors',
+*   setup: ({ OPTIONS }) => ({
+*     providers: [{
+*       provide: APP_MIDDLEWARE,
+*       useFactory: (o: CorsOptions) => buildCorsMiddleware(o),
+*       inject: [OPTIONS],
+*     }],
+*     exports: [OPTIONS],
+*   }),
+* });
+* export class CorsModule extends ConfigurableModuleClass {}
+* ```
+*
+* `ConfigurableModuleBuilder` remains supported (NestJS parity) and is a thin
+* adapter over this engine.
+*/
+function defineModule(spec) {
+	const optionsToken = spec.optionsToken ?? new InjectionToken(`${spec.name}_MODULE_OPTIONS`);
+	const syncName = spec.methodName ?? "forRoot";
+	const asyncName = `${syncName}Async`;
+	const factoryMethodName = spec.factoryMethodName ?? "create";
+	const extrasDefaults = spec.extras ?? DEFAULT_EXTRAS;
+	const transform = spec.transform ?? DEFAULT_TRANSFORM;
+	const deriveKey = (explicit, structural) => explicit ?? spec.key?.(structural) ?? stableHash(structural);
+	const applyLazy = (definition, callSiteLazy) => spec.lazy === true || callSiteLazy === true ? {
+		...definition,
+		lazy: true
+	} : definition;
+	const applyContributions = (definition, structural, key) => {
+		if (!spec.setup) return definition;
+		const contributions = spec.setup({
+			OPTIONS: optionsToken,
+			options: structural,
+			key
+		});
+		const providers = [
+			...definition.providers ?? [],
+			...contributions.providers ?? [],
+			...contributions.global ? lowerGlobalSlot(contributions.global) : []
+		];
+		return {
+			...definition,
+			providers,
+			controllers: [...definition.controllers ?? [], ...contributions.controllers ?? []],
+			imports: [...definition.imports ?? [], ...contributions.imports ?? []],
+			exports: [...definition.exports ?? [], ...contributions.exports ?? []]
+		};
+	};
+	class GeneratedModuleClass {}
+	Object.defineProperty(GeneratedModuleClass, "name", { value: `${spec.name}ModuleHost` });
+	Object.defineProperty(GeneratedModuleClass, syncName, {
+		configurable: true,
+		writable: true,
+		enumerable: false,
+		value(options = {}) {
+			const { key: explicitKey, ...rest } = options;
+			const key = deriveKey(explicitKey, rest);
+			const definition = {
+				module: this,
+				key,
+				providers: [{
+					provide: optionsToken,
+					useValue: rest
+				}]
+			};
+			return applyLazy(transform(applyContributions(definition, rest, key), {
+				...extrasDefaults,
+				...rest
+			}), rest.lazy);
+		}
+	});
+	Object.defineProperty(GeneratedModuleClass, asyncName, {
+		configurable: true,
+		writable: true,
+		enumerable: false,
+		value(options = {}) {
+			const bag = options;
+			const structural = {};
+			for (const [k, v] of Object.entries(bag)) if (!ASYNC_OPTION_KEYS.has(k)) structural[k] = v;
+			const key = deriveKey(bag.key, spec.key ? structural : {
+				inject: bag.inject,
+				useFactory: bag.useFactory,
+				useClass: bag.useClass,
+				useExisting: bag.useExisting,
+				...structural
+			});
+			const definition = {
+				module: this,
+				key,
+				imports: bag.imports ?? [],
+				providers: buildAsyncOptionsProviders(optionsToken, factoryMethodName, bag, structural)
+			};
+			return applyLazy(transform(applyContributions(definition, structural, key), {
+				...extrasDefaults,
+				...structural
+			}), structural.lazy);
+		}
+	});
+	return {
+		ConfigurableModuleClass: GeneratedModuleClass,
+		MODULE_OPTIONS_TOKEN: optionsToken,
+		OPTIONS_TYPE: void 0,
+		ASYNC_OPTIONS_TYPE: void 0
+	};
+}
+/**
+* Lower `useFactory`/`useClass`/`useExisting` async options into provider
+* registrations. Structural fields from the call site merge UNDER the resolved
+* options (`{ ...structural, ...resolved }`) so sync-declared fields act as
+* defaults and the factory stays authoritative.
+*/
+function buildAsyncOptionsProviders(optionsToken, factoryMethodName, async, structural = {}) {
+	const hasStructural = Object.keys(structural).length > 0;
+	const merge = (resolved) => resolved instanceof Promise ? resolved.then((o) => ({
+		...structural,
+		...o
+	})) : {
+		...structural,
+		...resolved
+	};
+	if (async.useFactory) {
+		const factory = async.useFactory;
+		return [{
+			provide: optionsToken,
+			useFactory: hasStructural ? (...deps) => merge(factory(...deps)) : factory,
+			inject: async.inject ?? []
+		}];
+	}
+	if (async.useClass) {
+		const factoryClass = async.useClass;
+		return [factoryClass, {
+			provide: optionsToken,
+			useFactory: (instance) => merge(instance[factoryMethodName]()),
+			inject: [factoryClass]
+		}];
+	}
+	if (async.useExisting) return [{
+		provide: optionsToken,
+		useFactory: (instance) => merge(instance[factoryMethodName]()),
+		inject: [async.useExisting]
+	}];
+	throw new Error("Async module options require one of `useFactory`, `useClass`, or `useExisting`.");
+}
+//#endregion
+export { defineModule as n, stableHash as r, buildAsyncOptionsProviders as t };
+
+//# sourceMappingURL=define-module-NOyOZNXD.js.map

package/dist/define-module-NOyOZNXD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-module-NOyOZNXD.js","names":[],"sources":["../src/module/stable-hash.ts","../src/module/define-module.ts"],"sourcesContent":["/**\n * Deterministic, sync, edge-safe hash for module-instance discrimination.\n *\n * Walks values (objects/arrays/primitives/functions/class instances) into a\n * sorted, source-fingerprinting JSON string, then runs FNV-1a (32-bit) for a\n * compact 8-hex-char output.\n *\n * Functions and class instances are tolerated — they become `__fn:source` or\n * `__cls:ClassName` markers. Two distinct closures with the same source code\n * collide; module authors who care about that should pass an explicit `key`.\n *\n * Not cryptographic. Sufficient for discriminating module instances within\n * an app.\n */\nexport function stableHash(value: unknown): string {\n  return fnv1a(stableStringify(value));\n}\n\nfunction stableStringify(value: unknown): string {\n  if (value === null || value === undefined) return JSON.stringify(value) ?? 'undefined';\n\n  if (typeof value === 'function') {\n    // Source-fingerprint via FNV-1a so we don't bloat the parent hash; this\n    // keeps two distinct factory functions distinguishable as long as their\n    // source differs (the common case). Names are intentionally excluded —\n    // two arrow functions with the same body should dedup.\n    return `__fn:${fnv1a(value.toString())}`;\n  }\n\n  if (typeof value === 'symbol') {\n    return `__sym:${value.description ?? ''}`;\n  }\n\n  if (typeof value !== 'object') return JSON.stringify(value);\n\n  if (Array.isArray(value)) {\n    return '[' + value.map(stableStringify).join(',') + ']';\n  }\n\n  const proto = Object.getPrototypeOf(value);\n  if (proto !== null && proto !== Object.prototype) {\n    const name: string = proto?.constructor?.name ?? 'AnonymousClass';\n    return `__cls:${name}` + stringifyOwnProps(value as Record<string, unknown>);\n  }\n\n  return stringifyOwnProps(value as Record<string, unknown>);\n}\n\nfunction stringifyOwnProps(obj: Record<string, unknown>): string {\n  const keys = Object.keys(obj).sort();\n  const parts = keys.map((k) => JSON.stringify(k) + ':' + stableStringify(obj[k]));\n  return '{' + parts.join(',') + '}';\n}\n\nfunction fnv1a(s: string): string {\n  let h = 0x811c9dc5;\n  for (let i = 0; i < s.length; i++) {\n    h ^= s.charCodeAt(i);\n    h = Math.imul(h, 0x01000193);\n  }\n  return (h >>> 0).toString(16).padStart(8, '0');\n}\n","import { InjectionToken, type ProviderOptions, type Token, type Type } from '../container/types';\nimport {\n  APP_FILTER,\n  APP_GUARD,\n  APP_INTERCEPTOR,\n  APP_MIDDLEWARE,\n  APP_PIPE,\n} from '../pipeline/tokens';\nimport type { ComponentInstance, DynamicModule, ModuleImport } from '../registry/types';\nimport type {\n  ConfigurableModuleAsyncOptions,\n  ConfigurableModuleClassType,\n  ConfigurableModuleExtras,\n  ConfigurableModuleExtrasTransform,\n  ConfigurableModuleHost,\n} from './configurable-module.types';\nimport { stableHash } from './stable-hash';\n\n/** The `global:` slot's component groups, lowered to `APP_*` registrations. */\nexport interface GlobalComponentSlot {\n  guards?: Array<Type | ComponentInstance>;\n  pipes?: Array<Type | ComponentInstance>;\n  interceptors?: Array<Type | ComponentInstance>;\n  filters?: Array<Type | ComponentInstance>;\n  middleware?: Array<Type | ComponentInstance>;\n}\n\n/** What a module instance contributes, computed from its call-time options. */\nexport interface ModuleContributions {\n  providers?: Array<Type | ProviderOptions>;\n  controllers?: Type[];\n  imports?: ModuleImport[];\n  exports?: Array<Type | InjectionToken>;\n  /**\n   * Standardized global-component registration — the one idiom replacing both\n   * the `@Module({ providers: [{ provide: APP_GUARD, useExisting: X }] })`\n   * pattern and the conditional-push-into-forRoot pattern. Class entries are\n   * registered as providers and wired via `useExisting`; instances via `useValue`.\n   */\n  global?: GlobalComponentSlot;\n}\n\nexport interface ModuleSetupContext<Opts> {\n  /** The options token — derived providers do `inject: [OPTIONS]`. */\n  readonly OPTIONS: InjectionToken<Opts>;\n  /**\n   * Structural options known at call time. For `forRoot` this is the full\n   * bag; for `forRootAsync` it is only the structural fields passed alongside\n   * the factory (the DI-resolved options exist only at resolution time —\n   * read them through `OPTIONS`, never here).\n   */\n  readonly options: Partial<Opts>;\n  /** The instance key in effect (for deriving per-instance token names). */\n  readonly key: string;\n}\n\nexport interface DefineModuleSpec<\n  Opts,\n  Extras extends ConfigurableModuleExtras = { isGlobal?: boolean },\n  MethodKey extends string = 'forRoot',\n  FactoryMethodKey extends string = 'create',\n> {\n  /** Names the generated base class, the minted options token, and diagnostics. */\n  name: string;\n  /**\n   * Reuse an existing options token instead of minting one — critical for\n   * migrations so the module's public token keeps its identity.\n   */\n  optionsToken?: InjectionToken<Opts>;\n  /**\n   * Structural contributions as a function of the call-time options. Runs at\n   * `forRoot`/`forRootAsync` call time, once per module instance.\n   */\n  setup?: (ctx: ModuleSetupContext<Opts>) => ModuleContributions;\n  /**\n   * Dedup key from the structural options. Defaults to `stableHash(options)`.\n   * Modules whose options carry stateful instances (drivers, registries)\n   * should derive from the stable identifying subset — or document that\n   * callers pass an explicit `key` for multi-instance setups.\n   */\n  key?: (options: Partial<Opts>) => string;\n  /** Call-site extras defaults (default `{ isGlobal: false }`). */\n  extras?: Extras;\n  /** Reshape the definition from resolved extras (default: `isGlobal` → `global: true`). */\n  transform?: ConfigurableModuleExtrasTransform<Extras>;\n  /** Rename the sync static (default `forRoot`); the async static becomes `<name>Async`. */\n  methodName?: MethodKey;\n  /** Method a `useClass`/`useExisting` options factory must implement (default `create`). */\n  factoryMethodName?: FactoryMethodKey;\n  /**\n   * Default every generated module instance to deferred (first-use)\n   * materialization. Call sites can also opt in per instance by passing\n   * `lazy: true` alongside the options (recognized like `isGlobal`).\n   * See MODULE_AUTHORING.md \"Lazy modules\".\n   */\n  lazy?: boolean;\n}\n\nconst DEFAULT_EXTRAS = { isGlobal: false } as const;\nconst DEFAULT_TRANSFORM: ConfigurableModuleExtrasTransform<{ isGlobal?: boolean }> = (\n  def,\n  extras,\n) => (extras.isGlobal ? { ...def, global: true } : def);\n\nconst GLOBAL_SLOT_TOKENS = {\n  guards: APP_GUARD,\n  pipes: APP_PIPE,\n  interceptors: APP_INTERCEPTOR,\n  filters: APP_FILTER,\n  middleware: APP_MIDDLEWARE,\n} as const;\n\n/** Lower a `global:` slot to `APP_*` provider registrations. */\nfunction lowerGlobalSlot(slot: GlobalComponentSlot): Array<Type | ProviderOptions> {\n  const out: Array<Type | ProviderOptions> = [];\n  for (const kind of Object.keys(GLOBAL_SLOT_TOKENS) as Array<keyof GlobalComponentSlot>) {\n    for (const component of slot[kind] ?? []) {\n      const token = GLOBAL_SLOT_TOKENS[kind];\n      if (typeof component === 'function') {\n        out.push(component as Type, { provide: token, useExisting: component as Token });\n      } else {\n        out.push({ provide: token, useValue: component });\n      }\n    }\n  }\n  return out;\n}\n\nconst ASYNC_OPTION_KEYS = new Set([\n  'key',\n  'imports',\n  'inject',\n  'useFactory',\n  'useClass',\n  'useExisting',\n]);\n\n/**\n * The one blessed module-authoring engine. Generates `forRoot` AND\n * `forRootAsync` statics with: `stableHash` key derivation (multi-instance\n * dedup that survives HMR), typed `inject` tuple inference on the async\n * factory, an `isGlobal` extra, and — the piece `ConfigurableModuleBuilder`\n * could not express — providers/controllers/imports/exports/global components\n * computed **as functions of the options**.\n *\n * ```ts\n * const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = defineModule<CorsOptions>({\n *   name: 'Cors',\n *   setup: ({ OPTIONS }) => ({\n *     providers: [{\n *       provide: APP_MIDDLEWARE,\n *       useFactory: (o: CorsOptions) => buildCorsMiddleware(o),\n *       inject: [OPTIONS],\n *     }],\n *     exports: [OPTIONS],\n *   }),\n * });\n * export class CorsModule extends ConfigurableModuleClass {}\n * ```\n *\n * `ConfigurableModuleBuilder` remains supported (NestJS parity) and is a thin\n * adapter over this engine.\n */\nexport function defineModule<\n  Opts,\n  Extras extends ConfigurableModuleExtras = { isGlobal?: boolean },\n  MethodKey extends string = 'forRoot',\n  FactoryMethodKey extends string = 'create',\n>(\n  spec: DefineModuleSpec<Opts, Extras, MethodKey, FactoryMethodKey>,\n): ConfigurableModuleHost<Opts, MethodKey, FactoryMethodKey, Extras> {\n  const optionsToken = spec.optionsToken ?? new InjectionToken<Opts>(`${spec.name}_MODULE_OPTIONS`);\n  const syncName = spec.methodName ?? 'forRoot';\n  const asyncName = `${syncName}Async`;\n  const factoryMethodName = spec.factoryMethodName ?? 'create';\n  const extrasDefaults = (spec.extras ?? DEFAULT_EXTRAS) as ConfigurableModuleExtras;\n  const transform = (spec.transform ??\n    DEFAULT_TRANSFORM) as ConfigurableModuleExtrasTransform<ConfigurableModuleExtras>;\n\n  const deriveKey = (explicit: string | undefined, structural: Record<string, unknown>): string =>\n    explicit ?? spec.key?.(structural as Partial<Opts>) ?? stableHash(structural);\n\n  // Laziness is OR-composed: the spec defaults it, a call site can add it.\n  const applyLazy = (definition: DynamicModule, callSiteLazy: unknown): DynamicModule =>\n    spec.lazy === true || callSiteLazy === true ? { ...definition, lazy: true } : definition;\n\n  const applyContributions = (\n    definition: DynamicModule,\n    structural: Record<string, unknown>,\n    key: string,\n  ): DynamicModule => {\n    if (!spec.setup) return definition;\n    const contributions = spec.setup({\n      OPTIONS: optionsToken,\n      options: structural as Partial<Opts>,\n      key,\n    });\n    const providers = [\n      ...(definition.providers ?? []),\n      ...(contributions.providers ?? []),\n      ...(contributions.global ? lowerGlobalSlot(contributions.global) : []),\n    ];\n    return {\n      ...definition,\n      providers,\n      controllers: [...(definition.controllers ?? []), ...(contributions.controllers ?? [])],\n      imports: [...(definition.imports ?? []), ...(contributions.imports ?? [])],\n      exports: [...(definition.exports ?? []), ...(contributions.exports ?? [])],\n    };\n  };\n\n  class GeneratedModuleClass {}\n  Object.defineProperty(GeneratedModuleClass, 'name', { value: `${spec.name}ModuleHost` });\n\n  Object.defineProperty(GeneratedModuleClass, syncName, {\n    configurable: true,\n    writable: true,\n    enumerable: false,\n    value(this: unknown, options: Record<string, unknown> = {}): DynamicModule {\n      const { key: explicitKey, ...rest } = options;\n      const key = deriveKey(explicitKey as string | undefined, rest);\n      const definition: DynamicModule = {\n        module: this as DynamicModule['module'],\n        key,\n        providers: [{ provide: optionsToken as Token, useValue: rest }],\n      };\n      return applyLazy(\n        transform(applyContributions(definition, rest, key), {\n          ...extrasDefaults,\n          ...rest,\n        }),\n        rest.lazy,\n      );\n    },\n  });\n\n  Object.defineProperty(GeneratedModuleClass, asyncName, {\n    configurable: true,\n    writable: true,\n    enumerable: false,\n    value(this: unknown, options: ConfigurableModuleAsyncOptions<Opts> = {}): DynamicModule {\n      const bag = options as ConfigurableModuleAsyncOptions<Opts> & Record<string, unknown>;\n      const structural: Record<string, unknown> = {};\n      for (const [k, v] of Object.entries(bag)) {\n        if (!ASYNC_OPTION_KEYS.has(k)) structural[k] = v;\n      }\n      const key = deriveKey(\n        bag.key,\n        // Async factories aren't structurally hashable in a useful way, so the\n        // default key hashes the async wiring + structural fields — same\n        // instance-identity semantics ConfigurableModuleBuilder always had.\n        spec.key\n          ? structural\n          : {\n              inject: bag.inject,\n              useFactory: bag.useFactory,\n              useClass: bag.useClass,\n              useExisting: bag.useExisting,\n              ...structural,\n            },\n      );\n      const definition: DynamicModule = {\n        module: this as DynamicModule['module'],\n        key,\n        imports: bag.imports ?? [],\n        providers: buildAsyncOptionsProviders<Opts>(\n          optionsToken as Token,\n          factoryMethodName,\n          bag,\n          structural,\n        ),\n      };\n      return applyLazy(\n        transform(applyContributions(definition, structural, key), {\n          ...extrasDefaults,\n          ...structural,\n        }),\n        structural.lazy,\n      );\n    },\n  });\n\n  return {\n    ConfigurableModuleClass: GeneratedModuleClass as unknown as ConfigurableModuleClassType<\n      Opts,\n      MethodKey,\n      FactoryMethodKey,\n      Extras\n    >,\n    MODULE_OPTIONS_TOKEN: optionsToken,\n    // Type-only sentinels — never read at runtime.\n    OPTIONS_TYPE: undefined as never,\n    ASYNC_OPTIONS_TYPE: undefined as never,\n  };\n}\n\n/**\n * Lower `useFactory`/`useClass`/`useExisting` async options into provider\n * registrations. Structural fields from the call site merge UNDER the resolved\n * options (`{ ...structural, ...resolved }`) so sync-declared fields act as\n * defaults and the factory stays authoritative.\n */\nexport function buildAsyncOptionsProviders<Opts>(\n  optionsToken: Token,\n  factoryMethodName: string,\n  async: Pick<\n    ConfigurableModuleAsyncOptions<Opts>,\n    'inject' | 'useFactory' | 'useClass' | 'useExisting'\n  >,\n  structural: Record<string, unknown> = {},\n): Array<ProviderOptions> {\n  const hasStructural = Object.keys(structural).length > 0;\n  const merge = (resolved: Opts | Promise<Opts>): Opts | Promise<Opts> =>\n    resolved instanceof Promise\n      ? resolved.then((o) => ({ ...structural, ...o }) as Opts)\n      : ({ ...structural, ...resolved } as Opts);\n\n  if (async.useFactory) {\n    const factory = async.useFactory;\n    return [\n      {\n        provide: optionsToken,\n        // No structural fields → pass the caller's factory through untouched\n        // (function identity preserved; nothing to merge).\n        useFactory: hasStructural\n          ? (...deps: unknown[]) =>\n              merge((factory as (...a: unknown[]) => Opts | Promise<Opts>)(...deps))\n          : (factory as (...deps: unknown[]) => Opts | Promise<Opts>),\n        inject: (async.inject ?? []) as Token[],\n      },\n    ];\n  }\n  if (async.useClass) {\n    const factoryClass = async.useClass;\n    return [\n      factoryClass as unknown as ProviderOptions,\n      {\n        provide: optionsToken,\n        useFactory: (instance: Record<string, () => Opts | Promise<Opts>>) =>\n          merge(instance[factoryMethodName]!()),\n        inject: [factoryClass as unknown as Token],\n      },\n    ];\n  }\n  if (async.useExisting) {\n    return [\n      {\n        provide: optionsToken,\n        useFactory: (instance: Record<string, () => Opts | Promise<Opts>>) =>\n          merge(instance[factoryMethodName]!()),\n        inject: [async.useExisting as unknown as Token],\n      },\n    ];\n  }\n  throw new Error(\n    'Async module options require one of `useFactory`, `useClass`, or `useExisting`.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,SAAgB,WAAW,OAAwB;CACjD,OAAO,MAAM,gBAAgB,KAAK,CAAC;AACrC;AAEA,SAAS,gBAAgB,OAAwB;CAC/C,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO,KAAK,UAAU,KAAK,KAAK;CAE3E,IAAI,OAAO,UAAU,YAKnB,OAAO,QAAQ,MAAM,MAAM,SAAS,CAAC;CAGvC,IAAI,OAAO,UAAU,UACnB,OAAO,SAAS,MAAM,eAAe;CAGvC,IAAI,OAAO,UAAU,UAAU,OAAO,KAAK,UAAU,KAAK;CAE1D,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,MAAM,IAAI,eAAe,CAAC,CAAC,KAAK,GAAG,IAAI;CAGtD,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,IAAI,UAAU,QAAQ,UAAU,OAAO,WAErC,OAAO,SADc,OAAO,aAAa,QAAQ,qBACxB,kBAAkB,KAAgC;CAG7E,OAAO,kBAAkB,KAAgC;AAC3D;AAEA,SAAS,kBAAkB,KAAsC;CAG/D,OAAO,MAFM,OAAO,KAAK,GAAG,CAAC,CAAC,KACb,CAAC,CAAC,KAAK,MAAM,KAAK,UAAU,CAAC,IAAI,MAAM,gBAAgB,IAAI,EAAE,CAC7D,CAAC,CAAC,KAAK,GAAG,IAAI;AACjC;AAEA,SAAS,MAAM,GAAmB;CAChC,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;EACjC,KAAK,EAAE,WAAW,CAAC;EACnB,IAAI,KAAK,KAAK,GAAG,QAAU;CAC7B;CACA,QAAQ,MAAM,EAAA,CAAG,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;AAC/C;;;ACqCA,MAAM,iBAAiB,EAAE,UAAU,MAAM;AACzC,MAAM,qBACJ,KACA,WACI,OAAO,WAAW;CAAE,GAAG;CAAK,QAAQ;AAAK,IAAI;AAEnD,MAAM,qBAAqB;CACzB,QAAQ;CACR,OAAO;CACP,cAAc;CACd,SAAS;CACT,YAAY;AACd;;AAGA,SAAS,gBAAgB,MAA0D;CACjF,MAAM,MAAqC,CAAC;CAC5C,KAAK,MAAM,QAAQ,OAAO,KAAK,kBAAkB,GAC/C,KAAK,MAAM,aAAa,KAAK,SAAS,CAAC,GAAG;EACxC,MAAM,QAAQ,mBAAmB;EACjC,IAAI,OAAO,cAAc,YACvB,IAAI,KAAK,WAAmB;GAAE,SAAS;GAAO,aAAa;EAAmB,CAAC;OAE/E,IAAI,KAAK;GAAE,SAAS;GAAO,UAAU;EAAU,CAAC;CAEpD;CAEF,OAAO;AACT;AAEA,MAAM,oCAAoB,IAAI,IAAI;CAChC;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BD,SAAgB,aAMd,MACmE;CACnE,MAAM,eAAe,KAAK,gBAAgB,IAAI,eAAqB,GAAG,KAAK,KAAK,gBAAgB;CAChG,MAAM,WAAW,KAAK,cAAc;CACpC,MAAM,YAAY,GAAG,SAAS;CAC9B,MAAM,oBAAoB,KAAK,qBAAqB;CACpD,MAAM,iBAAkB,KAAK,UAAU;CACvC,MAAM,YAAa,KAAK,aACtB;CAEF,MAAM,aAAa,UAA8B,eAC/C,YAAY,KAAK,MAAM,UAA2B,KAAK,WAAW,UAAU;CAG9E,MAAM,aAAa,YAA2B,iBAC5C,KAAK,SAAS,QAAQ,iBAAiB,OAAO;EAAE,GAAG;EAAY,MAAM;CAAK,IAAI;CAEhF,MAAM,sBACJ,YACA,YACA,QACkB;EAClB,IAAI,CAAC,KAAK,OAAO,OAAO;EACxB,MAAM,gBAAgB,KAAK,MAAM;GAC/B,SAAS;GACT,SAAS;GACT;EACF,CAAC;EACD,MAAM,YAAY;GAChB,GAAI,WAAW,aAAa,CAAC;GAC7B,GAAI,cAAc,aAAa,CAAC;GAChC,GAAI,cAAc,SAAS,gBAAgB,cAAc,MAAM,IAAI,CAAC;EACtE;EACA,OAAO;GACL,GAAG;GACH;GACA,aAAa,CAAC,GAAI,WAAW,eAAe,CAAC,GAAI,GAAI,cAAc,eAAe,CAAC,CAAE;GACrF,SAAS,CAAC,GAAI,WAAW,WAAW,CAAC,GAAI,GAAI,cAAc,WAAW,CAAC,CAAE;GACzE,SAAS,CAAC,GAAI,WAAW,WAAW,CAAC,GAAI,GAAI,cAAc,WAAW,CAAC,CAAE;EAC3E;CACF;CAEA,MAAM,qBAAqB,CAAC;CAC5B,OAAO,eAAe,sBAAsB,QAAQ,EAAE,OAAO,GAAG,KAAK,KAAK,YAAY,CAAC;CAEvF,OAAO,eAAe,sBAAsB,UAAU;EACpD,cAAc;EACd,UAAU;EACV,YAAY;EACZ,MAAqB,UAAmC,CAAC,GAAkB;GACzE,MAAM,EAAE,KAAK,aAAa,GAAG,SAAS;GACtC,MAAM,MAAM,UAAU,aAAmC,IAAI;GAC7D,MAAM,aAA4B;IAChC,QAAQ;IACR;IACA,WAAW,CAAC;KAAE,SAAS;KAAuB,UAAU;IAAK,CAAC;GAChE;GACA,OAAO,UACL,UAAU,mBAAmB,YAAY,MAAM,GAAG,GAAG;IACnD,GAAG;IACH,GAAG;GACL,CAAC,GACD,KAAK,IACP;EACF;CACF,CAAC;CAED,OAAO,eAAe,sBAAsB,WAAW;EACrD,cAAc;EACd,UAAU;EACV,YAAY;EACZ,MAAqB,UAAgD,CAAC,GAAkB;GACtF,MAAM,MAAM;GACZ,MAAM,aAAsC,CAAC;GAC7C,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,GAAG,GACrC,IAAI,CAAC,kBAAkB,IAAI,CAAC,GAAG,WAAW,KAAK;GAEjD,MAAM,MAAM,UACV,IAAI,KAIJ,KAAK,MACD,aACA;IACE,QAAQ,IAAI;IACZ,YAAY,IAAI;IAChB,UAAU,IAAI;IACd,aAAa,IAAI;IACjB,GAAG;GACL,CACN;GACA,MAAM,aAA4B;IAChC,QAAQ;IACR;IACA,SAAS,IAAI,WAAW,CAAC;IACzB,WAAW,2BACT,cACA,mBACA,KACA,UACF;GACF;GACA,OAAO,UACL,UAAU,mBAAmB,YAAY,YAAY,GAAG,GAAG;IACzD,GAAG;IACH,GAAG;GACL,CAAC,GACD,WAAW,IACb;EACF;CACF,CAAC;CAED,OAAO;EACL,yBAAyB;EAMzB,sBAAsB;EAEtB,cAAc,KAAA;EACd,oBAAoB,KAAA;CACtB;AACF;;;;;;;AAQA,SAAgB,2BACd,cACA,mBACA,OAIA,aAAsC,CAAC,GACf;CACxB,MAAM,gBAAgB,OAAO,KAAK,UAAU,CAAC,CAAC,SAAS;CACvD,MAAM,SAAS,aACb,oBAAoB,UAChB,SAAS,MAAM,OAAO;EAAE,GAAG;EAAY,GAAG;CAAE,EAAU,IACrD;EAAE,GAAG;EAAY,GAAG;CAAS;CAEpC,IAAI,MAAM,YAAY;EACpB,MAAM,UAAU,MAAM;EACtB,OAAO,CACL;GACE,SAAS;GAGT,YAAY,iBACP,GAAG,SACF,MAAO,QAAsD,GAAG,IAAI,CAAC,IACtE;GACL,QAAS,MAAM,UAAU,CAAC;EAC5B,CACF;CACF;CACA,IAAI,MAAM,UAAU;EAClB,MAAM,eAAe,MAAM;EAC3B,OAAO,CACL,cACA;GACE,SAAS;GACT,aAAa,aACX,MAAM,SAAS,kBAAkB,CAAE,CAAC;GACtC,QAAQ,CAAC,YAAgC;EAC3C,CACF;CACF;CACA,IAAI,MAAM,aACR,OAAO,CACL;EACE,SAAS;EACT,aAAa,aACX,MAAM,SAAS,kBAAkB,CAAE,CAAC;EACtC,QAAQ,CAAC,MAAM,WAA+B;CAChD,CACF;CAEF,MAAM,IAAI,MACR,iFACF;AACF"}

package/dist/discovery.service-BYm95SSD.js

@@ -0,0 +1,368 @@
+import { a as Injectable, h as APP_EXCEPTION_HANDLER, i as Inject, k as MetadataRegistry, m as Scope, n as __decorateParam, r as __decorateMetadata, t as __decorate, x as ERROR_CATALOG } from "./decorate-GcSMAbKn.js";
+import { t as Container } from "./container-BqUHID4l.js";
+import { HTTPException } from "hono/http-exception";
+import { CORE_CATALOG, isVelaError } from "@velajs/errors";
+//#region src/errors/http-exception.ts
+var HttpException = class extends Error {
+	statusCode;
+	_response;
+	constructor(response, statusCode) {
+		const message = typeof response === "string" ? response : JSON.stringify(response);
+		super(message);
+		this.name = "HttpException";
+		this.statusCode = statusCode;
+		this._response = response;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	getStatus() {
+		return this.statusCode;
+	}
+	getResponse() {
+		if (typeof this._response === "string") return {
+			statusCode: this.statusCode,
+			message: this._response
+		};
+		return this._response;
+	}
+	getRawResponse() {
+		return this._response;
+	}
+};
+var BadRequestException = class extends HttpException {
+	constructor(message = "Bad Request") {
+		super(message, 400);
+		this.name = "BadRequestException";
+	}
+};
+var UnauthorizedException = class extends HttpException {
+	constructor(message = "Unauthorized") {
+		super(message, 401);
+		this.name = "UnauthorizedException";
+	}
+};
+var ForbiddenException = class extends HttpException {
+	constructor(message = "Forbidden") {
+		super(message, 403);
+		this.name = "ForbiddenException";
+	}
+};
+var NotFoundException = class extends HttpException {
+	constructor(message = "Not Found") {
+		super(message, 404);
+		this.name = "NotFoundException";
+	}
+};
+var MethodNotAllowedException = class extends HttpException {
+	constructor(message = "Method Not Allowed") {
+		super(message, 405);
+		this.name = "MethodNotAllowedException";
+	}
+};
+var NotAcceptableException = class extends HttpException {
+	constructor(message = "Not Acceptable") {
+		super(message, 406);
+		this.name = "NotAcceptableException";
+	}
+};
+var RequestTimeoutException = class extends HttpException {
+	constructor(message = "Request Timeout") {
+		super(message, 408);
+		this.name = "RequestTimeoutException";
+	}
+};
+var ConflictException = class extends HttpException {
+	constructor(message = "Conflict") {
+		super(message, 409);
+		this.name = "ConflictException";
+	}
+};
+var GoneException = class extends HttpException {
+	constructor(message = "Gone") {
+		super(message, 410);
+		this.name = "GoneException";
+	}
+};
+var PayloadTooLargeException = class extends HttpException {
+	constructor(message = "Payload Too Large") {
+		super(message, 413);
+		this.name = "PayloadTooLargeException";
+	}
+};
+var UnsupportedMediaTypeException = class extends HttpException {
+	constructor(message = "Unsupported Media Type") {
+		super(message, 415);
+		this.name = "UnsupportedMediaTypeException";
+	}
+};
+var UnprocessableEntityException = class extends HttpException {
+	constructor(message = "Unprocessable Entity") {
+		super(message, 422);
+		this.name = "UnprocessableEntityException";
+	}
+};
+var TooManyRequestsException = class extends HttpException {
+	constructor(message = "Too Many Requests") {
+		super(message, 429);
+		this.name = "TooManyRequestsException";
+	}
+};
+var InternalServerErrorException = class extends HttpException {
+	constructor(message = "Internal Server Error") {
+		super(message, 500);
+		this.name = "InternalServerErrorException";
+	}
+};
+var NotImplementedException = class extends HttpException {
+	constructor(message = "Not Implemented") {
+		super(message, 501);
+		this.name = "NotImplementedException";
+	}
+};
+var BadGatewayException = class extends HttpException {
+	constructor(message = "Bad Gateway") {
+		super(message, 502);
+		this.name = "BadGatewayException";
+	}
+};
+var ServiceUnavailableException = class extends HttpException {
+	constructor(message = "Service Unavailable") {
+		super(message, 503);
+		this.name = "ServiceUnavailableException";
+	}
+};
+var GatewayTimeoutException = class extends HttpException {
+	constructor(message = "Gateway Timeout") {
+		super(message, 504);
+		this.name = "GatewayTimeoutException";
+	}
+};
+//#endregion
+//#region src/exceptions/exception-handler.ts
+/**
+* True when `error` matches any of `matchers`. A string matches a branded
+* {@link VelaError} by `code`; an arrow-function predicate is called; anything
+* else with a `prototype` is treated as an error class and matched via
+* `instanceof`. Predicates therefore MUST be arrow functions — a regular
+* `function` expression has a `prototype` and would be mistaken for a class.
+* Bound functions (e.g. `SomeClass.bind(null)`) lack `.prototype` too, so they
+* are invoked as predicates — don't pass a bound class as a class matcher.
+*/
+const matchesAny = (matchers, error) => {
+	if (!matchers?.length) return false;
+	return matchers.some((m) => {
+		if (typeof m === "string") return isVelaError(error) && error.code === m;
+		if (typeof m === "function" && !m.prototype) return m(error);
+		return error instanceof m;
+	});
+};
+//#endregion
+//#region src/exceptions/reporter.ts
+/**
+* Build an {@link ErrorReporter} from a container. Reads the optional
+* {@link APP_EXCEPTION_HANDLER} and {@link ERROR_CATALOG} providers; with
+* neither registered the reporter logs (unless diagnostics is `'silent'`) and
+* exposes the core catalog.
+*/
+const resolveErrorReporter = (container) => {
+	const handler = container.has(APP_EXCEPTION_HANDLER) ? container.resolve(APP_EXCEPTION_HANDLER) : void 0;
+	return {
+		catalog: container.has(ERROR_CATALOG) ? container.resolve(ERROR_CATALOG) : CORE_CATALOG,
+		report(error, ctx) {
+			let suppressed = false;
+			try {
+				suppressed = matchesAny(handler?.dontReport, error);
+			} catch {}
+			if (suppressed) return;
+			const merged = handler?.context ? {
+				...ctx,
+				...safeContext(handler, error, ctx)
+			} : ctx;
+			if (handler?.report) {
+				try {
+					Promise.resolve(handler.report(error, merged)).catch(() => {});
+				} catch {}
+				return;
+			}
+			if (container.getDiagnostics() !== "silent") {
+				const status = clientFaultStatus(error);
+				if (status !== void 0 && status >= 400 && status < 500) return;
+				console.error(`[vela] ${merged.edge} error${merged.source ? ` in ${merged.source}` : ""}${merged.note ? ` (${merged.note})` : ""}:`, error);
+			}
+		},
+		render(error, executionCtx) {
+			try {
+				return handler?.render?.(error, executionCtx);
+			} catch {
+				return;
+			}
+		}
+	};
+};
+/**
+* The HTTP status of a client-fault (4xx) error, read across the three shapes a
+* caught error can take: a branded {@link VelaError} (`.status`), vela's own
+* {@link HttpException} (`getStatus()`), or hono's {@link HTTPException}
+* (`.status`). `undefined` for anything else — including raw/unbranded errors,
+* which must always be logged. Only the DEFAULT console reporter uses this to
+* mute client faults; a custom `handler.report` still receives everything.
+*/
+const clientFaultStatus = (error) => {
+	if (isVelaError(error)) return error.status;
+	if (error instanceof HttpException) return error.getStatus();
+	if (error instanceof HTTPException) return error.status;
+};
+const safeContext = (handler, error, ctx) => {
+	try {
+		return handler.context?.(error, ctx) ?? {};
+	} catch {
+		return {};
+	}
+};
+//#endregion
+//#region src/discovery/discovery.service.ts
+function isMethodMetaItem(x) {
+	return typeof x === "object" && x !== null && (typeof x.methodName === "string" || typeof x.methodName === "symbol");
+}
+function resolveKey(key) {
+	return typeof key === "string" ? key : key.KEY;
+}
+let DiscoveryService = class DiscoveryService {
+	container;
+	constructor(container) {
+		this.container = container;
+	}
+	/** Every class-token provider registered in the container. */
+	getProviders(filter) {
+		const out = [];
+		for (const token of this.container.getTokens()) {
+			if (typeof token !== "function") continue;
+			const entry = this.buildEntry(token, filter, "provider discovery");
+			if (entry) out.push(entry);
+		}
+		return out;
+	}
+	/**
+	* Providers whose class carries class-level metadata under `key` — both
+	* class decorators (single value) and method decorators that append
+	* class-level lists (`@Cron`, `@OnEvent`, `@SubscribeMessage`).
+	*/
+	providersWithMeta(key, filter) {
+		const metaKey = resolveKey(key);
+		const out = [];
+		for (const target of this.candidatesWithClassMeta(metaKey)) {
+			const entry = this.buildEntry(target, filter, `discovery of '${metaKey}'`);
+			if (!entry) continue;
+			const meta = MetadataRegistry.getCustomClassMeta(target, metaKey);
+			out.push({
+				...entry,
+				meta
+			});
+		}
+		return out;
+	}
+	/**
+	* Handler methods carrying metadata under `key`. Merges the two storage
+	* conventions:
+	*  - class-level appended lists whose items carry `methodName`
+	*    (`@Cron`/`@OnEvent`-style method decorators), and
+	*  - true handler-level metadata (`@SetMetadata`/`createDiscoverableDecorator`
+	*    applied to a method).
+	*/
+	methodsWithMeta(key, filter) {
+		const metaKey = resolveKey(key);
+		const out = [];
+		for (const target of this.candidatesWithClassMeta(metaKey)) {
+			const classMeta = MetadataRegistry.getCustomClassMeta(target, metaKey);
+			if (!Array.isArray(classMeta) || !classMeta.some(isMethodMetaItem)) continue;
+			const entry = this.buildEntry(target, filter, `discovery of '${metaKey}'`);
+			if (!entry) continue;
+			for (const item of classMeta) {
+				if (!isMethodMetaItem(item)) continue;
+				out.push({
+					class: entry,
+					methodName: item.methodName,
+					meta: item
+				});
+			}
+		}
+		for (const target of MetadataRegistry.getClassesWithHandlerMeta(metaKey)) {
+			if (!this.container.has(target)) continue;
+			const entry = this.buildEntry(target, filter, `discovery of '${metaKey}'`);
+			if (!entry) continue;
+			for (const { handler, value } of MetadataRegistry.getHandlersWithMeta(target, metaKey)) out.push({
+				class: entry,
+				methodName: handler,
+				meta: value
+			});
+		}
+		return out;
+	}
+	/**
+	* Index-first candidate walk with a legacy full-scan fallback: when the
+	* reverse index knows nothing about a key, an older copy of the registry
+	* module may have taken the writes (mixed dist/src or package versions in
+	* one process) — fall back to scanning container tokens the way the
+	* pre-DiscoveryService loops did.
+	*/
+	candidatesWithClassMeta(metaKey) {
+		const indexed = MetadataRegistry.getClassesWithClassMeta(metaKey);
+		if (indexed.size > 0) return [...indexed].filter((t) => this.container.has(t));
+		const out = [];
+		for (const token of this.container.getTokens()) {
+			if (typeof token !== "function") continue;
+			if (MetadataRegistry.getCustomClassMeta(token, metaKey) !== void 0) out.push(token);
+		}
+		return out;
+	}
+	buildEntry(metatype, filter, label) {
+		const moduleIds = this.container.getOwnerModuleIds(metatype);
+		if (moduleIds.length === 0) return void 0;
+		if (filter?.moduleId !== void 0) {
+			const wanted = Array.isArray(filter.moduleId) ? filter.moduleId : [filter.moduleId];
+			if (!moduleIds.some((id) => wanted.includes(id))) return void 0;
+		}
+		const scope = this.container.getProviderScope(metatype) ?? Scope.SINGLETON;
+		if (filter?.deferLazy && this.container.isLazyPending(metatype)) return {
+			token: metatype,
+			metatype,
+			moduleIds,
+			scope,
+			instance: void 0
+		};
+		if (scope === Scope.REQUEST && !filter?.includeRequestScoped) {
+			if (this.container.getDiagnostics() === "log") console.warn(`[vela] ${label}: ${metatype.name} is request-scoped and cannot be materialized at bootstrap — skipped. Pass { includeRequestScoped: true } to override.`);
+			return {
+				token: metatype,
+				metatype,
+				moduleIds,
+				scope,
+				instance: void 0
+			};
+		}
+		let instance;
+		try {
+			instance = this.container.resolve(metatype);
+		} catch (err) {
+			const mode = this.container.getDiagnostics();
+			if (mode === "throw") throw err;
+			if (mode === "log") console.warn(`[vela] ${label}: cannot resolve ${metatype.name}:`, err);
+			return;
+		}
+		return {
+			token: metatype,
+			metatype,
+			moduleIds,
+			scope,
+			instance
+		};
+	}
+};
+DiscoveryService = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(Container)),
+	__decorateMetadata("design:paramtypes", [typeof Container === "undefined" ? Object : Container])
+], DiscoveryService);
+//#endregion
+export { UnsupportedMediaTypeException as S, RequestTimeoutException as _, BadRequestException as a, UnauthorizedException as b, GatewayTimeoutException as c, InternalServerErrorException as d, MethodNotAllowedException as f, PayloadTooLargeException as g, NotImplementedException as h, BadGatewayException as i, GoneException as l, NotFoundException as m, resolveErrorReporter as n, ConflictException as o, NotAcceptableException as p, matchesAny as r, ForbiddenException as s, DiscoveryService as t, HttpException as u, ServiceUnavailableException as v, UnprocessableEntityException as x, TooManyRequestsException as y };
+
+//# sourceMappingURL=discovery.service-BYm95SSD.js.map