@velajs/vela 1.19.0 → 1.19.1

package/dist/src-eb5CI6Xn.js

@@ -0,0 +1,2151 @@
+import { C as InjectionToken, S as ForwardRef, _ as APP_GUARD, a as Injectable, b as APP_PIPE, g as APP_FILTER, h as APP_EXCEPTION_HANDLER, i as Inject, k as MetadataRegistry, n as __decorateParam, o as Optional, p as ParamType, r as __decorateMetadata, t as __decorate, v as APP_INTERCEPTOR, x as ERROR_CATALOG, y as APP_MIDDLEWARE } from "./decorate-GcSMAbKn.js";
+import { G as getMetadata, H as joinPaths, I as ComponentManager, R as buildExecutionContext, U as toOpenApiPath, z as getRouteContributors } from "./route.manager-DRAZ5X04.js";
+import { a as BadRequestException, t as DiscoveryService, v as ServiceUnavailableException, y as TooManyRequestsException } from "./discovery.service-BYm95SSD.js";
+import { t as Container } from "./container-BqUHID4l.js";
+import { g as VelaApplication, m as CONFIG_OPTIONS, o as bootstrap, p as CONFIG_ENV } from "./plugin-ByBlVOve.js";
+import { t as REQUEST_CONTEXT } from "./request-context-C3nCGJNd.js";
+import { i as getModuleMetadata, n as Module } from "./decorators-C8YBFCIk.js";
+import { n as defineModule, r as stableHash } from "./define-module-NOyOZNXD.js";
+import { t as ConfigurableModuleBuilder } from "./configurable-module.builder-5FGMaXG6.js";
+import { i as INTERVAL_METADATA, n as ScheduleRegistry, r as CRON_METADATA } from "./cron-matcher-C9qv5OUA.js";
+import { CORE_CATALOG, CORE_CATALOG as CORE_CATALOG$1, VelaError, composeCatalogs, composeCatalogs as composeCatalogs$1, defineErrorCatalog, isVelaError as isVelaError$1, toErrorBody as toErrorBody$1 } from "@velajs/errors";
+import { contextStorage, getContext } from "hono/context-storage";
+import { cors } from "hono/cors";
+import { env, getRuntimeKey } from "hono/adapter";
+//#region src/factory.ts
+const VelaFactory = { async create(rootModule, options = {}) {
+	const { adapters = [], ...bootstrapOptions } = options;
+	const adapterMiddleware = adapters.flatMap((a) => a.requestMiddleware ?? []);
+	if (adapterMiddleware.length > 0) bootstrapOptions.middleware = [...adapterMiddleware, ...bootstrapOptions.middleware ?? []];
+	const { container, routeManager, loader } = await bootstrap(rootModule, bootstrapOptions);
+	const app = new VelaApplication(container, routeManager);
+	const instances = await loader.resolveAllInstances();
+	app.setInstances(instances);
+	await app.callOnModuleInit();
+	await app.callOnApplicationBootstrap();
+	const adapterContext = {
+		app,
+		container,
+		routeManager,
+		discovery: container.resolve(DiscoveryService)
+	};
+	for (const adapter of adapters) await adapter.onBootstrap?.(adapterContext);
+	await app.initRoutes();
+	for (const adapter of adapters) await adapter.onRoutesBuilt?.(adapterContext);
+	return app;
+} };
+//#endregion
+//#region src/module/graph.ts
+function isDynamicModuleLike(value) {
+	return !!value && typeof value === "object" && "module" in value && typeof value.module === "function";
+}
+/**
+* Walks the module dependency graph from a root, unwrapping ForwardRef and
+* dynamic-module imports along the way, and returns every controller
+* reachable from it. Pure metadata read — no Container, no side effects.
+*
+* Used by createOpenApiDocument and any other consumer that needs a
+* controller list without bootstrapping the application.
+*/
+function collectControllers(rootModule) {
+	const visited = /* @__PURE__ */ new Set();
+	const controllers = /* @__PURE__ */ new Set();
+	const visit = (entry) => {
+		const unwrapped = entry instanceof ForwardRef ? entry.factory() : entry;
+		const moduleClass = isDynamicModuleLike(unwrapped) ? unwrapped.module : unwrapped;
+		const extraControllers = isDynamicModuleLike(unwrapped) ? unwrapped.controllers ?? [] : [];
+		const extraImports = isDynamicModuleLike(unwrapped) ? unwrapped.imports ?? [] : [];
+		if (typeof moduleClass !== "function" || visited.has(moduleClass)) return;
+		visited.add(moduleClass);
+		const metadata = getModuleMetadata(moduleClass);
+		if (metadata) {
+			for (const controller of metadata.controllers) controllers.add(controller);
+			for (const imp of metadata.imports) visit(imp);
+		}
+		for (const controller of extraControllers) controllers.add(controller);
+		for (const imp of extraImports) visit(imp);
+	};
+	visit(rootModule);
+	return [...controllers];
+}
+//#endregion
+//#region src/openapi/decorators.ts
+const API_DOC_METADATA = "vela:openapi:doc";
+const API_TAGS_METADATA = "vela:openapi:tags";
+const API_RESPONSES_METADATA = "vela:openapi:responses";
+/**
+* Attach OpenAPI documentation to a route handler (or controller).
+*
+* ```ts
+* @Get('/:id')
+* @ApiDoc({ summary: 'Get a user', description: '...', operationId: 'getUser' })
+* findOne(@Param('id') id: string) { ... }
+* ```
+*/
+function ApiDoc(metadata) {
+	return (target, propertyKey) => {
+		if (propertyKey !== void 0) MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, API_DOC_METADATA, metadata);
+		else MetadataRegistry.setCustomClassMeta(target, API_DOC_METADATA, metadata);
+	};
+}
+/**
+* Attach OpenAPI tags to a controller or handler. Handler-level tags merge
+* with controller-level tags; duplicates are de-duplicated in the output.
+*/
+function ApiTags(...tags) {
+	return (target, propertyKey) => {
+		if (propertyKey !== void 0) MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, API_TAGS_METADATA, tags);
+		else MetadataRegistry.setCustomClassMeta(target, API_TAGS_METADATA, tags);
+	};
+}
+function getApiDoc(target, propertyKey) {
+	if (propertyKey !== void 0) return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_DOC_METADATA);
+	return MetadataRegistry.getCustomClassMeta(target, API_DOC_METADATA);
+}
+function getApiTags(target, propertyKey) {
+	if (propertyKey !== void 0) return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_TAGS_METADATA);
+	return MetadataRegistry.getCustomClassMeta(target, API_TAGS_METADATA);
+}
+/**
+* Document a response for a given status code. Stackable: apply multiple
+* times on the same handler to declare different statuses.
+*
+* ```ts
+* @Get('/:id')
+* @ApiResponse(200, { description: 'Found', schema: UserDto })
+* @ApiResponse(404, { description: 'Not found', schema: ErrorDto })
+* findOne() { ... }
+* ```
+*/
+function ApiResponse(status, options) {
+	return (target, propertyKey) => {
+		MetadataRegistry.appendCustomHandlerMeta(target.constructor, propertyKey, API_RESPONSES_METADATA, {
+			status,
+			...options
+		});
+	};
+}
+function getApiResponses(target, propertyKey) {
+	return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_RESPONSES_METADATA);
+}
+//#endregion
+//#region src/openapi/zod-to-json-schema.ts
+function stripOpenApiIncompatible(schema) {
+	const out = { ...schema };
+	delete out.$schema;
+	if (Array.isArray(out.properties)) {} else if (out.properties && typeof out.properties === "object") {
+		const props = out.properties;
+		const cleaned = {};
+		for (const [key, val] of Object.entries(props)) cleaned[key] = stripOpenApiIncompatible(val);
+		out.properties = cleaned;
+	}
+	if (out.items && typeof out.items === "object") out.items = stripOpenApiIncompatible(out.items);
+	return out;
+}
+function zodToJsonSchema(schema) {
+	if (!schema || typeof schema !== "object") return {};
+	const maybe = schema.toJSONSchema;
+	if (typeof maybe === "function") try {
+		const result = maybe.call(schema);
+		if (result && typeof result === "object") return stripOpenApiIncompatible(result);
+	} catch {}
+	return {};
+}
+function ctorName(schema) {
+	if (!schema || typeof schema !== "object") return void 0;
+	return schema.constructor?.name;
+}
+function isOptional(schema) {
+	const name = ctorName(schema);
+	return name === "ZodOptional" || name === "ZodDefault";
+}
+//#endregion
+//#region src/openapi/document.ts
+/**
+* Tracks DTO classes referenced during document generation and registers
+* each under `components.schemas`. Handles name collisions by suffixing.
+*/
+var ComponentsRegistry = class {
+	schemas = /* @__PURE__ */ new Map();
+	classToKey = /* @__PURE__ */ new WeakMap();
+	ref(dtoClass) {
+		const existing = this.classToKey.get(dtoClass);
+		if (existing) return { $ref: `#/components/schemas/${existing}` };
+		const baseName = dtoClass.name && dtoClass.name !== "" ? dtoClass.name : "Schema";
+		let key = baseName;
+		let counter = 2;
+		while (this.schemas.has(key)) key = `${baseName}${counter++}`;
+		this.classToKey.set(dtoClass, key);
+		const staticSchema = dtoClass.schema;
+		this.schemas.set(key, zodToJsonSchema(staticSchema));
+		return { $ref: `#/components/schemas/${key}` };
+	}
+	build() {
+		if (this.schemas.size === 0) return void 0;
+		return Object.fromEntries(this.schemas);
+	}
+};
+function isDtoClass(value) {
+	return typeof value === "function" && value.schema != null;
+}
+function getParamSchema(param, paramtypes, registry) {
+	const metatype = param.metatype ?? paramtypes?.[param.index];
+	if (!metatype) return void 0;
+	if (isDtoClass(metatype)) return registry.ref(metatype);
+	const maybeSchema = metatype.schema;
+	if (maybeSchema) return zodToJsonSchema(maybeSchema);
+}
+function isParamOptional(param, paramtypes) {
+	const metatype = param.metatype ?? paramtypes?.[param.index];
+	if (metatype?.schema) return isOptional(metatype.schema);
+	return true;
+}
+function isLikelyJsonSchema(value) {
+	if (!value || typeof value !== "object") return false;
+	const v = value;
+	if (typeof v.toJSONSchema === "function") return false;
+	return "type" in v || "$ref" in v || "oneOf" in v || "anyOf" in v || "allOf" in v || "enum" in v || "const" in v;
+}
+function resolveResponseSchema(input, registry) {
+	if (input === void 0 || input === null) return void 0;
+	if (isDtoClass(input)) return registry.ref(input);
+	if (isLikelyJsonSchema(input)) return { ...input };
+	if (typeof input === "object" && typeof input.toJSONSchema === "function") return zodToJsonSchema(input);
+}
+function buildOperation(controller, route, pathString, registry) {
+	const handlerName = route.handlerName;
+	const paramMetadata = MetadataRegistry.getParameters(controller).get(handlerName) ?? [];
+	const paramtypes = Reflect.getMetadata("design:paramtypes", controller.prototype, handlerName);
+	const parameters = [];
+	let requestBody;
+	const declaredPathParams = /* @__PURE__ */ new Set();
+	const pathParamNames = [...pathString.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+	for (const param of paramMetadata) if (param.type === ParamType.PARAM && param.name) {
+		declaredPathParams.add(param.name);
+		parameters.push({
+			name: param.name,
+			in: "path",
+			required: true,
+			schema: getParamSchema(param, paramtypes, registry) ?? { type: "string" }
+		});
+	} else if (param.type === ParamType.QUERY && param.name) parameters.push({
+		name: param.name,
+		in: "query",
+		required: !isParamOptional(param, paramtypes),
+		schema: getParamSchema(param, paramtypes, registry) ?? { type: "string" }
+	});
+	else if (param.type === ParamType.HEADERS && param.name) parameters.push({
+		name: param.name,
+		in: "header",
+		required: !isParamOptional(param, paramtypes),
+		schema: getParamSchema(param, paramtypes, registry) ?? { type: "string" }
+	});
+	else if (param.type === ParamType.BODY) {
+		const schema = getParamSchema(param, paramtypes, registry);
+		if (schema) requestBody = {
+			required: !isParamOptional(param, paramtypes),
+			content: { "application/json": { schema } }
+		};
+	}
+	for (const name of pathParamNames) if (!declaredPathParams.has(name)) parameters.push({
+		name,
+		in: "path",
+		required: true,
+		schema: { type: "string" }
+	});
+	const docMeta = getApiDoc(controller, handlerName);
+	const controllerTags = getApiTags(controller) ?? [];
+	const handlerTags = getApiTags(controller, handlerName) ?? [];
+	const docTags = docMeta?.tags ?? [];
+	const mergedTags = [.../* @__PURE__ */ new Set([
+		...controllerTags,
+		...handlerTags,
+		...docTags
+	])];
+	const responses = { "200": { description: "OK" } };
+	const apiResponses = getApiResponses(controller, handlerName) ?? [];
+	for (const entry of apiResponses) {
+		const key = String(entry.status);
+		const resolved = { description: entry.description };
+		const schema = resolveResponseSchema(entry.schema, registry);
+		if (schema) resolved.content = { "application/json": { schema } };
+		responses[key] = resolved;
+	}
+	const operation = { responses };
+	if (parameters.length > 0) operation.parameters = parameters;
+	if (requestBody) operation.requestBody = requestBody;
+	if (docMeta?.summary) operation.summary = docMeta.summary;
+	if (docMeta?.description) operation.description = docMeta.description;
+	const operationId = docMeta?.operationId ?? route.name;
+	if (operationId) operation.operationId = operationId;
+	if (docMeta?.deprecated) operation.deprecated = docMeta.deprecated;
+	if (mergedTags.length > 0) operation.tags = mergedTags;
+	return operation;
+}
+const VERB_WHITELIST = /* @__PURE__ */ new Set([
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"options",
+	"head"
+]);
+function createOpenApiDocument(rootModule, options = {}) {
+	const paths = {};
+	const globalPrefix = options.globalPrefix ?? "";
+	const registry = new ComponentsRegistry();
+	const controllers = collectControllers(rootModule);
+	for (const controller of controllers) {
+		const controllerPath = MetadataRegistry.getControllerPath(controller);
+		const routes = MetadataRegistry.getRoutes(controller);
+		for (const route of routes) {
+			const method = route.method.toLowerCase();
+			if (!VERB_WHITELIST.has(method)) continue;
+			const pathString = toOpenApiPath(joinPaths(joinPaths(globalPrefix, controllerPath), route.path));
+			const operation = buildOperation(controller, route, pathString, registry);
+			const pathItem = paths[pathString] ?? {};
+			pathItem[method] = operation;
+			paths[pathString] = pathItem;
+		}
+	}
+	for (const contributor of getRouteContributors()) {
+		if (!contributor.buildOpenApiPaths) continue;
+		for (const controller of controllers) {
+			const meta = getMetadata(contributor.claimsMetaKey, controller);
+			if (meta === void 0) continue;
+			const controllerPrefix = MetadataRegistry.getControllerPath(controller);
+			const contributedPaths = contributor.buildOpenApiPaths({
+				controller,
+				meta,
+				globalPrefix,
+				controllerPrefix
+			});
+			for (const [pathKey, pathItem] of Object.entries(contributedPaths)) paths[pathKey] = {
+				...paths[pathKey] ?? {},
+				...pathItem
+			};
+		}
+	}
+	const seenTagNames = /* @__PURE__ */ new Set();
+	const collectedTagNames = [];
+	for (const pathItem of Object.values(paths)) for (const verb of VERB_WHITELIST) {
+		const operation = pathItem[verb];
+		if (!operation?.tags) continue;
+		for (const tagName of operation.tags) {
+			if (seenTagNames.has(tagName)) continue;
+			seenTagNames.add(tagName);
+			collectedTagNames.push(tagName);
+		}
+	}
+	const declaredTags = options.tags ?? [];
+	const declaredTagNames = new Set(declaredTags.map((t) => t.name));
+	const tags = [...declaredTags, ...collectedTagNames.filter((name) => !declaredTagNames.has(name)).map((name) => ({ name }))];
+	const document = {
+		openapi: "3.1.0",
+		info: {
+			title: options.info?.title ?? "Vela API",
+			version: options.info?.version ?? "1.0.0",
+			...options.info?.description ? { description: options.info.description } : {}
+		},
+		...options.servers?.length ? { servers: options.servers } : {},
+		paths
+	};
+	const schemas = registry.build();
+	if (schemas || options.securitySchemes) document.components = {
+		...schemas ? { schemas } : {},
+		...options.securitySchemes ? { securitySchemes: options.securitySchemes } : {}
+	};
+	if (options.security?.length) document.security = options.security;
+	if (tags.length > 0) document.tags = tags;
+	return document;
+}
+//#endregion
+//#region src/container/mixin.ts
+/**
+* Creates a reusable injectable mixin class from a base class.
+* Applies @Injectable() so the returned class can be registered as a provider.
+*
+* @example
+* ```ts
+* function RoleGuardMixin(role: string) {
+*   class MixedRoleGuard implements CanActivate {
+*     canActivate(ctx: ExecutionContext) {
+*       return ctx.getRequest().headers.get('x-role') === role;
+*     }
+*   }
+*   return mixin(MixedRoleGuard);
+* }
+*
+* const AdminGuard = RoleGuardMixin('admin');
+*
+* @UseGuards(AdminGuard)
+* @Get('/admin')
+* adminOnly() { ... }
+* ```
+*/
+function mixin(mixinClass) {
+	Injectable()(mixinClass);
+	return mixinClass;
+}
+//#endregion
+//#region src/http/lazy-param.decorator.ts
+const CUSTOM_PARAM_TYPE = "custom";
+/**
+* Factory for parameter decorators whose value materializes lazily — the
+* factory does not run during argument extraction; it runs the first time
+* the handler reads a property on the resolved value.
+*
+* Why this exists: vela's argument resolver runs *before* guards
+* (handler-executor order: extract args → guards → handler). A custom
+* `createParamDecorator` factory that depends on guard-populated state
+* (e.g. a value a guard places into `REQUEST_CONTEXT`) therefore observes
+* an empty slot. `createLazyParamDecorator` defers factory execution to
+* first property access on the proxied result, by which point guards have
+* run and the slot is populated.
+*
+* The proxy explicitly short-circuits `prop === 'then'` so `await value`
+* does not consider the proxy a thenable, which would otherwise trigger
+* eager resolution. This single invariant is what makes the helper safe to
+* pass through `async` boundaries without surprise.
+*
+* @example
+* ```ts
+* const CurrentUser = createLazyParamDecorator(
+*   (_data: unknown, ctx: ExecutionContext) => {
+*     const reqCtx = ctx.getContext().get('container').resolve(REQUEST_CONTEXT);
+*     return reqCtx.get('user');     // populated by AuthGuard
+*   },
+* );
+*
+* @UseGuards(AuthGuard)
+* @Get('/me')
+* me(@CurrentUser() user: User) {
+*   return { id: user.id };          // factory runs here, after AuthGuard
+* }
+* ```
+*/
+function createLazyParamDecorator(factory) {
+	return (data, ...pipes) => {
+		return (target, propertyKey, parameterIndex) => {
+			if (propertyKey === void 0) throw new Error("Parameter decorators can only be used on method parameters");
+			MetadataRegistry.addParameter(target.constructor, propertyKey, {
+				index: parameterIndex,
+				type: CUSTOM_PARAM_TYPE,
+				name: void 0,
+				factory: (_unused, ctx) => {
+					const execCtx = buildExecutionContext(ctx, target.constructor, propertyKey);
+					return createLazyProxy(() => factory(data, execCtx));
+				},
+				...pipes.length > 0 ? { pipes } : {}
+			});
+		};
+	};
+}
+function createLazyProxy(produce) {
+	let resolved = false;
+	let value;
+	const materialize = () => {
+		if (!resolved) {
+			value = produce();
+			resolved = true;
+		}
+		return value;
+	};
+	return new Proxy(Object.create(null), {
+		get(_t, prop, receiver) {
+			if (prop === "then") return void 0;
+			const real = materialize();
+			if (real === null || real === void 0) return void 0;
+			const descriptor = Reflect.get(real, prop, receiver);
+			if (typeof descriptor === "function") return descriptor.bind(real);
+			return descriptor;
+		},
+		has(_t, prop) {
+			const real = materialize();
+			return real !== null && real !== void 0 && Reflect.has(real, prop);
+		},
+		ownKeys() {
+			const real = materialize();
+			if (real === null || real === void 0) return [];
+			return Reflect.ownKeys(real);
+		},
+		getOwnPropertyDescriptor(_t, prop) {
+			const real = materialize();
+			if (real === null || real === void 0) return void 0;
+			const descriptor = Reflect.getOwnPropertyDescriptor(real, prop);
+			if (descriptor) descriptor.configurable = true;
+			return descriptor;
+		}
+	});
+}
+//#endregion
+//#region src/http/ambient.ts
+/**
+* Returns Hono's `contextStorage()` middleware. Register it as the FIRST global
+* middleware so `getCurrentContainer()` works everywhere downstream. When using
+* `VelaFactory.create(module, { ambientContainer: true })` this is wired
+* automatically — call this only for manual/raw Hono setups.
+*/
+function enableAmbientContainer() {
+	return contextStorage();
+}
+function tryGetContext() {
+	try {
+		return getContext();
+	} catch {
+		return;
+	}
+}
+/**
+* The current request's DI container. Throws with actionable guidance if
+* ambient access isn't enabled or this runs outside a request.
+*/
+function getCurrentContainer() {
+	const container = tryGetContext()?.get("container");
+	if (!container) throw new Error("getCurrentContainer() is unavailable: enable ambient access via VelaFactory.create(module, { ambientContainer: true }) (or app.use(enableAmbientContainer())) and only call it within a request.");
+	return container;
+}
+/** The current request's {@link RequestContext} (via the ambient container). */
+function getCurrentRequestContext() {
+	return getCurrentContainer().resolve(REQUEST_CONTEXT);
+}
+//#endregion
+//#region src/http/request-container.ts
+/**
+* Returns the request-scoped child container for the current request.
+*
+* `@Inject(Container)` resolves the ROOT container (request children share the
+* provider map and never rebind `Container`), so module authors who need
+* request-scoped resolution from inside a handler, param-decorator factory, or
+* scoped middleware must read the child seeded by RouteManager instead. The
+* child is created before guards, pipes, params, and handlers run, so it is
+* always present on the Vela request path.
+*
+* Throws outside a Vela-managed request rather than materializing an orphan
+* child (mirrors the REQUEST_CONTEXT fail-fast).
+*/
+function getRequestContainer(c) {
+	const container = c.get("container");
+	if (!container) throw new Error("getRequestContainer(c) can only be called inside a Vela-managed request — the request child container is seeded by RouteManager when the request enters the pipeline.");
+	return container;
+}
+//#endregion
+//#region src/services/logger.ts
+var _Logger;
+const LogLevel = {
+	VERBOSE: 0,
+	DEBUG: 1,
+	LOG: 2,
+	WARN: 3,
+	ERROR: 4,
+	SILENT: 5
+};
+const defaultWriter = (level, line, ...rest) => {
+	if (level === "ERROR") return console.error(line, ...rest);
+	if (level === "WARN") return console.warn(line, ...rest);
+	if (level === "DEBUG" || level === "VERBOSE") return console.debug(line, ...rest);
+	return console.log(line, ...rest);
+};
+function formatValue(v) {
+	if (typeof v === "string") return /[\s="\\]/.test(v) ? JSON.stringify(v) : v;
+	if (typeof v === "number" || typeof v === "boolean") return String(v);
+	try {
+		return JSON.stringify(v);
+	} catch {
+		return String(v);
+	}
+}
+let Logger = class Logger {
+	static {
+		_Logger = this;
+	}
+	static level = LogLevel.LOG;
+	static globalLogger;
+	static globalContextProviders = [];
+	static globalWriter = defaultWriter;
+	context;
+	instanceContextProviders = [];
+	instanceWriter;
+	static setLogLevel(level) {
+		_Logger.level = level;
+	}
+	static overrideLogger(logger) {
+		_Logger.globalLogger = logger;
+	}
+	/** Register a context provider run on every log line from every logger. */
+	static addContextProvider(provider) {
+		_Logger.globalContextProviders.push(provider);
+	}
+	/** Remove all registered global context providers. */
+	static clearContextProviders() {
+		_Logger.globalContextProviders = [];
+	}
+	/** Replace the default console writer. Useful on edge runtimes that have
+	*  a different output sink (e.g. `env.LOGS.writeDataPoint` on Workers). */
+	static setWriter(writer) {
+		_Logger.globalWriter = writer;
+	}
+	/** Restore the default console-based writer. */
+	static resetWriter() {
+		_Logger.globalWriter = defaultWriter;
+	}
+	constructor(context) {
+		if (context) this.context = context;
+	}
+	setContext(context) {
+		this.context = context;
+	}
+	/** Add a context provider that runs only for THIS logger instance.
+	*  Children created via extend() inherit these providers by copy. */
+	addContextProvider(provider) {
+		this.instanceContextProviders.push(provider);
+		return this;
+	}
+	/** Override the writer for this logger (and any extend() children). */
+	setWriter(writer) {
+		this.instanceWriter = writer;
+		return this;
+	}
+	/** Create a child logger with a nested namespace. Context becomes
+	*  `parent:child`; instance-level providers and writers are inherited
+	*  by copy so later mutations on either logger stay isolated. */
+	extend(namespace) {
+		const newContext = this.context ? `${this.context}:${namespace}` : namespace;
+		const child = new _Logger(newContext);
+		child.instanceContextProviders = [...this.instanceContextProviders];
+		if (this.instanceWriter) child.instanceWriter = this.instanceWriter;
+		return child;
+	}
+	log(message, ...optionalParams) {
+		this.emit("LOG", LogLevel.LOG, message, optionalParams);
+	}
+	error(message, ...optionalParams) {
+		this.emit("ERROR", LogLevel.ERROR, message, optionalParams);
+	}
+	warn(message, ...optionalParams) {
+		this.emit("WARN", LogLevel.WARN, message, optionalParams);
+	}
+	debug(message, ...optionalParams) {
+		this.emit("DEBUG", LogLevel.DEBUG, message, optionalParams);
+	}
+	verbose(message, ...optionalParams) {
+		this.emit("VERBOSE", LogLevel.VERBOSE, message, optionalParams);
+	}
+	emit(levelName, levelValue, message, rest) {
+		if (_Logger.level > levelValue) return;
+		if (_Logger.globalLogger === false) return;
+		if (_Logger.globalLogger) {
+			const method = levelName.toLowerCase();
+			const fn = _Logger.globalLogger[method];
+			if (fn) fn.call(_Logger.globalLogger, message, ...rest);
+			return;
+		}
+		const line = this.formatMessage(levelName, message);
+		(this.instanceWriter ?? _Logger.globalWriter)(levelName, line, ...rest);
+	}
+	formatMessage(level, message) {
+		return `[Vela] ${(/* @__PURE__ */ new Date()).toISOString()} ${level}${this.context ? ` [${this.context}]` : ""} ${message}${this.formatContextObj(this.collectContext())}`;
+	}
+	collectContext() {
+		const result = {};
+		for (const provider of _Logger.globalContextProviders) try {
+			Object.assign(result, provider());
+		} catch {}
+		for (const provider of this.instanceContextProviders) try {
+			Object.assign(result, provider());
+		} catch {}
+		return result;
+	}
+	formatContextObj(obj) {
+		const parts = [];
+		for (const key of Object.keys(obj)) {
+			const value = obj[key];
+			if (value === void 0 || value === null) continue;
+			parts.push(`${key}=${formatValue(value)}`);
+		}
+		return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+	}
+};
+Logger = _Logger = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [String])], Logger);
+//#endregion
+//#region src/config/config.store.ts
+/** Prototype-pollution guard for dot-notation segments. */
+const DANGEROUS_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function runSchema(schema, config) {
+	if (typeof schema === "function") {
+		schema(config);
+		return;
+	}
+	if (schema && typeof schema.parse === "function") {
+		schema.parse(config);
+		return;
+	}
+	throw new Error("ConfigModule `validateSchema` must be a function or expose a `parse()` method");
+}
+let ConfigStore = class ConfigStore {
+	container;
+	config;
+	validateSchema;
+	namespaceKeys = /* @__PURE__ */ new Map();
+	cache = /* @__PURE__ */ new Map();
+	validated = false;
+	validationError;
+	constructor(container, config = {}, namespaces = [], validateSchema) {
+		this.container = container;
+		this.config = config;
+		this.validateSchema = validateSchema;
+		for (const ns of namespaces) this.namespaceKeys.set(ns.namespace, ns.KEY);
+	}
+	/** Read a value by dot-notation path; `undefined` if absent. */
+	get(path) {
+		this.ensureValidated();
+		return this.read(path);
+	}
+	/** Read a value by dot-notation path; throws if absent. */
+	getOrThrow(path) {
+		const value = this.get(path);
+		if (value === void 0) throw new Error(`Configuration key "${path}" was not found`);
+		return value;
+	}
+	/** Whether a dot-notation path resolves to a defined value. */
+	has(path) {
+		this.ensureValidated();
+		return this.read(path) !== void 0;
+	}
+	/** The full merged config object (flat record + resolved namespaces). */
+	all() {
+		this.ensureValidated();
+		return this.merged();
+	}
+	read(path) {
+		const [head, ...rest] = path.split(".");
+		if (head === void 0 || DANGEROUS_KEYS.has(head)) return void 0;
+		let current = this.namespaceKeys.has(head) ? this.resolveNamespace(head) : this.config[head];
+		for (const key of rest) {
+			if (DANGEROUS_KEYS.has(key)) return void 0;
+			if (current === null || current === void 0 || typeof current !== "object") return;
+			current = current[key];
+		}
+		return current;
+	}
+	/** Resolve a namespace's KEY through the container on first use, then cache. */
+	resolveNamespace(namespace) {
+		if (this.cache.has(namespace)) return this.cache.get(namespace);
+		const key = this.namespaceKeys.get(namespace);
+		const value = key === void 0 ? void 0 : this.container.resolve(key);
+		this.cache.set(namespace, value);
+		return value;
+	}
+	merged() {
+		const out = { ...this.config };
+		for (const namespace of this.namespaceKeys.keys()) out[namespace] = this.resolveNamespace(namespace);
+		return out;
+	}
+	/**
+	* Validate the merged config once, on first read. Deferred (not at bootstrap)
+	* because the merged shape needs namespace factories — and their env — which
+	* are only available after bootstrap on edge runtimes.
+	*/
+	ensureValidated() {
+		if (this.validated) {
+			if (this.validationError) throw this.validationError;
+			return;
+		}
+		this.validated = true;
+		if (!this.validateSchema) return;
+		try {
+			runSchema(this.validateSchema, this.merged());
+		} catch (err) {
+			this.validationError = err;
+			throw err;
+		}
+	}
+};
+ConfigStore = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [
+	typeof Pick === "undefined" ? Object : Pick,
+	typeof Record === "undefined" ? Object : Record,
+	Array,
+	Object
+])], ConfigStore);
+//#endregion
+//#region src/config/config.service.ts
+let ConfigService = class ConfigService {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	get(path, defaultValue) {
+		const value = this.store.get(path);
+		return value === void 0 ? defaultValue : value;
+	}
+	/** Read a config value; throws when the path is absent. */
+	getOrThrow(path) {
+		return this.store.getOrThrow(path);
+	}
+	/** Whether a config path resolves to a defined value. */
+	has(path) {
+		return this.store.has(path);
+	}
+	/** The full merged config object (flat record + resolved namespaces). */
+	getAll() {
+		return this.store.all();
+	}
+};
+ConfigService = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(ConfigStore)),
+	__decorateMetadata("design:paramtypes", [typeof ConfigStore === "undefined" ? Object : ConfigStore])
+], ConfigService);
+//#endregion
+//#region src/config/config.module.ts
+/**
+* Carrier for the namespace `asProvider()` KEY providers ONLY. Split out of
+* ConfigModule and marked `lazy: true` so those factories — which inject
+* `CONFIG_ENV`, live per-request on edge runtimes — never run at bootstrap.
+* ConfigModule itself stays EAGER (see below).
+*/
+var ConfigNamespacesModule = class {};
+/**
+* Build the lazy sub-module holding one KEY provider per namespace. Its `key`
+* is derived from the owning ConfigModule instance key so multiple ConfigModule
+* instances get distinct sub-module instances (no import-dedup collision).
+*/
+function namespacesSubModule(load, key) {
+	return {
+		module: ConfigNamespacesModule,
+		key: `config-ns:${key}`,
+		lazy: true,
+		providers: load.map((namespace) => namespace.asProvider()),
+		exports: load.map((namespace) => namespace.KEY)
+	};
+}
+const { ConfigurableModuleClass: ConfigurableModuleClass$5 } = defineModule({
+	name: "Config",
+	setup: ({ OPTIONS, options, key }) => {
+		const load = options.load ?? [];
+		const { validateSchema } = options;
+		return {
+			imports: load.length > 0 ? [namespacesSubModule(load, key)] : [],
+			providers: [
+				{
+					provide: CONFIG_OPTIONS,
+					useFactory: (opts) => opts.validate ? opts.validate(opts.config ?? {}) : opts.config ?? {},
+					inject: [OPTIONS]
+				},
+				{
+					provide: ConfigStore,
+					useFactory: (container, config) => new ConfigStore(container, config, load, validateSchema),
+					inject: [Container, CONFIG_OPTIONS]
+				},
+				ConfigService
+			],
+			exports: [
+				ConfigService,
+				ConfigStore,
+				CONFIG_OPTIONS,
+				...load.map((n) => n.KEY)
+			]
+		};
+	}
+});
+var ConfigModule = class extends ConfigurableModuleClass$5 {
+	/**
+	* Preserve (a) per-call generic inference over the flat config record and
+	* (b) the eager-validation contract: `validate` runs at call time so bad
+	* config fails fast, then is stripped so the derived `CONFIG_OPTIONS`
+	* provider is a passthrough (no double validation). `validateSchema` (the
+	* merged-config schema) is deferred to first read — its input needs env.
+	*/
+	static forRoot(options = {}) {
+		const validatedConfig = options.validate ? options.validate(options.config ?? {}) : options.config;
+		const { validate: _validate, ...rest } = options;
+		return super.forRoot({
+			...rest,
+			config: validatedConfig
+		});
+	}
+};
+//#endregion
+//#region src/config/register-as.ts
+/**
+* Create a namespaced configuration factory (NestJS `registerAs` parity).
+*
+* The `KEY` is minted with `Symbol.for` so it keeps a stable identity across
+* module re-evaluation (HMR / repeated imports) — a fresh `InjectionToken`
+* would mint a new identity each eval and break dedup. It is typed as
+* `InjectionToken<TConfig>` purely for injection-site DX.
+*
+* @example
+* ```ts
+* export const dbConfig = registerAs('database', (env: Env) => ({
+*   url: env.DATABASE_URL,
+*   pool: 10,
+* }));
+* // ConfigModule.forRoot({ load: [dbConfig] });
+* // cfg.get('database.url');                              // via ConfigService
+* // constructor(@Inject(dbConfig.KEY) db: InferConfigType<typeof dbConfig>) {}
+* ```
+*/
+function registerAs(namespace, factory) {
+	const KEY = Symbol.for(`vela:config:${namespace}`);
+	return {
+		KEY,
+		namespace,
+		factory,
+		asProvider() {
+			return {
+				provide: KEY,
+				useFactory: factory,
+				inject: [CONFIG_ENV]
+			};
+		}
+	};
+}
+//#endregion
+//#region src/fetch/fetch.service.ts
+const HTTP_MODULE_OPTIONS = new InjectionToken("HTTP_MODULE_OPTIONS");
+var HttpRequestException = class extends Error {
+	status;
+	statusText;
+	response;
+	constructor(status, statusText, response) {
+		super(`HTTP ${status} ${statusText}`);
+		this.status = status;
+		this.statusText = statusText;
+		this.response = response;
+		this.name = "HttpRequestException";
+	}
+};
+let HttpService = class HttpService {
+	baseURL;
+	defaultHeaders;
+	defaultTimeout;
+	constructor(options) {
+		const opts = options ?? {};
+		this.baseURL = opts.baseURL ?? "";
+		this.defaultHeaders = opts.headers ?? {};
+		this.defaultTimeout = opts.timeout;
+	}
+	get(url, config) {
+		return this.request({
+			method: "GET",
+			url,
+			...config
+		});
+	}
+	post(url, body, config) {
+		return this.request({
+			method: "POST",
+			url,
+			body,
+			...config
+		});
+	}
+	put(url, body, config) {
+		return this.request({
+			method: "PUT",
+			url,
+			body,
+			...config
+		});
+	}
+	patch(url, body, config) {
+		return this.request({
+			method: "PATCH",
+			url,
+			body,
+			...config
+		});
+	}
+	delete(url, config) {
+		return this.request({
+			method: "DELETE",
+			url,
+			...config
+		});
+	}
+	head(url, config) {
+		return this.request({
+			method: "HEAD",
+			url,
+			...config
+		});
+	}
+	async request(config) {
+		const fullUrl = this.buildUrl(config.url, config.params);
+		const headers = {
+			...this.defaultHeaders,
+			...config.headers
+		};
+		const init = {
+			method: config.method,
+			headers
+		};
+		if (config.body !== void 0) if (typeof config.body === "string" || config.body instanceof FormData) init.body = config.body;
+		else {
+			init.body = JSON.stringify(config.body);
+			if (!headers["Content-Type"] && !headers["content-type"]) headers["Content-Type"] = "application/json";
+		}
+		const timeout = config.timeout ?? this.defaultTimeout;
+		if (timeout !== void 0) init.signal = AbortSignal.timeout(timeout);
+		const response = await fetch(fullUrl, init);
+		if (!response.ok) throw new HttpRequestException(response.status, response.statusText, response);
+		return {
+			data: await this.parseBody(response),
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		};
+	}
+	buildUrl(url, params) {
+		const base = this.baseURL ? `${this.baseURL}${url}` : url;
+		if (!params || Object.keys(params).length === 0) return base;
+		return `${base}?${new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString()}`;
+	}
+	async parseBody(response) {
+		if (response.status === 204 || response.headers.get("content-length") === "0") return;
+		if ((response.headers.get("content-type") ?? "").includes("application/json")) return response.json();
+		return response.text();
+	}
+};
+HttpService = __decorate([
+	Injectable(),
+	__decorateParam(0, Optional()),
+	__decorateParam(0, Inject(HTTP_MODULE_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [Object])
+], HttpService);
+//#endregion
+//#region src/fetch/fetch.module.ts
+const { ConfigurableModuleClass: ConfigurableModuleClass$4 } = new ConfigurableModuleBuilder({
+	moduleName: "Http",
+	optionsInjectionToken: HTTP_MODULE_OPTIONS
+}).build();
+let HttpModule = class HttpModule extends ConfigurableModuleClass$4 {};
+HttpModule = __decorate([Module({
+	providers: [{
+		provide: HTTP_MODULE_OPTIONS,
+		useValue: {}
+	}, HttpService],
+	exports: [HttpService, HTTP_MODULE_OPTIONS]
+})], HttpModule);
+//#endregion
+//#region src/cors/cors.tokens.ts
+const CORS_OPTIONS = new InjectionToken("CORS_OPTIONS");
+//#endregion
+//#region src/cors/cors.module.ts
+function buildCorsMiddleware(options) {
+	const corsMiddleware = cors({
+		origin: options.origin ?? "*",
+		allowMethods: options.allowMethods,
+		allowHeaders: options.allowHeaders,
+		exposeHeaders: options.exposeHeaders,
+		credentials: options.credentials,
+		maxAge: options.maxAge
+	});
+	return { use: (c, next) => corsMiddleware(c, next) };
+}
+const { ConfigurableModuleClass: ConfigurableModuleClass$3 } = defineModule({
+	name: "Cors",
+	optionsToken: CORS_OPTIONS,
+	setup: ({ OPTIONS }) => ({
+		providers: [{
+			provide: APP_MIDDLEWARE,
+			useFactory: (options) => buildCorsMiddleware(options),
+			inject: [OPTIONS]
+		}],
+		exports: [OPTIONS]
+	})
+});
+var CorsModule = class extends ConfigurableModuleClass$3 {};
+//#endregion
+//#region src/pipeline/reflector.ts
+/**
+* Decorator that attaches custom metadata to a class or method.
+* Read via Reflector in guards/interceptors.
+*
+* @example
+* ```ts
+* const Roles = (...roles: string[]) => SetMetadata('roles', roles);
+*
+* @Controller('/admin')
+* @Roles('admin')
+* class AdminController { ... }
+* ```
+*/
+function SetMetadata(key, value) {
+	return (target, propertyKey) => {
+		if (propertyKey !== void 0) MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, key, value);
+		else MetadataRegistry.setCustomClassMeta(target, key, value);
+	};
+}
+/**
+* Reads custom metadata set by @SetMetadata().
+* Use in guards/interceptors via ExecutionContext.
+*
+* @example
+* ```ts
+* class RolesGuard implements CanActivate {
+*   private reflector = new Reflector();
+*
+*   canActivate(context: ExecutionContext): boolean {
+*     const roles = this.reflector.get<string[]>('roles', context);
+*     if (!roles) return true;
+*     const user = ...; // extract from request
+*     return roles.some(r => user.roles.includes(r));
+*   }
+* }
+* ```
+*/
+var Reflector = class {
+	/**
+	* Create a type-safe decorator that sets metadata with a typed key.
+	*
+	* @example
+	* ```ts
+	* const Roles = Reflector.createDecorator<string[]>();
+	* // Roles(['admin']) — class or method decorator
+	* // reflector.get(Roles, context) — typed as string[] | undefined
+	* ```
+	*/
+	static createDecorator(options) {
+		const key = options?.key ?? `vela:custom:${crypto.randomUUID()}`;
+		const decorator = (value) => SetMetadata(key, value);
+		decorator.KEY = key;
+		return decorator;
+	}
+	resolveKey(keyOrDecorator) {
+		return typeof keyOrDecorator === "string" ? keyOrDecorator : keyOrDecorator.KEY;
+	}
+	/**
+	* Get metadata value from handler first, then class.
+	* Handler-level metadata takes priority over class-level.
+	*/
+	get(key, context) {
+		const resolvedKey = this.resolveKey(key);
+		const ctor = context.getClass();
+		const handlerValue = MetadataRegistry.getCustomHandlerMeta(ctor, context.getHandler(), resolvedKey);
+		if (handlerValue !== void 0) return handlerValue;
+		return MetadataRegistry.getCustomClassMeta(ctor, resolvedKey);
+	}
+	/**
+	* Get metadata only from the handler (method) level.
+	*/
+	getHandler(key, context) {
+		const resolvedKey = this.resolveKey(key);
+		return MetadataRegistry.getCustomHandlerMeta(context.getClass(), context.getHandler(), resolvedKey);
+	}
+	/**
+	* Get metadata only from the class level.
+	*/
+	getClass(key, context) {
+		const resolvedKey = this.resolveKey(key);
+		return MetadataRegistry.getCustomClassMeta(context.getClass(), resolvedKey);
+	}
+	/**
+	* Get all metadata values for a key from both handler and class.
+	* Returns [handlerValue, classValue] (either may be undefined).
+	*/
+	getAll(key, context) {
+		return [this.getHandler(key, context), this.getClass(key, context)];
+	}
+	/**
+	* Returns handler value if defined, else class value, else undefined.
+	* First defined value wins.
+	*/
+	getAllAndOverride(key, context) {
+		return this.getHandler(key, context) ?? this.getClass(key, context);
+	}
+	/**
+	* Collects handler + class values, filters undefineds.
+	* - 0 values → []
+	* - 1 value → return it
+	* - Arrays → concatenate
+	* - Objects → Object.assign({}, ...values)
+	* - Otherwise → wrap in array
+	*/
+	getAllAndMerge(key, context) {
+		const [handlerValue, classValue] = this.getAll(key, context);
+		const values = [];
+		if (handlerValue !== void 0) values.push(handlerValue);
+		if (classValue !== void 0) values.push(classValue);
+		if (values.length === 0) return [];
+		if (values.length === 1) return values[0];
+		if (Array.isArray(values[0]) && Array.isArray(values[1])) return [...values[0], ...values[1]];
+		if (typeof values[0] === "object" && values[0] !== null && !Array.isArray(values[0]) && typeof values[1] === "object" && values[1] !== null && !Array.isArray(values[1])) return Object.assign({}, values[0], values[1]);
+		return values;
+	}
+};
+//#endregion
+//#region src/cache/cache.tokens.ts
+const CACHE_MANAGER = new InjectionToken("CACHE_MANAGER");
+const CACHE_MODULE_OPTIONS = new InjectionToken("CACHE_MODULE_OPTIONS");
+const CACHE_KEY_METADATA = "vela:cache-key";
+const CACHE_TTL_METADATA = "vela:cache-ttl";
+//#endregion
+//#region src/cache/cache.interceptor.ts
+let CacheInterceptor = class CacheInterceptor {
+	cacheStore;
+	options;
+	reflector = new Reflector();
+	constructor(cacheStore, options) {
+		this.cacheStore = cacheStore;
+		this.options = options;
+	}
+	async intercept(context, next) {
+		const request = context.getRequest();
+		if (request.method !== "GET") return next.handle();
+		const customKey = this.reflector.getAllAndOverride(CACHE_KEY_METADATA, context);
+		const url = new URL(request.url);
+		const cacheKey = customKey ?? `cache:GET:${url.pathname}`;
+		const cached = this.cacheStore.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const result = await next.handle();
+		const ttl = this.reflector.getAllAndOverride("vela:cache-ttl", context) ?? this.options.ttl ?? 5;
+		this.cacheStore.set(cacheKey, result, ttl);
+		return result;
+	}
+};
+CacheInterceptor = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(CACHE_MANAGER)),
+	__decorateParam(1, Inject(CACHE_MODULE_OPTIONS)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], CacheInterceptor);
+//#endregion
+//#region src/cache/cache.service.ts
+let CacheService = class CacheService {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	get(key) {
+		return this.store.get(key);
+	}
+	set(key, value, ttl) {
+		this.store.set(key, value, ttl);
+	}
+	del(key) {
+		this.store.del(key);
+	}
+	clear() {
+		this.store.clear();
+	}
+};
+CacheService = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(CACHE_MANAGER)),
+	__decorateMetadata("design:paramtypes", [Object])
+], CacheService);
+//#endregion
+//#region src/cache/cache.store.ts
+var MemoryCacheStore = class {
+	store = /* @__PURE__ */ new Map();
+	defaultTtl;
+	max;
+	constructor(ttl = 5, max = 100) {
+		this.defaultTtl = ttl;
+		this.max = max;
+	}
+	get(key) {
+		const entry = this.store.get(key);
+		if (!entry) return void 0;
+		if (Date.now() > entry.expiresAt) {
+			this.store.delete(key);
+			return;
+		}
+		return entry.value;
+	}
+	set(key, value, ttl) {
+		if (!this.store.has(key) && this.store.size >= this.max) this.evict();
+		const effectiveTtl = ttl ?? this.defaultTtl;
+		this.store.set(key, {
+			value,
+			expiresAt: Date.now() + effectiveTtl * 1e3
+		});
+	}
+	del(key) {
+		this.store.delete(key);
+	}
+	clear() {
+		this.store.clear();
+	}
+	evict() {
+		const now = Date.now();
+		for (const [key, entry] of this.store) if (now > entry.expiresAt) this.store.delete(key);
+		if (this.store.size >= this.max) {
+			const firstKey = this.store.keys().next().value;
+			if (firstKey !== void 0) this.store.delete(firstKey);
+		}
+	}
+};
+//#endregion
+//#region src/cache/cache.module.ts
+const { ConfigurableModuleClass: ConfigurableModuleClass$2, MODULE_OPTIONS_TOKEN: MODULE_OPTIONS_TOKEN$1 } = new ConfigurableModuleBuilder({
+	moduleName: "Cache",
+	optionsInjectionToken: CACHE_MODULE_OPTIONS
+}).setExtras({ isGlobal: false }, (definition, { isGlobal }) => isGlobal ? {
+	...definition,
+	providers: [...definition.providers ?? [], {
+		provide: APP_INTERCEPTOR,
+		useExisting: CacheInterceptor
+	}]
+} : definition).build();
+let CacheModule = class CacheModule extends ConfigurableModuleClass$2 {};
+CacheModule = __decorate([Module({
+	providers: [
+		CacheService,
+		CacheInterceptor,
+		{
+			provide: CACHE_MANAGER,
+			useFactory: (options) => options.store ?? new MemoryCacheStore(options.ttl ?? 5, options.max ?? 100),
+			inject: [MODULE_OPTIONS_TOKEN$1]
+		}
+	],
+	exports: [
+		CACHE_MANAGER,
+		CACHE_MODULE_OPTIONS,
+		CacheService,
+		CacheInterceptor
+	]
+})], CacheModule);
+//#endregion
+//#region src/cache/tiered-cache.store.ts
+/**
+* Composes an ordered list of cache tiers (fastest first, e.g. in-memory L1 →
+* KV L2). Tiers may be sync ({@link CacheStore}) or async ({@link AsyncCacheStore}) —
+* results are awaited uniformly. Reads are read-through: the first tier with a
+* hit wins, and nearer tiers that missed are backfilled. Writes/deletes/clears
+* fan out to all tiers. Always async ({@link AsyncCacheStore}).
+*
+* Runtime-agnostic — the concrete tiers (memory here, KV in `@velajs/cloudflare`)
+* live wherever fits.
+*/
+var TieredCacheStore = class {
+	tiers;
+	constructor(tiers) {
+		if (tiers.length === 0) throw new Error("TieredCacheStore requires at least one tier.");
+		this.tiers = tiers;
+	}
+	async get(key) {
+		for (let i = 0; i < this.tiers.length; i++) {
+			const value = await this.tiers[i].get(key);
+			if (value !== void 0) {
+				for (let j = 0; j < i; j++) await this.tiers[j].set(key, value);
+				return value;
+			}
+		}
+	}
+	async set(key, value, ttl) {
+		await Promise.all(this.tiers.map((tier) => tier.set(key, value, ttl)));
+	}
+	async del(key) {
+		await Promise.all(this.tiers.map((tier) => tier.del(key)));
+	}
+	async clear() {
+		await Promise.all(this.tiers.map((tier) => tier.clear()));
+	}
+};
+//#endregion
+//#region src/cache/cache.decorators.ts
+const CacheKey = (key) => SetMetadata(CACHE_KEY_METADATA, key);
+const CacheTTL = (seconds) => SetMetadata(CACHE_TTL_METADATA, seconds);
+//#endregion
+//#region src/module/lazy-provider.ts
+/**
+* Provide a zero-arg thunk `() => T` whose factory runs on FIRST CALL, not at
+* provider construction — for values that don't exist yet when the module
+* graph is built (Cloudflare bindings are only live at request time).
+*
+* The shared primitive replacing the hand-rolled
+* `useFactory: (...deps) => () => build(...deps)` closure that auth and
+* storage each copy-pasted.
+*
+* ```ts
+* lazyProvider({
+*   provide: STORAGE_DRIVER_BUILDER,
+*   inject: [MODULE_OPTIONS_TOKEN],
+*   useFactory: (options) => options.driver(),
+* })
+* ```
+*/
+function lazyProvider(spec) {
+	const memoize = spec.memoize ?? true;
+	return {
+		provide: spec.provide,
+		inject: [...spec.inject ?? []],
+		useFactory: (...deps) => {
+			const build = () => spec.useFactory(...deps);
+			if (!memoize) return build;
+			let cached;
+			return () => (cached ??= { value: build() }).value;
+		}
+	};
+}
+const GLOBAL_COMPONENT_TOKENS = {
+	guard: APP_GUARD,
+	pipe: APP_PIPE,
+	interceptor: APP_INTERCEPTOR,
+	filter: APP_FILTER,
+	middleware: APP_MIDDLEWARE
+};
+/**
+* The one idiom for registering an app-wide component from a module's
+* providers. Returns registrations to spread:
+*
+* ```ts
+* providers: [MyService, ...provideGlobal('guard', AuthGuard)]
+* ```
+*
+* Class components are registered as providers and wired via `useExisting`
+* (so DI constructs them with their dependencies); instances via `useValue`.
+* Inside `defineModule`, prefer the equivalent `global:` contribution slot.
+*/
+function provideGlobal(kind, component) {
+	const token = GLOBAL_COMPONENT_TOKENS[kind];
+	if (typeof component === "function") return [component, {
+		provide: token,
+		useExisting: component
+	}];
+	return [{
+		provide: token,
+		useValue: component
+	}];
+}
+/**
+* A first-class side-effect-only module: contributes providers/exports without
+* being a configurable module — the supported form of the "empty marker
+* module" trick (i18n's `registerMessages`). Content-derived `key` makes
+* identical contributions dedup (HMR-idempotent) while distinct ones coexist.
+*
+* ```ts
+* export function registerMessages(messages: Messages): DynamicModule {
+*   return sideEffectModule('I18nMessages', {
+*     providers: [{ provide: I18N_MESSAGES, useValue: messages }],
+*     exports: [I18N_MESSAGES],
+*   });
+* }
+* ```
+*/
+function sideEffectModule(name, contributions = {}) {
+	const { key, ...rest } = contributions;
+	const moduleClass = { [name]: class {} }[name];
+	Module({})(moduleClass);
+	return {
+		module: moduleClass,
+		key: key ?? stableHash(rest),
+		providers: rest.providers ?? [],
+		controllers: rest.controllers ?? [],
+		imports: rest.imports ?? [],
+		exports: rest.exports ?? []
+	};
+}
+/**
+* Blessed token-minting convention: always an `InjectionToken` (never a raw
+* string), named for diagnostics. Namespace it `'<pkg>:<area>:<thing>'`.
+*/
+function moduleToken(name) {
+	return new InjectionToken(name);
+}
+//#endregion
+//#region src/event-emitter/event-emitter.service.ts
+function isWildcard(pattern) {
+	return pattern.includes("*");
+}
+function compilePattern(pattern) {
+	const regexStr = pattern.split(".").map((segment) => {
+		if (segment === "**") return ".*";
+		if (segment === "*") return "[^.]+";
+		return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}).join("\\.");
+	return new RegExp(`^${regexStr}$`);
+}
+let EventEmitter = class EventEmitter {
+	exactListeners = /* @__PURE__ */ new Map();
+	exactOnceListeners = /* @__PURE__ */ new Map();
+	wildcardListeners = /* @__PURE__ */ new Map();
+	on(event, handler) {
+		if (isWildcard(event)) this.getOrCreateWildcard(event).handlers.add(handler);
+		else {
+			const handlers = this.exactListeners.get(event) ?? /* @__PURE__ */ new Set();
+			handlers.add(handler);
+			this.exactListeners.set(event, handlers);
+		}
+		return this;
+	}
+	once(event, handler) {
+		this.on(event, handler);
+		if (isWildcard(event)) this.getOrCreateWildcard(event).onceHandlers.add(handler);
+		else {
+			const onceSet = this.exactOnceListeners.get(event) ?? /* @__PURE__ */ new Set();
+			onceSet.add(handler);
+			this.exactOnceListeners.set(event, onceSet);
+		}
+		return this;
+	}
+	off(event, handler) {
+		if (isWildcard(event)) {
+			const entry = this.wildcardListeners.get(event);
+			if (entry) {
+				entry.handlers.delete(handler);
+				entry.onceHandlers.delete(handler);
+				if (entry.handlers.size === 0) this.wildcardListeners.delete(event);
+			}
+		} else {
+			const handlers = this.exactListeners.get(event);
+			if (handlers) {
+				handlers.delete(handler);
+				this.exactOnceListeners.get(event)?.delete(handler);
+				if (handlers.size === 0) this.exactListeners.delete(event);
+			}
+		}
+		return this;
+	}
+	async emit(event, ...args) {
+		const toRemove = [];
+		const exactHandlers = this.exactListeners.get(event);
+		if (exactHandlers) {
+			const onceSet = this.exactOnceListeners.get(event);
+			await Promise.all([...exactHandlers].map(async (handler) => {
+				await handler(...args);
+				if (onceSet?.has(handler)) toRemove.push(() => this.off(event, handler));
+			}));
+		}
+		for (const [pattern, entry] of this.wildcardListeners) {
+			if (!entry.regex.test(event)) continue;
+			await Promise.all([...entry.handlers].map(async (handler) => {
+				await handler(...args);
+				if (entry.onceHandlers.has(handler)) toRemove.push(() => this.off(pattern, handler));
+			}));
+		}
+		for (const remove of toRemove) remove();
+	}
+	removeAllListeners(event) {
+		if (event) if (isWildcard(event)) this.wildcardListeners.delete(event);
+		else {
+			this.exactListeners.delete(event);
+			this.exactOnceListeners.delete(event);
+		}
+		else {
+			this.exactListeners.clear();
+			this.exactOnceListeners.clear();
+			this.wildcardListeners.clear();
+		}
+		return this;
+	}
+	listenerCount(event) {
+		let count = this.exactListeners.get(event)?.size ?? 0;
+		for (const entry of this.wildcardListeners.values()) if (entry.regex.test(event)) count += entry.handlers.size;
+		return count;
+	}
+	getOrCreateWildcard(pattern) {
+		const existing = this.wildcardListeners.get(pattern);
+		if (existing) return existing;
+		const entry = {
+			regex: compilePattern(pattern),
+			handlers: /* @__PURE__ */ new Set(),
+			onceHandlers: /* @__PURE__ */ new Set()
+		};
+		this.wildcardListeners.set(pattern, entry);
+		return entry;
+	}
+};
+EventEmitter = __decorate([Injectable()], EventEmitter);
+//#endregion
+//#region src/event-emitter/event-emitter.tokens.ts
+const ON_EVENT_METADATA = "vela:on-event";
+//#endregion
+//#region src/event-emitter/event-emitter.subscriber.ts
+let EventEmitterSubscriber = class EventEmitterSubscriber {
+	discovery;
+	emitter;
+	constructor(discovery, emitter) {
+		this.discovery = discovery;
+		this.emitter = emitter;
+	}
+	onApplicationBootstrap() {
+		for (const found of this.discovery.methodsWithMeta(ON_EVENT_METADATA)) {
+			const instance = found.class.instance;
+			if (!instance) continue;
+			const method = instance[found.methodName];
+			if (typeof method === "function") this.emitter.on(found.meta.event, (...args) => method.apply(instance, args));
+		}
+	}
+};
+EventEmitterSubscriber = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(DiscoveryService)),
+	__decorateMetadata("design:paramtypes", [typeof DiscoveryService === "undefined" ? Object : DiscoveryService, typeof EventEmitter === "undefined" ? Object : EventEmitter])
+], EventEmitterSubscriber);
+//#endregion
+//#region src/event-emitter/event-emitter.module.ts
+let EventEmitterModule = class EventEmitterModule {};
+EventEmitterModule = __decorate([Module({
+	lazy: true,
+	providers: [EventEmitter, EventEmitterSubscriber],
+	exports: [EventEmitter]
+})], EventEmitterModule);
+//#endregion
+//#region src/event-emitter/event-emitter.decorators.ts
+function OnEvent(event) {
+	return (target, propertyKey) => {
+		MetadataRegistry.appendCustomClassMeta(target.constructor, ON_EVENT_METADATA, {
+			event,
+			methodName: String(propertyKey)
+		});
+	};
+}
+//#endregion
+//#region src/schedule/schedule.module.ts
+var _ScheduleModule;
+let ScheduleModule = _ScheduleModule = class ScheduleModule {
+	static forRoot() {
+		return { module: _ScheduleModule };
+	}
+};
+ScheduleModule = _ScheduleModule = __decorate([Module({
+	lazy: true,
+	providers: [ScheduleRegistry],
+	exports: [ScheduleRegistry]
+})], ScheduleModule);
+//#endregion
+//#region src/schedule/schedule.decorators.ts
+function Cron(expression) {
+	return (target, propertyKey) => {
+		MetadataRegistry.appendCustomClassMeta(target.constructor, CRON_METADATA, {
+			expression,
+			methodName: String(propertyKey)
+		});
+	};
+}
+function Interval(ms) {
+	return (target, propertyKey) => {
+		MetadataRegistry.appendCustomClassMeta(target.constructor, INTERVAL_METADATA, {
+			ms,
+			methodName: String(propertyKey)
+		});
+	};
+}
+//#endregion
+//#region src/health/health.service.ts
+let HealthCheckService = class HealthCheckService {
+	isShuttingDown = false;
+	beforeApplicationShutdown() {
+		this.isShuttingDown = true;
+	}
+	async check(indicators) {
+		if (this.isShuttingDown) throw new ServiceUnavailableException({
+			status: "shutting_down",
+			info: {},
+			error: {},
+			details: {}
+		});
+		const results = await Promise.allSettled(indicators.map((fn) => fn()));
+		const info = {};
+		const error = {};
+		const details = {};
+		for (const result of results) if (result.status === "fulfilled") {
+			const indicatorResult = result.value;
+			for (const [key, value] of Object.entries(indicatorResult)) {
+				details[key] = value;
+				if (value.status === "up") info[key] = value;
+				else error[key] = value;
+			}
+		} else {
+			const message = result.reason instanceof Error ? result.reason.message : "Health check failed";
+			const key = "unknown";
+			const value = {
+				status: "down",
+				message
+			};
+			details[key] = value;
+			error[key] = value;
+		}
+		const status = Object.keys(error).length > 0 ? "error" : "ok";
+		const checkResult = {
+			status,
+			info,
+			error,
+			details
+		};
+		if (status === "error") throw new ServiceUnavailableException({ ...checkResult });
+		return checkResult;
+	}
+};
+HealthCheckService = __decorate([Injectable()], HealthCheckService);
+//#endregion
+//#region src/health/health.indicator.ts
+let HealthIndicatorService = class HealthIndicatorService {
+	check(key) {
+		return {
+			up(data) {
+				return { [key]: {
+					status: "up",
+					...data
+				} };
+			},
+			down(data) {
+				return { [key]: {
+					status: "down",
+					...data
+				} };
+			}
+		};
+	}
+};
+HealthIndicatorService = __decorate([Injectable()], HealthIndicatorService);
+//#endregion
+//#region src/health/health.http.ts
+let HttpHealthIndicator = class HttpHealthIndicator {
+	indicator;
+	constructor(indicator) {
+		this.indicator = indicator;
+	}
+	async pingCheck(key, url, options) {
+		const { method = "GET", headers, timeout = 5e3, expectedStatus } = options ?? {};
+		try {
+			const response = await fetch(url, {
+				method,
+				headers,
+				signal: AbortSignal.timeout(timeout)
+			});
+			const statusCode = response.status;
+			if (expectedStatus !== void 0 ? statusCode === expectedStatus : statusCode >= 200 && statusCode < 300) return this.indicator.check(key).up({ statusCode });
+			return this.indicator.check(key).down({
+				statusCode,
+				message: response.statusText
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			return this.indicator.check(key).down({ message });
+		}
+	}
+	async responseCheck(key, url, callback, options) {
+		const { method = "GET", headers, timeout = 5e3 } = options ?? {};
+		try {
+			const response = await fetch(url, {
+				method,
+				headers,
+				signal: AbortSignal.timeout(timeout)
+			});
+			const statusCode = response.status;
+			if (await callback(response)) return this.indicator.check(key).up({ statusCode });
+			return this.indicator.check(key).down({ statusCode });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			return this.indicator.check(key).down({ message });
+		}
+	}
+};
+HttpHealthIndicator = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof HealthIndicatorService === "undefined" ? Object : HealthIndicatorService])], HttpHealthIndicator);
+//#endregion
+//#region src/health/health.module.ts
+let HealthModule = class HealthModule {};
+HealthModule = __decorate([Module({
+	providers: [
+		HealthCheckService,
+		HealthIndicatorService,
+		HttpHealthIndicator
+	],
+	exports: [
+		HealthCheckService,
+		HealthIndicatorService,
+		HttpHealthIndicator
+	]
+})], HealthModule);
+//#endregion
+//#region src/throttler/throttler.tokens.ts
+const THROTTLER_OPTIONS = new InjectionToken("THROTTLER_OPTIONS");
+const THROTTLER_STORAGE = new InjectionToken("THROTTLER_STORAGE");
+const THROTTLE_METADATA = "vela:throttle";
+const SKIP_THROTTLE_METADATA = "vela:skip-throttle";
+//#endregion
+//#region src/throttler/throttler.guard.ts
+let ThrottlerGuard = class ThrottlerGuard {
+	options;
+	storage;
+	reflector = new Reflector();
+	constructor(options, storage) {
+		this.options = options;
+		this.storage = storage;
+	}
+	async canActivate(context) {
+		if (this.reflector.getAllAndOverride("vela:skip-throttle", context)) return true;
+		const override = this.reflector.getAllAndOverride(THROTTLE_METADATA, context);
+		const limit = override?.limit ?? this.options.limit;
+		const ttl = override?.ttl ?? this.options.ttl;
+		const request = context.getRequest();
+		const tracker = this.options.getTracker ? this.options.getTracker(request) : request.headers.get("x-forwarded-for") ?? "anonymous";
+		const className = context.getClass().name;
+		const handlerName = String(context.getHandler());
+		const key = this.options.generateKey ? this.options.generateKey(tracker, {
+			className,
+			handlerName
+		}) : `throttler:${className}:${handlerName}:${tracker}`;
+		const { count, ttlMs } = await this.storage.increment(key, ttl);
+		const remaining = Math.max(0, limit - count);
+		const resetSeconds = Math.ceil(ttlMs / 1e3);
+		const honoContext = context.getContext();
+		honoContext.header("X-RateLimit-Limit", String(limit));
+		honoContext.header("X-RateLimit-Remaining", String(remaining));
+		honoContext.header("X-RateLimit-Reset", String(resetSeconds));
+		const rateLimitInfo = {
+			limit,
+			remaining,
+			reset: resetSeconds
+		};
+		honoContext.set("rateLimit", rateLimitInfo);
+		if (count > limit) {
+			honoContext.header("Retry-After", String(resetSeconds));
+			throw new TooManyRequestsException();
+		}
+		return true;
+	}
+};
+ThrottlerGuard = __decorate([
+	Injectable(),
+	__decorateParam(0, Inject(THROTTLER_OPTIONS)),
+	__decorateParam(1, Inject(THROTTLER_STORAGE)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], ThrottlerGuard);
+//#endregion
+//#region src/throttler/throttler.storage.ts
+let ThrottlerStorage = class ThrottlerStorage {
+	current = /* @__PURE__ */ new Map();
+	previous = /* @__PURE__ */ new Map();
+	lastSwap = Date.now();
+	swapIntervalMs = 6e4;
+	increment(key, ttlMs) {
+		this.maybeSwap();
+		const now = Date.now();
+		let entry = this.current.get(key) ?? this.previous.get(key);
+		if (!entry || now >= entry.resetTime) entry = {
+			count: 0,
+			resetTime: now + ttlMs
+		};
+		entry.count++;
+		this.current.set(key, entry);
+		return {
+			count: entry.count,
+			ttlMs: entry.resetTime - now
+		};
+	}
+	reset(key) {
+		this.current.delete(key);
+		this.previous.delete(key);
+	}
+	maybeSwap() {
+		const now = Date.now();
+		if (now - this.lastSwap < this.swapIntervalMs) return;
+		this.previous = this.current;
+		this.current = /* @__PURE__ */ new Map();
+		this.lastSwap = now;
+	}
+};
+ThrottlerStorage = __decorate([Injectable()], ThrottlerStorage);
+//#endregion
+//#region src/throttler/throttler.module.ts
+const { ConfigurableModuleClass: ConfigurableModuleClass$1, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder({
+	moduleName: "Throttler",
+	optionsInjectionToken: THROTTLER_OPTIONS
+}).build();
+let ThrottlerModule = class ThrottlerModule extends ConfigurableModuleClass$1 {};
+ThrottlerModule = __decorate([Module({
+	providers: [
+		{
+			provide: THROTTLER_STORAGE,
+			useFactory: (options) => options.storage ?? new ThrottlerStorage(),
+			inject: [MODULE_OPTIONS_TOKEN]
+		},
+		ThrottlerGuard,
+		{
+			provide: APP_GUARD,
+			useExisting: ThrottlerGuard
+		}
+	],
+	exports: [
+		THROTTLER_OPTIONS,
+		THROTTLER_STORAGE,
+		ThrottlerGuard
+	]
+})], ThrottlerModule);
+//#endregion
+//#region src/throttler/throttler.decorators.ts
+const Throttle = (config) => SetMetadata(THROTTLE_METADATA, config);
+const SkipThrottle = () => SetMetadata(SKIP_THROTTLE_METADATA, true);
+//#endregion
+//#region src/entrypoint/execution-scope.ts
+/**
+* Run one unit of non-HTTP work (a queue batch, a scheduled tick, an RPC
+* call) inside a fresh request-scoped child container — the non-HTTP
+* equivalent of the per-request child the HTTP pipeline creates:
+*
+* ```ts
+* await runInEntrypointScope(app.getContainer(), async (scope) => {
+*   const consumer = scope.resolve(ep.token);
+*   await consumer.process(batch);
+* });
+* ```
+*
+* Request-scoped providers (and singletons bubbled to request scope) resolve
+* per invocation instead of leaking one boot-time instance across every
+* dispatch; the child's request-scoped disposables are disposed (LIFO) when
+* `fn` settles — success or failure. `REQUEST_CONTEXT` is deliberately NOT
+* seeded: it is an HTTP primitive, and resolving it here keeps throwing its
+* explicit misuse error.
+*/
+async function runInEntrypointScope(container, fn) {
+	const scope = container.createChild();
+	try {
+		return await fn(scope);
+	} finally {
+		if (scope.hasDisposables()) await scope.dispose();
+	}
+}
+//#endregion
+//#region src/entrypoint/execution-context.ts
+const WRONG_TRANSPORT = (accessor, kind) => () => {
+	throw new Error(`${accessor} called on a '${kind}' entrypoint ExecutionContext — this handler runs over an entrypoint dispatch, not that transport. Use getType()/getPayload() to branch.`);
+};
+/**
+* Entrypoint sibling of `buildExecutionContext` (HTTP) and
+* `buildWsExecutionContext`: lets guards/interceptors/filters written against
+* `getClass()`/`getHandler()`/`getType()` run unchanged around queue batches,
+* scheduled ticks, and any custom entrypoint kind. Transport-specific
+* accessors throw rather than fabricate fakes.
+*/
+function buildEntrypointExecutionContext(kind, targetClass, handlerName, payload) {
+	return {
+		getType: () => kind,
+		getClass: () => targetClass,
+		getHandler: () => handlerName,
+		getPayload: () => payload,
+		getContext: WRONG_TRANSPORT("getContext()", kind),
+		getRequest: WRONG_TRANSPORT("getRequest()", kind),
+		switchToHttp: WRONG_TRANSPORT("switchToHttp()", kind),
+		switchToWs: WRONG_TRANSPORT("switchToWs()", kind)
+	};
+}
+//#endregion
+//#region src/pipeline/scoped-components.ts
+const RESOLVERS = {
+	guard: ComponentManager.resolveGuards.bind(ComponentManager),
+	pipe: ComponentManager.resolvePipes.bind(ComponentManager),
+	interceptor: ComponentManager.resolveInterceptors.bind(ComponentManager),
+	filter: ComponentManager.resolveFilters.bind(ComponentManager),
+	middleware: ComponentManager.resolveMiddleware.bind(ComponentManager)
+};
+/**
+* Public seam for custom dispatchers: the `@UseGuards`/`@UsePipes`/
+* `@UseInterceptors`/`@UseFilters` components scoped to a handler (class-level
+* then method-level, declaration order), resolved to instances through the
+* given container (classes constructed with DI; instances passed through).
+*
+* Order is preserved exactly as declared — conventions stay with the CALLER:
+* filters run closest-first, so dispatchers reverse them
+* (`resolveScopedComponents('filter', ...).reverse()`), and app-wide `APP_*`
+* components are a separate, transport-specific decision.
+*
+* Promoted to the public API by the QueueModule work (the "openness proof"):
+* it was the one capability custom entrypoint dispatchers needed that only
+* the internal `ComponentManager` provided.
+*/
+function resolveScopedComponents(type, targetClass, methodName, container) {
+	const scoped = ComponentManager.getScopedComponents(type, targetClass, methodName);
+	const resolve = RESOLVERS[type];
+	return resolve(scoped, container);
+}
+//#endregion
+//#region src/pipeline/pipes.ts
+var ParseIntPipe = class {
+	transform(value, metadata) {
+		const parsed = parseInt(value, 10);
+		if (isNaN(parsed)) throw new BadRequestException(`Validation failed (numeric string expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+		return parsed;
+	}
+};
+var ParseFloatPipe = class {
+	transform(value, metadata) {
+		const parsed = parseFloat(value);
+		if (isNaN(parsed)) throw new BadRequestException(`Validation failed (float string expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+		return parsed;
+	}
+};
+var ParseBoolPipe = class {
+	transform(value, metadata) {
+		if (value === "true") return true;
+		if (value === "false") return false;
+		throw new BadRequestException(`Validation failed (boolean string expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+	}
+};
+var DefaultValuePipe = class {
+	defaultValue;
+	constructor(defaultValue) {
+		this.defaultValue = defaultValue;
+	}
+	transform(value, _metadata) {
+		return value !== void 0 && value !== null ? value : this.defaultValue;
+	}
+};
+var RequiredPipe = class {
+	transform(value, metadata) {
+		if (value === void 0 || value === null || value === "") throw new BadRequestException(`Validation failed (value required)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+		return value;
+	}
+};
+var ZodValidationPipe = class {
+	schema;
+	constructor(schema) {
+		this.schema = schema;
+	}
+	transform(value, _metadata) {
+		return this.schema.parse(value);
+	}
+};
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_VERSION_REGEX = {
+	"3": /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	"4": /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	"5": /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+};
+var ParseUUIDPipe = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	transform(value, metadata) {
+		if (!(this.options?.version ? UUID_VERSION_REGEX[this.options.version] : UUID_REGEX).test(value)) throw new BadRequestException(`Validation failed (uuid${this.options?.version ? ` v${this.options.version}` : ""} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+		return value;
+	}
+};
+var ParseEnumPipe = class {
+	allowedValues;
+	valuesLabel;
+	constructor(enumType) {
+		const values = Object.values(enumType);
+		this.allowedValues = new Set(values);
+		this.valuesLabel = values.join(", ");
+	}
+	transform(value, metadata) {
+		if (!this.allowedValues.has(value)) throw new BadRequestException(`Validation failed (${this.valuesLabel} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+		return value;
+	}
+};
+var ParseArrayPipe = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	transform(value, metadata) {
+		if (value === void 0 || value === null || value === "") {
+			if (this.options?.optional) return [];
+			throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+		}
+		if (Array.isArray(value)) return value;
+		if (typeof value === "string") {
+			const sep = this.options?.separator ?? ",";
+			return value.split(sep).map((v) => v.trim()).filter((v) => v.length > 0);
+		}
+		throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ""}`);
+	}
+};
+//#endregion
+//#region src/exceptions/errors.module.ts
+/** Lower a `handler` option to an {@link APP_EXCEPTION_HANDLER} provider. */
+const handlerProvider = (handler) => typeof handler === "function" ? {
+	provide: APP_EXCEPTION_HANDLER,
+	useClass: handler
+} : {
+	provide: APP_EXCEPTION_HANDLER,
+	useValue: handler
+};
+const { ConfigurableModuleClass } = defineModule({
+	name: "Errors",
+	setup: ({ options }) => {
+		const providers = [{
+			provide: ERROR_CATALOG,
+			useValue: composeCatalogs(CORE_CATALOG, ...options.catalogs ?? [])
+		}];
+		const exports = [ERROR_CATALOG];
+		if (options.handler) {
+			providers.push(handlerProvider(options.handler));
+			exports.push(APP_EXCEPTION_HANDLER);
+		}
+		return {
+			providers,
+			exports
+		};
+	}
+});
+/**
+* Registers the application-wide error surface: the composed
+* {@link ERROR_CATALOG} that every transport edge redacts against, and an
+* optional {@link APP_EXCEPTION_HANDLER}. The imperative sibling is
+* `app.useGlobalExceptionHandler(handler)`.
+*
+* ```ts
+* @Module({
+*   imports: [ErrorsModule.forRoot({ catalogs: [ordersCatalog], handler: SentryHandler })],
+* })
+* class AppModule {}
+* ```
+*/
+var ErrorsModule = class extends ConfigurableModuleClass {};
+//#endregion
+//#region src/validation/create-zod-dto.ts
+function createZodDto(schema, options = {}) {
+	const className = options.name ?? "ZodDto";
+	return { [className]: class {
+		static schema = schema;
+		constructor(initial) {
+			if (initial && typeof initial === "object") Object.assign(this, initial);
+		}
+	} }[className];
+}
+//#endregion
+//#region src/validation/validation.pipe.ts
+var ValidationPipe = class {
+	transform(value, metadata) {
+		const metatype = metadata.metatype;
+		if (!metatype?.schema?.parse) return value;
+		try {
+			return metatype.schema.parse(value);
+		} catch (error) {
+			if (error && typeof error === "object" && "issues" in error && Array.isArray(error.issues)) throw new BadRequestException({
+				statusCode: 400,
+				message: "Validation failed",
+				errors: error.issues
+			});
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region src/serialization/serialize.decorator.ts
+const SERIALIZE_METADATA = "vela:serialize";
+function Serialize(dto) {
+	return (target, propertyKey) => {
+		MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, SERIALIZE_METADATA, dto);
+	};
+}
+//#endregion
+//#region src/serialization/serializer.interceptor.ts
+var SerializerInterceptor = class {
+	async intercept(context, next) {
+		const result = await next.handle();
+		const controller = context.getClass();
+		const handler = context.getHandler();
+		const schema = MetadataRegistry.getCustomHandlerMeta(controller, handler, SERIALIZE_METADATA)?.schema;
+		if (!schema?.parse) return result;
+		if (Array.isArray(result)) return result.map((item) => schema.parse(item));
+		return schema.parse(result);
+	}
+};
+//#endregion
+export { CacheTTL as $, ThrottlerStorage as A, zodToJsonSchema as At, Cron as B, ZodValidationPipe as C, getRequestContainer as Ct, SkipThrottle as D, createLazyParamDecorator as Dt, runInEntrypointScope as E, getCurrentRequestContext as Et, THROTTLE_METADATA as F, EventEmitterSubscriber as G, ScheduleModule as H, HealthModule as I, lazyProvider as J, ON_EVENT_METADATA as K, HttpHealthIndicator as L, SKIP_THROTTLE_METADATA as M, ApiResponse as Mt, THROTTLER_OPTIONS as N, ApiTags as Nt, Throttle as O, mixin as Ot, THROTTLER_STORAGE as P, VelaFactory as Pt, CacheKey as Q, HealthIndicatorService as R, RequiredPipe as S, Logger as St, buildEntrypointExecutionContext as T, getCurrentContainer as Tt, OnEvent as U, Interval as V, EventEmitterModule as W, provideGlobal as X, moduleToken as Y, sideEffectModule as Z, ParseBoolPipe as _, registerAs as _t, env as a, CACHE_KEY_METADATA as at, ParseIntPipe as b, ConfigStore as bt, toErrorBody$1 as c, CACHE_TTL_METADATA as ct, Serialize as d, CorsModule as dt, TieredCacheStore as et, ValidationPipe as f, CORS_OPTIONS as ft, ParseArrayPipe as g, HttpService as gt, DefaultValuePipe as h, HttpRequestException as ht, defineErrorCatalog as i, CacheInterceptor as it, ThrottlerGuard as j, ApiDoc as jt, ThrottlerModule as k, createOpenApiDocument as kt, SerializerInterceptor as l, Reflector as lt, ErrorsModule as m, HTTP_MODULE_OPTIONS as mt, VelaError as n, MemoryCacheStore as nt, getRuntimeKey as o, CACHE_MANAGER as ot, createZodDto as p, HttpModule as pt, EventEmitter as q, composeCatalogs$1 as r, CacheService as rt, isVelaError$1 as s, CACHE_MODULE_OPTIONS as st, CORE_CATALOG$1 as t, CacheModule as tt, SERIALIZE_METADATA as u, SetMetadata as ut, ParseEnumPipe as v, ConfigModule as vt, resolveScopedComponents as w, enableAmbientContainer as wt, ParseUUIDPipe as x, LogLevel as xt, ParseFloatPipe as y, ConfigService as yt, HealthCheckService as z };
+
+//# sourceMappingURL=src-eb5CI6Xn.js.map