@velajs/vela 1.19.0 → 1.19.1

package/dist/decorate-GcSMAbKn.js

@@ -0,0 +1,528 @@
+//#region src/registry/util.ts
+function getOrCreate(map, key, factory) {
+	let v = map.get(key);
+	if (v === void 0) map.set(key, v = factory());
+	return v;
+}
+const getOrCreateMap = (map, key) => getOrCreate(map, key, () => /* @__PURE__ */ new Map());
+const getOrCreateArray = (map, key) => getOrCreate(map, key, () => []);
+//#endregion
+//#region src/registry/metadata.registry.ts
+function emptyComponentByOwner() {
+	return {
+		middleware: /* @__PURE__ */ new Map(),
+		guard: /* @__PURE__ */ new Map(),
+		pipe: /* @__PURE__ */ new Map(),
+		interceptor: /* @__PURE__ */ new Map(),
+		filter: /* @__PURE__ */ new Map()
+	};
+}
+function createRegistryState() {
+	return {
+		routes: /* @__PURE__ */ new Map(),
+		controllers: /* @__PURE__ */ new Map(),
+		controllerOptions: /* @__PURE__ */ new Map(),
+		modules: /* @__PURE__ */ new Map(),
+		parameters: /* @__PURE__ */ new Map(),
+		injectables: /* @__PURE__ */ new Set(),
+		scopes: /* @__PURE__ */ new Map(),
+		injectTokens: /* @__PURE__ */ new Map(),
+		handlerHttpMeta: /* @__PURE__ */ new Map(),
+		catchTypes: /* @__PURE__ */ new Map(),
+		routeVersions: /* @__PURE__ */ new Map(),
+		classMeta: /* @__PURE__ */ new Map(),
+		handlerMeta: /* @__PURE__ */ new Map(),
+		classMetaIndex: /* @__PURE__ */ new Map(),
+		handlerMetaIndex: /* @__PURE__ */ new Map(),
+		controllerComponents: emptyComponentByOwner(),
+		handlerComponents: {
+			middleware: /* @__PURE__ */ new Map(),
+			guard: /* @__PURE__ */ new Map(),
+			pipe: /* @__PURE__ */ new Map(),
+			interceptor: /* @__PURE__ */ new Map(),
+			filter: /* @__PURE__ */ new Map()
+		}
+	};
+}
+const REGISTRY_STATE_KEY = Symbol.for("vela:registry:v1");
+const EMPTY_TARGET_SET = /* @__PURE__ */ new Set();
+function registryState() {
+	const g = globalThis;
+	const state = g[REGISTRY_STATE_KEY] ??= createRegistryState();
+	state.classMetaIndex ??= /* @__PURE__ */ new Map();
+	state.handlerMetaIndex ??= /* @__PURE__ */ new Map();
+	return state;
+}
+var MetadataRegistry = class {
+	static get routes() {
+		return registryState().routes;
+	}
+	static get controllers() {
+		return registryState().controllers;
+	}
+	static get controllerOptions() {
+		return registryState().controllerOptions;
+	}
+	static get modules() {
+		return registryState().modules;
+	}
+	static get parameters() {
+		return registryState().parameters;
+	}
+	static get injectables() {
+		return registryState().injectables;
+	}
+	static get scopes() {
+		return registryState().scopes;
+	}
+	static get injectTokens() {
+		return registryState().injectTokens;
+	}
+	static get handlerHttpMeta() {
+		return registryState().handlerHttpMeta;
+	}
+	static get catchTypes() {
+		return registryState().catchTypes;
+	}
+	static get routeVersions() {
+		return registryState().routeVersions;
+	}
+	static get classMeta() {
+		return registryState().classMeta;
+	}
+	static get handlerMeta() {
+		return registryState().handlerMeta;
+	}
+	static get classMetaIndex() {
+		return registryState().classMetaIndex;
+	}
+	static get handlerMetaIndex() {
+		return registryState().handlerMetaIndex;
+	}
+	static get controllerComponents() {
+		return registryState().controllerComponents;
+	}
+	static get handlerComponents() {
+		return registryState().handlerComponents;
+	}
+	static getRoutes(controller) {
+		return this.routes.get(controller) ?? [];
+	}
+	static addRoute(controller, route) {
+		getOrCreateArray(this.routes, controller).push(route);
+	}
+	static getControllerPath(controller) {
+		return this.controllers.get(controller) ?? "";
+	}
+	static setControllerPath(controller, path) {
+		this.controllers.set(controller, path);
+	}
+	static getControllerOptions(controller) {
+		return this.controllerOptions.get(controller) ?? {};
+	}
+	static setControllerOptions(controller, options) {
+		this.controllerOptions.set(controller, options);
+	}
+	static getModuleOptions(module) {
+		return this.modules.get(module);
+	}
+	static setModuleOptions(module, options) {
+		this.modules.set(module, options);
+	}
+	static getParameters(controller) {
+		return this.parameters.get(controller) ?? /* @__PURE__ */ new Map();
+	}
+	static addParameter(controller, methodName, param) {
+		getOrCreateArray(getOrCreateMap(this.parameters, controller), methodName).push(param);
+	}
+	static registerController(type, controller, component) {
+		const map = this.controllerComponents[type];
+		getOrCreateArray(map, controller).push(component);
+	}
+	static getController(type, controller) {
+		return this.controllerComponents[type].get(controller) ?? [];
+	}
+	static registerHandler(type, controller, methodName, component) {
+		const map = this.handlerComponents[type];
+		getOrCreateArray(getOrCreateMap(map, controller), methodName).push(component);
+	}
+	static getHandler(type, controller, methodName) {
+		return this.handlerComponents[type].get(controller)?.get(methodName) ?? [];
+	}
+	static markInjectable(target) {
+		this.injectables.add(target);
+	}
+	static hasInjectable(target) {
+		return this.injectables.has(target);
+	}
+	static setScope(target, scope) {
+		this.scopes.set(target, scope);
+	}
+	static getScope(target) {
+		return this.scopes.get(target);
+	}
+	static setInjectTokens(target, tokens) {
+		this.injectTokens.set(target, tokens);
+	}
+	static getInjectTokens(target) {
+		return this.injectTokens.get(target);
+	}
+	static setHandlerHttpMeta(controller, method, meta) {
+		const methodMap = getOrCreateMap(this.handlerHttpMeta, controller);
+		const existing = methodMap.get(method) ?? {};
+		const merged = {
+			...existing,
+			...meta
+		};
+		if (meta.responseHeaders) merged.responseHeaders = [...existing.responseHeaders ?? [], ...meta.responseHeaders];
+		methodMap.set(method, merged);
+	}
+	static getHandlerHttpMeta(controller, method) {
+		return this.handlerHttpMeta.get(controller)?.get(method);
+	}
+	static setCatchTypes(filter, types) {
+		this.catchTypes.set(filter, types);
+	}
+	static getCatchTypes(filter) {
+		return this.catchTypes.get(filter);
+	}
+	static hasCatchTypes(filter) {
+		return this.catchTypes.has(filter);
+	}
+	static setRouteVersion(controller, method, version) {
+		getOrCreateMap(this.routeVersions, controller).set(method, version);
+	}
+	static getRouteVersion(controller, method) {
+		return this.routeVersions.get(controller)?.get(method);
+	}
+	static setCustomClassMeta(target, key, value) {
+		getOrCreate(this.classMeta, target, () => /* @__PURE__ */ new Map()).set(key, value);
+		if (!key.startsWith("design:")) getOrCreate(this.classMetaIndex, key, () => /* @__PURE__ */ new Set()).add(target);
+	}
+	static getCustomClassMeta(target, key) {
+		return this.classMeta.get(target)?.get(key);
+	}
+	static getCustomClassMetaAll(target) {
+		return this.classMeta.get(target);
+	}
+	static setCustomHandlerMeta(target, handler, key, value) {
+		getOrCreate(getOrCreate(this.handlerMeta, target, () => /* @__PURE__ */ new Map()), handler, () => /* @__PURE__ */ new Map()).set(key, value);
+		if (!key.startsWith("design:")) getOrCreate(this.handlerMetaIndex, key, () => /* @__PURE__ */ new Set()).add(target);
+	}
+	static getCustomHandlerMeta(target, handler, key) {
+		return this.handlerMeta.get(target)?.get(handler)?.get(key);
+	}
+	static getCustomHandlerMetaAll(target, handler) {
+		return this.handlerMeta.get(target)?.get(handler);
+	}
+	static appendCustomClassMeta(target, key, item) {
+		const list = this.getCustomClassMeta(target, key) ?? [];
+		list.push(item);
+		this.setCustomClassMeta(target, key, list);
+	}
+	static appendCustomHandlerMeta(target, handler, key, item) {
+		const list = this.getCustomHandlerMeta(target, handler, key) ?? [];
+		list.push(item);
+		this.setCustomHandlerMeta(target, handler, key, list);
+	}
+	static getClassesWithClassMeta(key) {
+		return this.classMetaIndex.get(key) ?? EMPTY_TARGET_SET;
+	}
+	static getClassesWithHandlerMeta(key) {
+		return this.handlerMetaIndex.get(key) ?? EMPTY_TARGET_SET;
+	}
+	/** Every (handler, value) pair on `target` carrying metadata under `key`. */
+	static getHandlersWithMeta(target, key) {
+		const byHandler = this.handlerMeta.get(target);
+		if (!byHandler) return [];
+		const out = [];
+		for (const [handler, metaMap] of byHandler) if (metaMap.has(key)) out.push({
+			handler,
+			value: metaMap.get(key)
+		});
+		return out;
+	}
+	static setReflectMetadata(target, key, value, propertyKey) {
+		if (propertyKey !== void 0) this.setCustomHandlerMeta(target, propertyKey, key, value);
+		else this.setCustomClassMeta(target, key, value);
+	}
+	static getReflectMetadata(target, key, propertyKey) {
+		if (propertyKey !== void 0) return this.getCustomHandlerMeta(target, propertyKey, key);
+		return this.getCustomClassMeta(target, key);
+	}
+	static getParamTypes(target, propertyKey) {
+		return this.getReflectMetadata(target, "design:paramtypes", propertyKey);
+	}
+	static propagateControllerComponents(from, to) {
+		for (const type of [
+			"middleware",
+			"guard",
+			"pipe",
+			"interceptor",
+			"filter"
+		]) {
+			const map = this.controllerComponents[type];
+			const components = map.get(from);
+			if (components && components.length > 0) getOrCreateArray(map, to).push(...components);
+		}
+	}
+	static clear() {}
+	static reset() {
+		this.routes.clear();
+		this.controllers.clear();
+		this.controllerOptions.clear();
+		this.modules.clear();
+		this.parameters.clear();
+		this.injectables.clear();
+		this.scopes.clear();
+		this.injectTokens.clear();
+		this.handlerHttpMeta.clear();
+		this.catchTypes.clear();
+		this.routeVersions.clear();
+		this.classMeta.clear();
+		this.handlerMeta.clear();
+		this.classMetaIndex.clear();
+		this.handlerMetaIndex.clear();
+		for (const type of [
+			"middleware",
+			"guard",
+			"pipe",
+			"interceptor",
+			"filter"
+		]) {
+			this.controllerComponents[type].clear();
+			this.handlerComponents[type].clear();
+		}
+	}
+};
+//#endregion
+//#region src/container/types.ts
+var InjectionToken = class {
+	description;
+	options;
+	constructor(description, options) {
+		this.description = description;
+		this.options = options;
+	}
+	toString() {
+		return `InjectionToken(${this.description})`;
+	}
+};
+var ForwardRef = class {
+	factory;
+	constructor(factory) {
+		this.factory = factory;
+	}
+};
+function forwardRef(factory) {
+	return new ForwardRef(factory);
+}
+/**
+* Human-readable token label — class name, `InjectionToken(desc)`, symbol
+* string, or String() fallback. Public so introspection tooling (module
+* graphs, entrypoint listings) renders tokens the same way vela's own errors
+* do.
+*/
+function describeToken(token) {
+	if (token instanceof InjectionToken) return token.toString();
+	if (typeof token === "function") return token.name;
+	if (typeof token === "symbol") return token.toString();
+	return String(token);
+}
+var ModuleVisibilityError = class extends Error {
+	moduleId;
+	token;
+	constructor(moduleId, token) {
+		super(`Module '${moduleId}' cannot resolve '${describeToken(token)}': not declared in providers, not imported from another module's exports, not @Global. Either add to imports/exports or mark as @Global.`);
+		this.moduleId = moduleId;
+		this.token = token;
+		this.name = "ModuleVisibilityError";
+	}
+};
+var MultipleProvidersFoundError = class extends Error {
+	moduleId;
+	token;
+	candidates;
+	constructor(moduleId, token, candidates) {
+		super(`Multiple providers found for '${describeToken(token)}' in module '${moduleId}':\n` + candidates.map((c) => `  - ${c}`).join("\n") + "\nResolve ambiguity by importing only one instance, or by using a per-instance accessor exposed by the module (e.g., Module.tokenFor(key)).");
+		this.moduleId = moduleId;
+		this.token = token;
+		this.candidates = candidates;
+		this.name = "MultipleProvidersFoundError";
+	}
+};
+const ROOT_MODULE_ID = "__root__";
+//#endregion
+//#region src/pipeline/tokens.ts
+/**
+* Register global guards via module providers instead of app.useGlobalGuards().
+*
+* @example
+* ```ts
+* @Module({
+*   providers: [
+*     AuthGuard,
+*     { provide: APP_GUARD, useClass: AuthGuard },
+*   ],
+* })
+* class AppModule {}
+* ```
+*/
+const APP_GUARD = new InjectionToken("APP_GUARD");
+/**
+* Register global pipes via module providers.
+*/
+const APP_PIPE = new InjectionToken("APP_PIPE");
+/**
+* Register global interceptors via module providers.
+*/
+const APP_INTERCEPTOR = new InjectionToken("APP_INTERCEPTOR");
+/**
+* Register global filters via module providers.
+*/
+const APP_FILTER = new InjectionToken("APP_FILTER");
+/**
+* Register global middleware via module providers.
+*/
+const APP_MIDDLEWARE = new InjectionToken("APP_MIDDLEWARE");
+/**
+* Register the application-wide exception handler via module providers.
+* Consumed by the shared error reporter (`resolveErrorReporter`) at every
+* transport edge to customize how errors are reported and rendered.
+*
+* @example
+* ```ts
+* @Module({
+*   providers: [
+*     { provide: APP_EXCEPTION_HANDLER, useValue: { report: (e) => sentry.capture(e) } },
+*   ],
+* })
+* class AppModule {}
+* ```
+*/
+const APP_EXCEPTION_HANDLER = new InjectionToken("APP_EXCEPTION_HANDLER");
+/**
+* Provide the composed error catalog (`composeCatalogs(CORE_CATALOG, …)`)
+* consulted when rendering wire-bound error bodies. Defaults to the core
+* catalog when unset.
+*/
+const ERROR_CATALOG = new InjectionToken("ERROR_CATALOG");
+//#endregion
+//#region src/constants.ts
+const METADATA_KEYS = {
+	INJECTABLE: "vela:injectable",
+	INJECT: "vela:inject",
+	SCOPE: "vela:scope",
+	MODULE: "vela:module",
+	MODULE_OPTIONS: "vela:module-options",
+	CONTROLLER: "vela:controller",
+	ROUTES: "vela:routes",
+	PARAMS: "vela:params",
+	HTTP_CODE: "vela:http-code",
+	RESPONSE_HEADERS: "vela:response-headers",
+	REDIRECT: "vela:redirect",
+	CATCH: "vela:catch",
+	CRUD: "vela:crud"
+};
+const HttpMethod = {
+	GET: "GET",
+	POST: "POST",
+	PUT: "PUT",
+	PATCH: "PATCH",
+	DELETE: "DELETE",
+	OPTIONS: "OPTIONS",
+	HEAD: "HEAD",
+	ALL: "ALL"
+};
+const ParamType = {
+	BODY: "body",
+	QUERY: "query",
+	PARAM: "param",
+	HEADERS: "headers",
+	REQUEST: "request",
+	RESPONSE: "response",
+	IP: "ip",
+	COOKIE: "cookie",
+	RAW_BODY: "raw_body"
+};
+const Scope = {
+	SINGLETON: "singleton",
+	TRANSIENT: "transient",
+	REQUEST: "request"
+};
+//#endregion
+//#region src/container/decorators.ts
+function Injectable(options = {}) {
+	return (target) => {
+		const { scope = Scope.SINGLETON } = options;
+		MetadataRegistry.markInjectable(target);
+		MetadataRegistry.setScope(target, scope);
+	};
+}
+function Optional() {
+	return (target, _propertyKey, parameterIndex) => {
+		const existing = getInjectMetadata(target);
+		const entry = existing.find((m) => m.index === parameterIndex);
+		if (entry) entry.optional = true;
+		else existing.push({
+			index: parameterIndex,
+			optional: true
+		});
+		MetadataRegistry.setInjectTokens(target, existing);
+	};
+}
+function Inject(token) {
+	return (target, _propertyKey, parameterIndex) => {
+		const existing = getInjectMetadata(target);
+		const entry = existing.find((m) => m.index === parameterIndex);
+		if (entry) entry.token = token;
+		else existing.push({
+			index: parameterIndex,
+			token
+		});
+		MetadataRegistry.setInjectTokens(target, existing);
+	};
+}
+function isInjectable(target) {
+	return MetadataRegistry.hasInjectable(target);
+}
+function getScope(target) {
+	return MetadataRegistry.getScope(target) ?? Scope.SINGLETON;
+}
+/**
+* Read through Reflect so dist/src coexistence in tests routes through the
+* single polyfill-installed registry — SWC writes `design:paramtypes` via
+* Reflect, so reads must too. The runtime contract is that each entry is a
+* constructor reference (a `Token`); we surface that contract directly so
+* callers don't need to re-cast.
+*/
+function getConstructorDependencies(target) {
+	return Reflect.getMetadata("design:paramtypes", target) ?? [];
+}
+function getInjectMetadata(target) {
+	return MetadataRegistry.getInjectTokens(target) ?? [];
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { getOrCreateArray as A, InjectionToken as C, describeToken as D, ROOT_MODULE_ID as E, forwardRef as O, ForwardRef as S, MultipleProvidersFoundError as T, APP_GUARD as _, Injectable as a, APP_PIPE as b, getInjectMetadata as c, HttpMethod as d, METADATA_KEYS as f, APP_FILTER as g, APP_EXCEPTION_HANDLER as h, Inject as i, MetadataRegistry as k, getScope as l, Scope as m, __decorateParam as n, Optional as o, ParamType as p, __decorateMetadata as r, getConstructorDependencies as s, __decorate as t, isInjectable as u, APP_INTERCEPTOR as v, ModuleVisibilityError as w, ERROR_CATALOG as x, APP_MIDDLEWARE as y };
+
+//# sourceMappingURL=decorate-GcSMAbKn.js.map

package/dist/decorate-GcSMAbKn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorate-GcSMAbKn.js","names":[],"sources":["../src/registry/util.ts","../src/registry/metadata.registry.ts","../src/container/types.ts","../src/pipeline/tokens.ts","../src/constants.ts","../src/container/decorators.ts"],"sourcesContent":["// Single map.get + optional set. Replaces `map.has(key) || map.set(key, …); map.get(key)!` patterns.\nexport function getOrCreate<K, V>(map: Map<K, V>, key: K, factory: () => V): V {\n  let v = map.get(key);\n  if (v === undefined) map.set(key, (v = factory()));\n  return v;\n}\n\nexport const getOrCreateMap = <K, NK, NV>(map: Map<K, Map<NK, NV>>, key: K) =>\n  getOrCreate(map, key, () => new Map<NK, NV>());\n\nexport const getOrCreateArray = <K, V>(map: Map<K, V[]>, key: K) =>\n  getOrCreate(map, key, () => [] as V[]);\n","import type { Scope } from '../constants';\nimport type { InjectMetadata } from '../container/types';\nimport type {\n  ComponentType,\n  ComponentTypeMap,\n  Constructor,\n  FilterType,\n  GuardType,\n  HttpHandlerMeta,\n  InterceptorType,\n  MiddlewareType,\n  ModuleOptions,\n  ParameterMetadata,\n  PipeType,\n  RouteDefinition,\n  Type,\n} from './types';\nimport { getOrCreate, getOrCreateArray, getOrCreateMap } from './util';\n\nexport interface ControllerOptions {\n  version?: number | number[];\n}\n\ninterface ComponentByOwner<O> {\n  middleware: Map<O, MiddlewareType[]>;\n  guard: Map<O, GuardType[]>;\n  pipe: Map<O, PipeType[]>;\n  interceptor: Map<O, InterceptorType[]>;\n  filter: Map<O, FilterType[]>;\n}\n\nfunction emptyComponentByOwner<O>(): ComponentByOwner<O> {\n  return {\n    middleware: new Map(),\n    guard: new Map(),\n    pipe: new Map(),\n    interceptor: new Map(),\n    filter: new Map(),\n  };\n}\n\ntype HandlerComponentStore = {\n  middleware: Map<Constructor, Map<string | symbol, MiddlewareType[]>>;\n  guard: Map<Constructor, Map<string | symbol, GuardType[]>>;\n  pipe: Map<Constructor, Map<string | symbol, PipeType[]>>;\n  interceptor: Map<Constructor, Map<string | symbol, InterceptorType[]>>;\n  filter: Map<Constructor, Map<string | symbol, FilterType[]>>;\n};\n\ninterface RegistryState {\n  routes: Map<Constructor, RouteDefinition[]>;\n  controllers: Map<Constructor, string>;\n  controllerOptions: Map<Constructor, ControllerOptions>;\n  modules: Map<Constructor, ModuleOptions>;\n  parameters: Map<Constructor, Map<string | symbol, ParameterMetadata[]>>;\n  injectables: Set<Constructor>;\n  scopes: Map<Constructor, Scope>;\n  injectTokens: Map<Constructor, InjectMetadata[]>;\n  handlerHttpMeta: Map<Constructor, Map<string | symbol, HttpHandlerMeta>>;\n  catchTypes: Map<Constructor, Type<Error>[]>;\n  routeVersions: Map<Constructor, Map<string | symbol, number | number[]>>;\n  classMeta: Map<object, Map<string, unknown>>;\n  handlerMeta: Map<object, Map<string | symbol, Map<string, unknown>>>;\n  // Reverse indexes: metadata key -> targets carrying it. Backs DiscoveryService\n  // so metadata-driven discovery never scans every container token. `design:*`\n  // keys (SWC-emitted type info) are excluded — high-volume, never discovered.\n  classMetaIndex: Map<string, Set<object>>;\n  handlerMetaIndex: Map<string, Set<object>>;\n  controllerComponents: ComponentByOwner<Constructor>;\n  handlerComponents: HandlerComponentStore;\n}\n\nfunction createRegistryState(): RegistryState {\n  return {\n    routes: new Map(),\n    controllers: new Map(),\n    controllerOptions: new Map(),\n    modules: new Map(),\n    parameters: new Map(),\n    injectables: new Set(),\n    scopes: new Map(),\n    injectTokens: new Map(),\n    handlerHttpMeta: new Map(),\n    catchTypes: new Map(),\n    routeVersions: new Map(),\n    classMeta: new Map(),\n    handlerMeta: new Map(),\n    classMetaIndex: new Map(),\n    handlerMetaIndex: new Map(),\n    controllerComponents: emptyComponentByOwner<Constructor>(),\n    handlerComponents: {\n      middleware: new Map(),\n      guard: new Map(),\n      pipe: new Map(),\n      interceptor: new Map(),\n      filter: new Map(),\n    },\n  };\n}\n\n// HMR-safe: anchor ALL backing state on `globalThis` so a Vite dev re-eval of\n// this module reuses the SAME maps that classes were already decorated against.\n// Without this, re-eval creates fresh empty statics → split-brain (lost routes,\n// spurious \"not @Injectable\" warnings, duplicated global components). The\n// versioned symbol avoids collisions across framework major versions in one\n// process. `globalThis` + `Symbol.for` exist on every target runtime; no node:*.\nconst REGISTRY_STATE_KEY = Symbol.for('vela:registry:v1');\n\n// Shared empty result for index misses — avoids allocating per lookup.\nconst EMPTY_TARGET_SET: ReadonlySet<object> = new Set<object>();\n\nfunction registryState(): RegistryState {\n  const g = globalThis as unknown as Record<symbol, RegistryState | undefined>;\n  const state = (g[REGISTRY_STATE_KEY] ??= createRegistryState());\n  // Backfill fields added after the v1 state shape was first anchored: a state\n  // created by an older copy of this module (dist/src coexistence in tests,\n  // mixed package versions in one process) must not crash newer readers.\n  state.classMetaIndex ??= new Map();\n  state.handlerMetaIndex ??= new Map();\n  return state;\n}\n\nexport class MetadataRegistry {\n  // Every field is a getter over the globalThis-anchored state (registryState).\n  // Method bodies keep using `this.<field>`; the getter returns the live map so\n  // `.set`/`.get`/`.clear` mutate the shared state.\n  private static get routes(): RegistryState['routes'] {\n    return registryState().routes;\n  }\n  private static get controllers(): RegistryState['controllers'] {\n    return registryState().controllers;\n  }\n  private static get controllerOptions(): RegistryState['controllerOptions'] {\n    return registryState().controllerOptions;\n  }\n  private static get modules(): RegistryState['modules'] {\n    return registryState().modules;\n  }\n  private static get parameters(): RegistryState['parameters'] {\n    return registryState().parameters;\n  }\n  private static get injectables(): RegistryState['injectables'] {\n    return registryState().injectables;\n  }\n  private static get scopes(): RegistryState['scopes'] {\n    return registryState().scopes;\n  }\n  private static get injectTokens(): RegistryState['injectTokens'] {\n    return registryState().injectTokens;\n  }\n  private static get handlerHttpMeta(): RegistryState['handlerHttpMeta'] {\n    return registryState().handlerHttpMeta;\n  }\n  private static get catchTypes(): RegistryState['catchTypes'] {\n    return registryState().catchTypes;\n  }\n  private static get routeVersions(): RegistryState['routeVersions'] {\n    return registryState().routeVersions;\n  }\n  private static get classMeta(): RegistryState['classMeta'] {\n    return registryState().classMeta;\n  }\n  private static get handlerMeta(): RegistryState['handlerMeta'] {\n    return registryState().handlerMeta;\n  }\n  private static get classMetaIndex(): RegistryState['classMetaIndex'] {\n    return registryState().classMetaIndex;\n  }\n  private static get handlerMetaIndex(): RegistryState['handlerMetaIndex'] {\n    return registryState().handlerMetaIndex;\n  }\n  private static get controllerComponents(): RegistryState['controllerComponents'] {\n    return registryState().controllerComponents;\n  }\n  private static get handlerComponents(): RegistryState['handlerComponents'] {\n    return registryState().handlerComponents;\n  }\n\n  // Routes\n\n  static getRoutes(controller: Constructor): RouteDefinition[] {\n    return this.routes.get(controller) ?? [];\n  }\n\n  static addRoute(controller: Constructor, route: RouteDefinition): void {\n    getOrCreateArray(this.routes, controller).push(route);\n  }\n\n  // Controllers\n\n  static getControllerPath(controller: Constructor): string {\n    return this.controllers.get(controller) ?? '';\n  }\n\n  static setControllerPath(controller: Constructor, path: string): void {\n    this.controllers.set(controller, path);\n  }\n\n  static getControllerOptions(controller: Constructor): ControllerOptions {\n    return this.controllerOptions.get(controller) ?? {};\n  }\n\n  static setControllerOptions(controller: Constructor, options: ControllerOptions): void {\n    this.controllerOptions.set(controller, options);\n  }\n\n  // Modules\n\n  static getModuleOptions(module: Constructor): ModuleOptions | undefined {\n    return this.modules.get(module);\n  }\n\n  static setModuleOptions(module: Constructor, options: ModuleOptions): void {\n    this.modules.set(module, options);\n  }\n\n  // Parameters\n\n  static getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]> {\n    return this.parameters.get(controller) ?? new Map();\n  }\n\n  static addParameter(\n    controller: Constructor,\n    methodName: string | symbol,\n    param: ParameterMetadata,\n  ): void {\n    const methodMap = getOrCreateMap(this.parameters, controller);\n    getOrCreateArray(methodMap, methodName).push(param);\n  }\n\n  // Component registration — controller-level. (There is deliberately NO\n  // global tier here: app-wide components live on the per-app RouteManager,\n  // one source, never process-global state.)\n\n  static registerController<T extends ComponentType>(\n    type: T,\n    controller: Constructor,\n    component: ComponentTypeMap[T],\n  ): void {\n    const map = this.controllerComponents[type] as Map<Constructor, ComponentTypeMap[T][]>;\n    getOrCreateArray(map, controller).push(component);\n  }\n\n  static getController<T extends ComponentType>(\n    type: T,\n    controller: Constructor,\n  ): ComponentTypeMap[T][] {\n    const map = this.controllerComponents[type] as Map<Constructor, ComponentTypeMap[T][]>;\n    return map.get(controller) ?? [];\n  }\n\n  // Component registration — handler-level\n\n  static registerHandler<T extends ComponentType>(\n    type: T,\n    controller: Constructor,\n    methodName: string | symbol,\n    component: ComponentTypeMap[T],\n  ): void {\n    const map = this.handlerComponents[type] as Map<\n      Constructor,\n      Map<string | symbol, ComponentTypeMap[T][]>\n    >;\n    const methodMap = getOrCreateMap(map, controller);\n    getOrCreateArray(methodMap, methodName).push(component);\n  }\n\n  static getHandler<T extends ComponentType>(\n    type: T,\n    controller: Constructor,\n    methodName: string | symbol,\n  ): ComponentTypeMap[T][] {\n    const map = this.handlerComponents[type] as Map<\n      Constructor,\n      Map<string | symbol, ComponentTypeMap[T][]>\n    >;\n    return map.get(controller)?.get(methodName) ?? [];\n  }\n\n  // DI metadata\n\n  static markInjectable(target: object): void {\n    this.injectables.add(target as Constructor);\n  }\n\n  static hasInjectable(target: object): boolean {\n    return this.injectables.has(target as Constructor);\n  }\n\n  static setScope(target: object, scope: Scope): void {\n    this.scopes.set(target as Constructor, scope);\n  }\n\n  static getScope(target: object): Scope | undefined {\n    return this.scopes.get(target as Constructor);\n  }\n\n  static setInjectTokens(target: object, tokens: InjectMetadata[]): void {\n    this.injectTokens.set(target as Constructor, tokens);\n  }\n\n  static getInjectTokens(target: object): InjectMetadata[] | undefined {\n    return this.injectTokens.get(target as Constructor);\n  }\n\n  // HTTP handler metadata\n\n  static setHandlerHttpMeta(\n    controller: Constructor,\n    method: string | symbol,\n    meta: HttpHandlerMeta,\n  ): void {\n    const methodMap = getOrCreateMap(this.handlerHttpMeta, controller);\n    const existing = methodMap.get(method) ?? {};\n    const merged: HttpHandlerMeta = { ...existing, ...meta };\n    if (meta.responseHeaders) {\n      merged.responseHeaders = [...(existing.responseHeaders ?? []), ...meta.responseHeaders];\n    }\n    methodMap.set(method, merged);\n  }\n\n  static getHandlerHttpMeta(\n    controller: Constructor,\n    method: string | symbol,\n  ): HttpHandlerMeta | undefined {\n    return this.handlerHttpMeta.get(controller)?.get(method);\n  }\n\n  // Exception filter types\n\n  static setCatchTypes(filter: Constructor, types: Type<Error>[]): void {\n    this.catchTypes.set(filter, types);\n  }\n\n  static getCatchTypes(filter: Constructor): Type<Error>[] | undefined {\n    return this.catchTypes.get(filter);\n  }\n\n  static hasCatchTypes(filter: Constructor): boolean {\n    return this.catchTypes.has(filter);\n  }\n\n  // Route versions\n\n  static setRouteVersion(\n    controller: Constructor,\n    method: string | symbol,\n    version: number | number[],\n  ): void {\n    getOrCreateMap(this.routeVersions, controller).set(method, version);\n  }\n\n  static getRouteVersion(\n    controller: Constructor,\n    method: string | symbol,\n  ): number | number[] | undefined {\n    return this.routeVersions.get(controller)?.get(method);\n  }\n\n  // Custom class/handler metadata. One slot per (target, key) for class-level,\n  // (target, handler, key) for handler-level. The same slots back @SetMetadata,\n  // every feature decorator (@Cron, @OnEvent, @ApiDoc, …), the SWC shim, and\n  // external Reflect.defineMetadata calls — one model, one source of truth.\n\n  static setCustomClassMeta(target: object, key: string, value: unknown): void {\n    getOrCreate(this.classMeta, target, () => new Map<string, unknown>()).set(key, value);\n    if (!key.startsWith('design:')) {\n      getOrCreate(this.classMetaIndex, key, () => new Set<object>()).add(target);\n    }\n  }\n\n  static getCustomClassMeta(target: object, key: string): unknown {\n    return this.classMeta.get(target)?.get(key);\n  }\n\n  static getCustomClassMetaAll(target: object): Map<string, unknown> | undefined {\n    return this.classMeta.get(target);\n  }\n\n  static setCustomHandlerMeta(\n    target: object,\n    handler: string | symbol,\n    key: string,\n    value: unknown,\n  ): void {\n    const byHandler = getOrCreate(\n      this.handlerMeta,\n      target,\n      () => new Map<string | symbol, Map<string, unknown>>(),\n    );\n    getOrCreate(byHandler, handler, () => new Map<string, unknown>()).set(key, value);\n    if (!key.startsWith('design:')) {\n      getOrCreate(this.handlerMetaIndex, key, () => new Set<object>()).add(target);\n    }\n  }\n\n  static getCustomHandlerMeta(target: object, handler: string | symbol, key: string): unknown {\n    return this.handlerMeta.get(target)?.get(handler)?.get(key);\n  }\n\n  static getCustomHandlerMetaAll(\n    target: object,\n    handler: string | symbol,\n  ): Map<string, unknown> | undefined {\n    return this.handlerMeta.get(target)?.get(handler);\n  }\n\n  // Append helpers — for stackable metadata like @Cron / @Interval / @OnEvent / @ApiResponse.\n\n  static appendCustomClassMeta<T>(target: object, key: string, item: T): void {\n    const list = (this.getCustomClassMeta(target, key) as T[] | undefined) ?? [];\n    list.push(item);\n    this.setCustomClassMeta(target, key, list);\n  }\n\n  static appendCustomHandlerMeta<T>(\n    target: object,\n    handler: string | symbol,\n    key: string,\n    item: T,\n  ): void {\n    const list = (this.getCustomHandlerMeta(target, handler, key) as T[] | undefined) ?? [];\n    list.push(item);\n    this.setCustomHandlerMeta(target, handler, key, list);\n  }\n\n  // Reverse-index readers — the DiscoveryService seam. Return the constructors\n  // known to carry class-level (resp. handler-level) metadata under `key`.\n  // Callers must still intersect with container-registered tokens: decoration\n  // alone does not make a class a provider.\n\n  static getClassesWithClassMeta(key: string): ReadonlySet<object> {\n    return this.classMetaIndex.get(key) ?? EMPTY_TARGET_SET;\n  }\n\n  static getClassesWithHandlerMeta(key: string): ReadonlySet<object> {\n    return this.handlerMetaIndex.get(key) ?? EMPTY_TARGET_SET;\n  }\n\n  /** Every (handler, value) pair on `target` carrying metadata under `key`. */\n  static getHandlersWithMeta(\n    target: object,\n    key: string,\n  ): Array<{ handler: string | symbol; value: unknown }> {\n    const byHandler = this.handlerMeta.get(target);\n    if (!byHandler) return [];\n    const out: Array<{ handler: string | symbol; value: unknown }> = [];\n    for (const [handler, metaMap] of byHandler) {\n      if (metaMap.has(key)) out.push({ handler, value: metaMap.get(key) });\n    }\n    return out;\n  }\n\n  // Reflect-style API — same storage as the typed setters above. Lets external\n  // code (and the SWC shim's Reflect.metadata polyfill) write/read uniformly.\n\n  static setReflectMetadata(\n    target: object,\n    key: string,\n    value: unknown,\n    propertyKey?: string | symbol,\n  ): void {\n    if (propertyKey !== undefined) {\n      this.setCustomHandlerMeta(target, propertyKey, key, value);\n    } else {\n      this.setCustomClassMeta(target, key, value);\n    }\n  }\n\n  static getReflectMetadata<T = unknown>(\n    target: object,\n    key: string,\n    propertyKey?: string | symbol,\n  ): T | undefined {\n    if (propertyKey !== undefined) {\n      return this.getCustomHandlerMeta(target, propertyKey, key) as T | undefined;\n    }\n    return this.getCustomClassMeta(target, key) as T | undefined;\n  }\n\n  // SWC-emitted design:paramtypes — class-level for constructors, handler-level for methods.\n\n  static getParamTypes(target: object, propertyKey?: string | symbol): unknown[] | undefined {\n    return this.getReflectMetadata<unknown[]>(target, 'design:paramtypes', propertyKey);\n  }\n\n  // Propagate all controller-level components from one class to another.\n\n  static propagateControllerComponents(from: Constructor, to: Constructor): void {\n    for (const type of ['middleware', 'guard', 'pipe', 'interceptor', 'filter'] as const) {\n      const map = this.controllerComponents[type];\n      const components = map.get(from);\n      if (components && components.length > 0) {\n        const target = getOrCreateArray(map as Map<Constructor, unknown[]>, to) as unknown[];\n        target.push(...components);\n      }\n    }\n  }\n\n  // Clear app-time state. Decoration metadata persists — once a class is\n  // decorated, that fact is permanent for the lifetime of the process.\n  // Currently a no-op: the last piece of app-time registry state (the global\n  // component tier) moved to the per-app RouteManager. Kept because test\n  // suites call it between cases and future app-time state belongs here.\n\n  static clear(): void {\n    // no app-time state to clear\n  }\n\n  // Full reset, including decoration metadata. Used in framework-internal scenarios.\n\n  static reset(): void {\n    this.routes.clear();\n    this.controllers.clear();\n    this.controllerOptions.clear();\n    this.modules.clear();\n    this.parameters.clear();\n    this.injectables.clear();\n    this.scopes.clear();\n    this.injectTokens.clear();\n    this.handlerHttpMeta.clear();\n    this.catchTypes.clear();\n    this.routeVersions.clear();\n    this.classMeta.clear();\n    this.handlerMeta.clear();\n    this.classMetaIndex.clear();\n    this.handlerMetaIndex.clear();\n    for (const type of ['middleware', 'guard', 'pipe', 'interceptor', 'filter'] as const) {\n      this.controllerComponents[type].clear();\n      this.handlerComponents[type].clear();\n    }\n  }\n}\n","import type { Scope } from '../constants';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Type<T = any> = new (...args: any[]) => T;\n\n// Broader: matches concrete and abstract classes. Used for metadata keying,\n// where any class reference is acceptable.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Constructor<T = unknown> = abstract new (...args: any[]) => T;\n\nexport interface InjectionTokenOptions<T> {\n  factory?: () => T;\n}\n\nexport class InjectionToken<T = unknown> {\n  constructor(\n    private readonly description: string,\n    public readonly options?: InjectionTokenOptions<T>,\n  ) {}\n\n  toString(): string {\n    return `InjectionToken(${this.description})`;\n  }\n}\n\nexport class ForwardRef<T = unknown> {\n  constructor(public readonly factory: () => Token<T>) {}\n}\n\nexport function forwardRef<T>(factory: () => Token<T>): ForwardRef<T> {\n  return new ForwardRef(factory);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type Token<T = any> = Type<T> | InjectionToken<T> | string | symbol;\n\n/**\n * Maps a single DI `Token<T>` to its resolved value type at the type level:\n * - `InjectionToken<T>`           → `T`\n * - `Type<T>` / `Constructor<T>`  → `T` (the instance type)\n * - `ForwardRef<T>`               → `T`\n * - `string` / `symbol`           → `unknown` (runtime-only tokens carry no\n *                                   static type info; the consumer asserts).\n *\n * Used by `AsyncModuleOptions` to give `useFactory` parameters their real\n * types based on the literal `inject` tuple — without `as const` at the call\n * site (relies on the `const` type parameter on the consuming generic).\n */\nexport type InferToken<T> =\n  T extends InjectionToken<infer U>\n    ? U\n    : T extends ForwardRef<infer U>\n      ? U\n      : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        T extends abstract new (...args: any[]) => infer U\n        ? U\n        : unknown;\n\n/**\n * Map every position of a `Token[]` tuple to its resolved value type.\n * Pairs with `const Inject extends readonly Token<unknown>[]` generics to\n * give `useFactory(...deps)` parameter types inferred from the literal\n * `inject` array.\n */\nexport type InferTokens<T extends readonly unknown[]> = {\n  [K in keyof T]: InferToken<T[K]>;\n};\n\nexport interface InjectableOptions {\n  scope?: Scope;\n}\n\nexport interface InjectMetadata {\n  index: number;\n  token?: Token | ForwardRef;\n  optional?: boolean;\n}\n\nexport interface ProviderOptions<T = unknown> {\n  provide?: Token<T>;\n  scope?: Scope;\n  useValue?: T;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  useFactory?: (...args: any[]) => T | Promise<T>;\n  useClass?: Type<T>;\n  // Accepts both mutable and readonly token arrays — the latter is what\n  // const-tuple-inferred `AsyncModuleOptions.inject` produces when threaded\n  // through to module-internal provider registrations. Behavior is identical\n  // at runtime; the container iterates and resolves.\n  inject?: readonly Token[];\n  useExisting?: Token<T>;\n}\n\nexport interface ProviderRegistration<T = unknown> {\n  provide: Token<T>;\n  /** The declared scope (from `@Injectable`/`@Controller`/provider options). */\n  scope: Scope;\n  /**\n   * Scope after request-scope bubbling: `REQUEST` if this provider (transitively)\n   * depends on a request-scoped provider, else the declared scope. Computed once\n   * at bootstrap (`Container.computeEffectiveScopes`); falls back to `scope`\n   * until then. Governs caching + eager instantiation.\n   */\n  effectiveScope?: Scope;\n  /**\n   * Module that owns this registration. Used by `resolveClass` to determine\n   * the POV from which the class's dependencies resolve. Sandbox/bootstrap\n   * registrations land in the `\"__root__\"` bucket.\n   */\n  declaringModuleId: string;\n  instance?: T;\n  useValue?: T;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  useFactory?: (...args: any[]) => T | Promise<T>;\n  useClass?: Type<T>;\n  inject?: readonly Token[];\n  useExisting?: Token<T>;\n}\n\n// Module visibility\nexport interface ModuleScope {\n  moduleId: string;\n  localProviders: Set<Token>;\n  importedModules: Set<string>;\n  exportedTokens: Set<Token>;\n  isGlobal: boolean;\n  /** Module instance opted into deferred (first-use) materialization. */\n  lazy?: boolean;\n}\n\n/**\n * The container's seam into lazy-module materialization (implemented by\n * `LazyModuleManager`). The container only ever *claims* a pending module at\n * a resolution trigger and *drains* completed claims when the resolution\n * stack has fully unwound — construction and hook replay live behind this\n * interface so the container stays module-system-agnostic.\n */\nexport interface LazyResolutionHook {\n  /** Is this module instance still deferred (untriggered)? */\n  isPending(moduleId: string): boolean;\n  /** Mark a pending module as triggered; idempotent. */\n  claim(moduleId: string): void;\n  /** Any claimed-but-unmaterialized groups? (cheap fast-path check) */\n  hasClaimed(): boolean;\n  /**\n   * A drain loop is currently running. The container must NOT start (or\n   * await) another drain from inside it — the running loop picks pending\n   * claims up; awaiting would self-deadlock on the async path.\n   */\n  isDraining(): boolean;\n  /** Complete claimed groups synchronously; throws if async work surfaces. */\n  drainSync(): void;\n  /** Complete claimed groups, awaiting async construction and hooks. */\n  drainAsync(): Promise<void>;\n}\n\nexport type Diagnostics = 'silent' | 'log' | 'throw';\n\nexport interface ContainerOptions {\n  diagnostics?: Diagnostics;\n}\n\n/**\n * Human-readable token label — class name, `InjectionToken(desc)`, symbol\n * string, or String() fallback. Public so introspection tooling (module\n * graphs, entrypoint listings) renders tokens the same way vela's own errors\n * do.\n */\nexport function describeToken(token: Token): string {\n  if (token instanceof InjectionToken) return token.toString();\n  if (typeof token === 'function') return token.name;\n  if (typeof token === 'symbol') return token.toString();\n  return String(token);\n}\n\n/**\n * One module instance in the loaded graph, serializable (strings only) —\n * what `Container.getModuleDescriptions()` returns for introspection tooling\n * (`vela module graph`). Reads registration state only; never constructs.\n */\nexport interface ModuleDescription {\n  moduleId: string;\n  /** moduleIds this instance imports. */\n  imports: string[];\n  isGlobal: boolean;\n  lazy: boolean;\n  /** Token labels registered in this instance's bucket (registration order). */\n  providers: string[];\n  /** Token labels this instance exports. */\n  exports: string[];\n}\n\nexport class ModuleVisibilityError extends Error {\n  constructor(\n    public readonly moduleId: string,\n    public readonly token: Token,\n  ) {\n    super(\n      `Module '${moduleId}' cannot resolve '${describeToken(token)}': ` +\n        `not declared in providers, not imported from another module's exports, not @Global. ` +\n        `Either add to imports/exports or mark as @Global.`,\n    );\n    this.name = 'ModuleVisibilityError';\n  }\n}\n\nexport class MultipleProvidersFoundError extends Error {\n  constructor(\n    public readonly moduleId: string,\n    public readonly token: Token,\n    public readonly candidates: string[],\n  ) {\n    super(\n      `Multiple providers found for '${describeToken(token)}' in module '${moduleId}':\\n` +\n        candidates.map((c) => `  - ${c}`).join('\\n') +\n        `\\nResolve ambiguity by importing only one instance, or by using a per-instance ` +\n        `accessor exposed by the module (e.g., Module.tokenFor(key)).`,\n    );\n    this.name = 'MultipleProvidersFoundError';\n  }\n}\n\nexport const ROOT_MODULE_ID = '__root__';\n","import type { Catalog } from '@velajs/errors';\nimport { InjectionToken } from '../container/types';\nimport type { ExceptionHandler } from '../exceptions/exception-handler';\nimport type {\n  CanActivate,\n  ExceptionFilter,\n  NestInterceptor,\n  NestMiddleware,\n  PipeTransform,\n} from './types';\n\n/**\n * Register global guards via module providers instead of app.useGlobalGuards().\n *\n * @example\n * ```ts\n * @Module({\n *   providers: [\n *     AuthGuard,\n *     { provide: APP_GUARD, useClass: AuthGuard },\n *   ],\n * })\n * class AppModule {}\n * ```\n */\nexport const APP_GUARD = new InjectionToken<CanActivate>('APP_GUARD');\n\n/**\n * Register global pipes via module providers.\n */\nexport const APP_PIPE = new InjectionToken<PipeTransform>('APP_PIPE');\n\n/**\n * Register global interceptors via module providers.\n */\nexport const APP_INTERCEPTOR = new InjectionToken<NestInterceptor>('APP_INTERCEPTOR');\n\n/**\n * Register global filters via module providers.\n */\nexport const APP_FILTER = new InjectionToken<ExceptionFilter>('APP_FILTER');\n\n/**\n * Register global middleware via module providers.\n */\nexport const APP_MIDDLEWARE = new InjectionToken<NestMiddleware>('APP_MIDDLEWARE');\n\n/**\n * Register the application-wide exception handler via module providers.\n * Consumed by the shared error reporter (`resolveErrorReporter`) at every\n * transport edge to customize how errors are reported and rendered.\n *\n * @example\n * ```ts\n * @Module({\n *   providers: [\n *     { provide: APP_EXCEPTION_HANDLER, useValue: { report: (e) => sentry.capture(e) } },\n *   ],\n * })\n * class AppModule {}\n * ```\n */\nexport const APP_EXCEPTION_HANDLER = new InjectionToken<ExceptionHandler>('APP_EXCEPTION_HANDLER');\n\n/**\n * Provide the composed error catalog (`composeCatalogs(CORE_CATALOG, …)`)\n * consulted when rendering wire-bound error bodies. Defaults to the core\n * catalog when unset.\n */\nexport const ERROR_CATALOG = new InjectionToken<Catalog<string>>('ERROR_CATALOG');\n","export const METADATA_KEYS = {\n  // DI\n  INJECTABLE: 'vela:injectable',\n  INJECT: 'vela:inject',\n  SCOPE: 'vela:scope',\n\n  // Module\n  MODULE: 'vela:module',\n  MODULE_OPTIONS: 'vela:module-options',\n\n  // HTTP\n  CONTROLLER: 'vela:controller',\n  ROUTES: 'vela:routes',\n  PARAMS: 'vela:params',\n  HTTP_CODE: 'vela:http-code',\n  RESPONSE_HEADERS: 'vela:response-headers',\n  REDIRECT: 'vela:redirect',\n\n  // Pipeline\n  CATCH: 'vela:catch',\n\n  // CRUD\n  CRUD: 'vela:crud',\n} as const;\n\nexport const HttpMethod = {\n  GET: 'GET',\n  POST: 'POST',\n  PUT: 'PUT',\n  PATCH: 'PATCH',\n  DELETE: 'DELETE',\n  OPTIONS: 'OPTIONS',\n  HEAD: 'HEAD',\n  ALL: 'ALL',\n} as const;\nexport type HttpMethod = (typeof HttpMethod)[keyof typeof HttpMethod];\n\nexport const ParamType = {\n  BODY: 'body',\n  QUERY: 'query',\n  PARAM: 'param',\n  HEADERS: 'headers',\n  REQUEST: 'request',\n  RESPONSE: 'response',\n  IP: 'ip',\n  COOKIE: 'cookie',\n  RAW_BODY: 'raw_body',\n} as const;\nexport type ParamType = (typeof ParamType)[keyof typeof ParamType];\n\nexport const Scope = {\n  SINGLETON: 'singleton',\n  TRANSIENT: 'transient',\n  REQUEST: 'request',\n} as const;\nexport type Scope = (typeof Scope)[keyof typeof Scope];\n","import { Scope } from '../constants';\nimport { MetadataRegistry } from '../registry/metadata.registry';\nimport type { InjectableOptions, InjectMetadata, Token } from './types';\nimport { ForwardRef } from './types';\n\nexport function Injectable(options: InjectableOptions = {}): ClassDecorator {\n  return (target: object) => {\n    const { scope = Scope.SINGLETON } = options;\n    MetadataRegistry.markInjectable(target);\n    MetadataRegistry.setScope(target, scope);\n  };\n}\n\nexport function Optional(): ParameterDecorator {\n  return (target: object, _propertyKey: string | symbol | undefined, parameterIndex: number) => {\n    const existing = getInjectMetadata(target);\n    const entry = existing.find((m) => m.index === parameterIndex);\n    if (entry) {\n      entry.optional = true;\n    } else {\n      existing.push({ index: parameterIndex, optional: true });\n    }\n    MetadataRegistry.setInjectTokens(target, existing);\n  };\n}\n\nexport function Inject(token: Token | ForwardRef): ParameterDecorator {\n  return (target: object, _propertyKey: string | symbol | undefined, parameterIndex: number) => {\n    const existing = getInjectMetadata(target);\n    const entry = existing.find((m) => m.index === parameterIndex);\n    if (entry) {\n      entry.token = token;\n    } else {\n      existing.push({ index: parameterIndex, token });\n    }\n    MetadataRegistry.setInjectTokens(target, existing);\n  };\n}\n\nexport function isInjectable(target: object): boolean {\n  return MetadataRegistry.hasInjectable(target);\n}\n\nexport function getScope(target: object): Scope {\n  return MetadataRegistry.getScope(target) ?? Scope.SINGLETON;\n}\n\n/**\n * Read through Reflect so dist/src coexistence in tests routes through the\n * single polyfill-installed registry — SWC writes `design:paramtypes` via\n * Reflect, so reads must too. The runtime contract is that each entry is a\n * constructor reference (a `Token`); we surface that contract directly so\n * callers don't need to re-cast.\n */\nexport function getConstructorDependencies(target: object): Array<Token | undefined> {\n  return (\n    (Reflect.getMetadata('design:paramtypes', target) as Array<Token | undefined> | undefined) ?? []\n  );\n}\n\nexport function getInjectMetadata(target: object): InjectMetadata[] {\n  return MetadataRegistry.getInjectTokens(target) ?? [];\n}\n"],"mappings":"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"}

package/dist/decorators-C8YBFCIk.js

@@ -0,0 +1,53 @@
+import { k as MetadataRegistry } from "./decorate-GcSMAbKn.js";
+//#region src/module/decorators.ts
+function Global() {
+	return (target) => {
+		const ctor = target;
+		const existing = MetadataRegistry.getModuleOptions(ctor);
+		MetadataRegistry.setModuleOptions(ctor, {
+			...existing,
+			isGlobal: true
+		});
+	};
+}
+function Module(options = {}) {
+	return (target) => {
+		MetadataRegistry.setModuleOptions(target, {
+			imports: options.imports,
+			providers: options.providers,
+			controllers: options.controllers,
+			exports: options.exports,
+			isGlobal: options.isGlobal,
+			lazy: options.lazy
+		});
+	};
+}
+function isModule(target) {
+	return MetadataRegistry.getModuleOptions(target) !== void 0;
+}
+/**
+* Normalize a DynamicModule, defaulting `key` to `"default"`. Module authors
+* call this from `forRoot()` so the loader always sees an explicit key.
+*/
+function defineDynamicModule(input) {
+	return {
+		...input,
+		key: input.key ?? "default"
+	};
+}
+function getModuleMetadata(target) {
+	const options = MetadataRegistry.getModuleOptions(target);
+	if (!options) return void 0;
+	return {
+		providers: options.providers ?? [],
+		controllers: options.controllers ?? [],
+		imports: options.imports ?? [],
+		exports: options.exports ?? [],
+		isGlobal: options.isGlobal === true,
+		lazy: options.lazy === true
+	};
+}
+//#endregion
+export { isModule as a, getModuleMetadata as i, Module as n, defineDynamicModule as r, Global as t };
+
+//# sourceMappingURL=decorators-C8YBFCIk.js.map