@velajs/vela 1.19.0 → 1.19.1

package/dist/route.manager-DRAZ5X04.js

@@ -0,0 +1,991 @@
+import { c as getInjectMetadata, d as HttpMethod, k as MetadataRegistry, m as Scope, p as ParamType, s as getConstructorDependencies } from "./decorate-GcSMAbKn.js";
+import { n as resolveErrorReporter, s as ForbiddenException, u as HttpException } from "./discovery.service-BYm95SSD.js";
+import { n as createRequestContext, t as REQUEST_CONTEXT } from "./request-context-C3nCGJNd.js";
+import { STATUS_TO_CODE, toErrorBody } from "@velajs/errors";
+import { Hono } from "hono";
+import { contextStorage } from "hono/context-storage";
+import { getCookie } from "hono/cookie";
+//#region src/metadata.ts
+function defineMetadata(key, value, target, propertyKey) {
+	MetadataRegistry.setReflectMetadata(target, key, value, propertyKey);
+}
+function getMetadata(key, target, propertyKey) {
+	return MetadataRegistry.getReflectMetadata(target, key, propertyKey);
+}
+if (typeof Reflect.defineMetadata !== "function") {
+	Reflect.defineMetadata = defineMetadata;
+	Reflect.getMetadata = getMetadata;
+	Reflect.getOwnMetadata = getMetadata;
+	Reflect.metadata = (key, value) => {
+		return (target, propertyKey) => {
+			defineMetadata(key, value, target, propertyKey);
+		};
+	};
+}
+//#endregion
+//#region src/registry/paths.ts
+function normalizePath(path) {
+	if (!path) return path;
+	return path.startsWith("/") ? path : `/${path}`;
+}
+function joinPaths(prefix, path) {
+	return `${prefix.endsWith("/") ? prefix.slice(0, -1) : prefix}${path && !path.startsWith("/") ? `/${path}` : path}` || "/";
+}
+function toOpenApiPath(path) {
+	return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}");
+}
+//#endregion
+//#region src/http/instantiate.ts
+function instantiate(classOrInstance, container) {
+	if (typeof classOrInstance === "function") {
+		const clazz = classOrInstance;
+		if (container.has(clazz)) return container.resolve(clazz);
+		if (constructorExpectsDependencies(clazz)) throw new Error(`Cannot instantiate ${clazz.name}: the class declares constructor dependencies (\`@Inject(...)\` parameters or typed constructor parameters), but no matching provider is registered in the container. Add it to a module's providers (and export it if used outside its declaring module) instead of relying on the bare \`new\` fallback, which would construct the class without honouring its dependency-injection metadata and leave every injected field \`undefined\`.`);
+		return new clazz();
+	}
+	if (container.has(classOrInstance)) return container.resolve(classOrInstance);
+	return classOrInstance;
+}
+function constructorExpectsDependencies(clazz) {
+	if (getInjectMetadata(clazz).length > 0) return true;
+	return getConstructorDependencies(clazz).length > 0;
+}
+function instantiateMany(items, container) {
+	return items.map((item) => instantiate(item, container));
+}
+//#endregion
+//#region src/http/argument-resolver.ts
+const PARAM_EXTRACTORS = /* @__PURE__ */ new Map([
+	[ParamType.PARAM, (c, p) => p.name ? c.req.param(p.name) : c.req.param()],
+	[ParamType.QUERY, (c, p) => p.name ? c.req.query(p.name) : c.req.query()],
+	[ParamType.BODY, async (c, p) => {
+		let body;
+		try {
+			body = await c.req.json();
+		} catch {
+			return;
+		}
+		return p.name && body !== null && typeof body === "object" ? body[p.name] : body;
+	}],
+	[ParamType.HEADERS, (c, p) => p.name ? c.req.header(p.name) : c.req.header()],
+	[ParamType.REQUEST, (c) => c],
+	[ParamType.RESPONSE, (c) => c],
+	[ParamType.COOKIE, (c, p) => p.name ? getCookie(c, p.name) : getCookie(c)],
+	[ParamType.RAW_BODY, async (c) => new Uint8Array(await c.req.arrayBuffer())]
+]);
+var ArgumentResolver = class {
+	ipExtractor;
+	constructor(ipExtractor) {
+		this.ipExtractor = ipExtractor;
+	}
+	async extract(c, paramMetadata, pipes, requestContainer, paramTypes) {
+		if (paramMetadata.length === 0) return [c];
+		const maxIndex = paramMetadata.at(-1).index;
+		const args = new Array(maxIndex + 1).fill(void 0);
+		for (const param of paramMetadata) {
+			let value = await this.extractParam(c, param);
+			const metadata = {
+				type: param.type,
+				data: param.name,
+				metatype: param.metatype ?? paramTypes?.[param.index]
+			};
+			for (const pipe of pipes) value = await pipe.transform(value, metadata);
+			if (param.pipes && param.pipes.length > 0) for (const paramPipe of param.pipes) value = await instantiate(paramPipe, requestContainer).transform(value, metadata);
+			args[param.index] = value;
+		}
+		return args;
+	}
+	extractParam(c, param) {
+		if (param.type === ParamType.IP) return this.ipExtractor(c);
+		const extractor = PARAM_EXTRACTORS.get(param.type);
+		if (extractor) return extractor(c, param);
+		return param.factory ? param.factory(param.name, c) : void 0;
+	}
+};
+//#endregion
+//#region src/http/route-contributor.ts
+const STORE_KEY = Symbol.for("vela:route-contributors:v1");
+function store() {
+	const g = globalThis;
+	return g[STORE_KEY] ??= /* @__PURE__ */ new Map();
+}
+/** Register a contributor. Last registration per `id` wins. */
+function registerRouteContributor(contributor) {
+	store().set(contributor.id, contributor);
+}
+/** All registered contributors (registration order). */
+function getRouteContributors() {
+	return [...store().values()];
+}
+//#endregion
+//#region src/http/execution-context.ts
+function buildExecutionContext(c, controller, handlerName) {
+	return {
+		getType: () => "http",
+		getClass: () => controller,
+		getHandler: () => handlerName,
+		getContext: () => c,
+		getRequest: () => c.req.raw,
+		switchToHttp: () => ({
+			getRequest: () => c.req.raw,
+			getResponse: () => c
+		}),
+		switchToWs: () => {
+			throw new Error("switchToWs() called on an HTTP ExecutionContext. This handler runs over HTTP, not a WebSocket gateway.");
+		}
+	};
+}
+var VelaMiddlewareHost = class {};
+const VELA_MIDDLEWARE_HANDLER = Symbol.for("vela.middleware");
+function buildMiddlewareExecutionContext(c) {
+	return buildExecutionContext(c, VelaMiddlewareHost, VELA_MIDDLEWARE_HANDLER);
+}
+//#endregion
+//#region src/pipeline/pipeline-runner.ts
+/**
+* The transport-agnostic guard → pipe → interceptor execution core shared by
+* the HTTP `HandlerExecutor` and the WebSocket `WsDispatcher` (and any future
+* entrypoint dispatcher: queue consumers, scheduled jobs, …). Exception
+* FILTERS stay with the caller — their terminal behavior is transport-specific
+* (HTTP maps to a Response, WS sends an error frame).
+*/
+var PipelineRunner = class PipelineRunner {
+	static async run(options) {
+		let args;
+		if (options.argsBeforeGuards) args = await options.resolveArgs();
+		for (const guard of options.guards) if (!await guard.canActivate(options.context)) throw options.onGuardReject?.() ?? new ForbiddenException();
+		args ??= await options.resolveArgs();
+		const resolvedArgs = args;
+		return PipelineRunner.chainInterceptors(options.interceptors, options.context, () => options.invoke(resolvedArgs));
+	}
+	/** Interceptor onion — innermost is the core handler. */
+	static async chainInterceptors(interceptors, context, coreHandler) {
+		if (interceptors.length === 0) return coreHandler();
+		let next = { handle: coreHandler };
+		for (let i = interceptors.length - 1; i >= 0; i--) {
+			const interceptor = interceptors[i];
+			const currentNext = next;
+			next = { handle: () => interceptor.intercept(context, currentNext) };
+		}
+		return next.handle();
+	}
+};
+//#endregion
+//#region src/pipeline/component.manager.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Component registration + resolution for the controller/handler tiers.
+* App-wide (global) components have exactly ONE source: the per-app
+* `RouteManager` (`APP_*` provider tokens + `useGlobalX()`) — callers merge
+* `routeManager.getGlobalComponents()` with {@link getScopedComponents}.
+*
+* Stateless by design: no process-global container (two apps in one process
+* never cross-talk) — every `resolve*` takes the resolving container.
+*/
+var ComponentManager = class {
+	static registerController(type, controller, ...components) {
+		for (const component of components) MetadataRegistry.registerController(type, controller, component);
+	}
+	static registerHandler(type, controller, handlerName, ...components) {
+		for (const component of components) MetadataRegistry.registerHandler(type, controller, handlerName, component);
+	}
+	static getScopedComponents(type, controller, handlerName) {
+		return [...MetadataRegistry.getController(type, controller), ...MetadataRegistry.getHandler(type, controller, handlerName)];
+	}
+	static resolveAll(items, methodKey, container) {
+		return items.map((item) => isObject(item) && methodKey in item ? item : container.resolve(item));
+	}
+	static resolveMiddleware(items, container) {
+		return this.resolveAll(items, "use", container);
+	}
+	static resolveGuards(items, container) {
+		return this.resolveAll(items, "canActivate", container);
+	}
+	static resolvePipes(items, container) {
+		return this.resolveAll(items, "transform", container);
+	}
+	static resolveInterceptors(items, container) {
+		return this.resolveAll(items, "intercept", container);
+	}
+	static resolveFilters(items, container) {
+		return this.resolveAll(items, "catch", container);
+	}
+	static async executePipes(value, metadata, pipes) {
+		let transformed = value;
+		for (const pipe of pipes) transformed = await pipe.transform(transformed, metadata);
+		return transformed;
+	}
+	static async runInterceptorChain(interceptors, context, coreHandler) {
+		return PipelineRunner.chainInterceptors(interceptors, context, coreHandler);
+	}
+};
+//#endregion
+//#region src/pipeline/decorators.ts
+function UseComponent(type, ...components) {
+	return (target, propertyKey) => {
+		if (propertyKey !== void 0) ComponentManager.registerHandler(type, target.constructor, propertyKey, ...components);
+		else ComponentManager.registerController(type, target, ...components);
+	};
+}
+function UseMiddleware(...middleware) {
+	return UseComponent("middleware", ...middleware);
+}
+function UseGuards(...guards) {
+	return UseComponent("guard", ...guards);
+}
+function UsePipes(...pipes) {
+	return UseComponent("pipe", ...pipes);
+}
+function UseInterceptors(...interceptors) {
+	return UseComponent("interceptor", ...interceptors);
+}
+function UseFilters(...filters) {
+	return UseComponent("filter", ...filters);
+}
+function Catch(...exceptions) {
+	return (target) => {
+		MetadataRegistry.setCatchTypes(target, exceptions);
+	};
+}
+function getCatchTypes(filter) {
+	const filterClass = typeof filter === "function" ? filter : filter.constructor;
+	return MetadataRegistry.getCatchTypes(filterClass) ?? [];
+}
+function shouldFilterCatch(filter, exception) {
+	const catchTypes = getCatchTypes(filter);
+	if (catchTypes.length === 0) return true;
+	return catchTypes.some((type) => exception instanceof type);
+}
+//#endregion
+//#region src/http/decorators.ts
+/**
+* Marks a class as a controller.
+* Accepts a path string or an options object with `path` and `version`.
+*
+* @example
+* ```ts
+* @Controller('/users')
+* @Controller({ path: '/users', version: 1 })
+* @Controller({ path: '/users', version: [1, 2] })
+* ```
+*/
+function Controller(pathOrOptions) {
+	return (target) => {
+		const ctor = target;
+		const path = typeof pathOrOptions === "string" ? pathOrOptions : pathOrOptions?.path ?? "";
+		const version = typeof pathOrOptions === "object" ? pathOrOptions?.version : void 0;
+		MetadataRegistry.setControllerPath(ctor, normalizePath(path));
+		if (version !== void 0) MetadataRegistry.setControllerOptions(ctor, { version });
+		MetadataRegistry.markInjectable(ctor);
+		MetadataRegistry.setScope(ctor, Scope.SINGLETON);
+	};
+}
+/**
+* Override the version for a specific route method.
+*
+* @example
+* ```ts
+* @Controller({ prefix: '/users', version: 1 })
+* class UserController {
+*   @Get()
+*   listV1() { ... }          // GET /v1/users
+*
+*   @Version(2)
+*   @Get()
+*   listV2() { ... }          // GET /v2/users
+* }
+* ```
+*/
+function Version(version) {
+	return (target, propertyKey, _descriptor) => {
+		const ctor = target.constructor;
+		MetadataRegistry.setRouteVersion(ctor, propertyKey, version);
+		const route = MetadataRegistry.getRoutes(ctor).find((r) => r.handlerName === propertyKey);
+		if (route) route.version = version;
+	};
+}
+function createMethodDecorator(method) {
+	return (path = "", options) => {
+		return (target, propertyKey, _descriptor) => {
+			const ctor = target.constructor;
+			const normalizedPath = normalizePath(path);
+			const version = MetadataRegistry.getRouteVersion(ctor, propertyKey);
+			MetadataRegistry.addRoute(ctor, {
+				method,
+				path: normalizedPath,
+				handlerName: propertyKey,
+				...version !== void 0 ? { version } : {},
+				...options?.name !== void 0 ? { name: options.name } : {}
+			});
+		};
+	};
+}
+const Get = createMethodDecorator(HttpMethod.GET);
+const Post = createMethodDecorator(HttpMethod.POST);
+const Put = createMethodDecorator(HttpMethod.PUT);
+const Patch = createMethodDecorator(HttpMethod.PATCH);
+const Delete = createMethodDecorator(HttpMethod.DELETE);
+const Options = createMethodDecorator(HttpMethod.OPTIONS);
+const Head = createMethodDecorator(HttpMethod.HEAD);
+const All = createMethodDecorator(HttpMethod.ALL);
+const Sse = createMethodDecorator(HttpMethod.GET);
+const CUSTOM_PARAM_TYPE = "custom";
+function createBuiltinParamDecorator(type) {
+	return (nameOrPipe, ...pipes) => {
+		return (target, propertyKey, parameterIndex) => {
+			if (propertyKey === void 0) throw new Error("Parameter decorators can only be used on method parameters");
+			let name;
+			let allPipes;
+			if (typeof nameOrPipe === "string") {
+				name = nameOrPipe;
+				allPipes = pipes;
+			} else if (nameOrPipe !== void 0) {
+				name = void 0;
+				allPipes = [nameOrPipe, ...pipes];
+			} else {
+				name = void 0;
+				allPipes = pipes;
+			}
+			MetadataRegistry.addParameter(target.constructor, propertyKey, {
+				index: parameterIndex,
+				type,
+				name,
+				...allPipes.length > 0 ? { pipes: allPipes } : {}
+			});
+		};
+	};
+}
+const Param = createBuiltinParamDecorator(ParamType.PARAM);
+const Query = createBuiltinParamDecorator(ParamType.QUERY);
+const Body = createBuiltinParamDecorator(ParamType.BODY);
+const Headers = createBuiltinParamDecorator(ParamType.HEADERS);
+const Req = createBuiltinParamDecorator(ParamType.REQUEST);
+/**
+* Injects the Hono `Context` as the response handle.
+* In Hono, request and response state are unified in the `Context` object,
+* so `@Res()` and `@Req()` both return it.
+*
+* Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
+*
+* @example
+* ```ts
+* @Get('/set-cookie')
+* handle(@Res() c: Context) {
+*   c.setCookie('session', 'abc123', { httpOnly: true });
+*   return { ok: true };
+* }
+* ```
+*/
+const Res = createBuiltinParamDecorator(ParamType.RESPONSE);
+const Ip = createBuiltinParamDecorator(ParamType.IP);
+const Cookie = createBuiltinParamDecorator(ParamType.COOKIE);
+/**
+* Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
+*
+* - `@Cookie()` — all cookies as an object
+* - `@Cookie('token')` — the value of the `token` cookie
+*
+* @example
+* ```ts
+* @Get('/me')
+* handle(@Cookie('session') session: string) { ... }
+* ```
+*/
+const Cookies = Cookie;
+/**
+* Injects the raw request body as a `Uint8Array`.
+* Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
+* need the raw bytes before any JSON parsing.
+*
+* @example
+* ```ts
+* @Post('/webhook')
+* async handle(@RawBody() body: Uint8Array) {
+*   const sig = new TextDecoder().decode(body);
+*   // verify HMAC...
+* }
+* ```
+*/
+function RawBody() {
+	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: ParamType.RAW_BODY
+		});
+	};
+}
+/**
+* Factory for creating custom parameter decorators.
+*
+* @example
+* ```ts
+* const CurrentUser = createParamDecorator(
+*   (data: unknown, ctx: ExecutionContext) => {
+*     const req = ctx.getRequest();
+*     return req.headers.get('x-user-id');
+*   }
+* );
+*
+* // Usage:
+* @Get()
+* handle(@CurrentUser() userId: string) { ... }
+*
+* // With data argument:
+* const Header = createParamDecorator(
+*   (data: string, ctx: ExecutionContext) => {
+*     return ctx.getRequest().headers.get(data);
+*   }
+* );
+*
+* @Get()
+* handle(@Header('x-request-id') requestId: string) { ... }
+* ```
+*/
+function createParamDecorator(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) => {
+					return factory(data, buildExecutionContext(ctx, target.constructor, propertyKey));
+				},
+				...pipes.length > 0 ? { pipes } : {}
+			});
+		};
+	};
+}
+/**
+* Override the HTTP status code for a handler's response.
+*
+* @example
+* ```ts
+* @Post()
+* @HttpCode(201)
+* create(@Body() data: CreateDto) { return data; }
+* ```
+*/
+function HttpCode(statusCode) {
+	return (target, propertyKey, _descriptor) => {
+		MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, { httpCode: statusCode });
+	};
+}
+/**
+* Set a response header declaratively.
+* Can be applied multiple times to set multiple headers.
+*
+* @example
+* ```ts
+* @Get()
+* @Header('Cache-Control', 'no-cache')
+* @Header('X-Custom', 'value')
+* handle() { return { ok: true }; }
+* ```
+*/
+function Header(name, value) {
+	return (target, propertyKey, _descriptor) => {
+		MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, { responseHeaders: [[name, value]] });
+	};
+}
+/**
+* Redirect to another URL. The handler's return value can override the URL.
+*
+* @example
+* ```ts
+* @Get('/old')
+* @Redirect('/new', 301)
+* handleOld() {}
+*
+* // Dynamic redirect — return { url, statusCode? } to override
+* @Get('/go')
+* @Redirect('/default')
+* handleGo(@Query('to') to?: string) {
+*   if (to) return { url: to };
+* }
+* ```
+*/
+function Redirect(url, statusCode = 302) {
+	return (target, propertyKey, _descriptor) => {
+		MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, { redirect: {
+			url,
+			statusCode
+		} });
+	};
+}
+function getHttpCode(target, method) {
+	return MetadataRegistry.getHandlerHttpMeta(target, method)?.httpCode;
+}
+function getResponseHeaders(target, method) {
+	return MetadataRegistry.getHandlerHttpMeta(target, method)?.responseHeaders ?? [];
+}
+function getRedirect(target, method) {
+	return MetadataRegistry.getHandlerHttpMeta(target, method)?.redirect;
+}
+function applyDecorators(...decorators) {
+	return ((target, propertyKey, descriptor) => {
+		for (const decorator of decorators) if (propertyKey === void 0 && typeof descriptor !== "number") decorator(target);
+		else if (typeof descriptor === "number") decorator(target, propertyKey, descriptor);
+		else decorator(target, propertyKey, descriptor);
+	});
+}
+//#endregion
+//#region src/http/response-mapper.ts
+function parseRedirectResult(result) {
+	if (typeof result !== "object" || result === null) return void 0;
+	if (!("url" in result)) return void 0;
+	const obj = result;
+	if (typeof obj.url !== "string") return void 0;
+	return {
+		url: obj.url,
+		...typeof obj.statusCode === "number" ? { statusCode: obj.statusCode } : {}
+	};
+}
+function mapResponse(c, result, statusCode) {
+	if (result instanceof Response) return result;
+	if (result === null || result === void 0) return c.body(null, statusCode ?? 204);
+	if (typeof result === "string") return c.text(result, statusCode ?? 200);
+	return c.json(result, statusCode ?? 200);
+}
+function mapRedirect(c, result, redirect) {
+	const overrides = parseRedirectResult(result);
+	const finalUrl = overrides?.url ?? redirect.url;
+	const finalStatus = overrides?.statusCode ?? redirect.statusCode;
+	return c.redirect(finalUrl, finalStatus);
+}
+function applyResponseHeaders(response, headers) {
+	for (const [name, value] of headers) response.headers.set(name, value);
+}
+//#endregion
+//#region src/http/handler-executor.ts
+var HandlerExecutor = class {
+	argumentResolver;
+	getGlobals;
+	getRequestContainer;
+	constructor(argumentResolver, getGlobals, getRequestContainer) {
+		this.argumentResolver = argumentResolver;
+		this.getGlobals = getGlobals;
+		this.getRequestContainer = getRequestContainer;
+	}
+	create(route, controller, allParamMetadata) {
+		const paramMetadata = (allParamMetadata.get(route.handlerName) || []).sort((a, b) => a.index - b.index);
+		const paramTypes = Reflect.getMetadata("design:paramtypes", controller.prototype, route.handlerName);
+		const methodGuards = ComponentManager.getScopedComponents("guard", controller, route.handlerName);
+		const methodPipes = ComponentManager.getScopedComponents("pipe", controller, route.handlerName);
+		const methodInterceptors = ComponentManager.getScopedComponents("interceptor", controller, route.handlerName);
+		const methodFilters = [...ComponentManager.getScopedComponents("filter", controller, route.handlerName)].reverse();
+		const httpCode = getHttpCode(controller, route.handlerName);
+		const responseHeaders = getResponseHeaders(controller, route.handlerName);
+		const redirect = getRedirect(controller, route.handlerName);
+		return async (c) => {
+			const requestContainer = this.getRequestContainer(c);
+			const globals = this.getGlobals();
+			const guards = [...instantiateMany(globals.guards, requestContainer), ...instantiateMany(methodGuards, requestContainer)];
+			const pipes = [...instantiateMany(globals.pipes, requestContainer), ...instantiateMany(methodPipes, requestContainer)];
+			const interceptors = [...instantiateMany(globals.interceptors, requestContainer), ...instantiateMany(methodInterceptors, requestContainer)];
+			const filters = [...instantiateMany(methodFilters, requestContainer), ...instantiateMany(globals.filters, requestContainer)];
+			const executionContext = buildExecutionContext(c, controller, route.handlerName);
+			try {
+				const instance = requestContainer.resolve(controller);
+				const method = Reflect.get(instance, route.handlerName);
+				if (typeof method !== "function") throw new Error(`Method ${String(route.handlerName)} not found on controller`);
+				const result = await PipelineRunner.run({
+					context: executionContext,
+					guards,
+					interceptors,
+					argsBeforeGuards: true,
+					resolveArgs: () => this.argumentResolver.extract(c, paramMetadata, pipes, requestContainer, paramTypes),
+					invoke: async (args) => Reflect.apply(method, instance, args)
+				});
+				if (redirect) return mapRedirect(c, result, redirect);
+				const response = mapResponse(c, result, httpCode);
+				applyResponseHeaders(response, responseHeaders);
+				return response;
+			} catch (error) {
+				const reporter = resolveErrorReporter(requestContainer);
+				const source = `${controller.name}.${String(route.handlerName)}`;
+				reporter.report(error, {
+					edge: "http",
+					source
+				});
+				for (const filter of filters) if (shouldFilterCatch(filter, error)) try {
+					return mapResponse(c, await filter.catch(error, executionContext));
+				} catch (filterError) {
+					reporter.report(filterError, {
+						edge: "http",
+						source,
+						note: "exception filter threw"
+					});
+					break;
+				}
+				const rendered = reporter.render(error, executionContext);
+				if (rendered instanceof Response) return rendered;
+				if (rendered) return c.json(rendered.body, rendered.status);
+				if (error instanceof HttpException) {
+					const status = error.getStatus();
+					const raw = error.getRawResponse() ?? error.message;
+					if (typeof raw === "string") return c.json({ error: {
+						code: STATUS_TO_CODE[status] ?? "internal",
+						message: raw
+					} }, status);
+					return c.json(raw, status);
+				}
+				const { body, status } = toErrorBody(error, { catalog: reporter.catalog });
+				return c.json(body, status);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/http/route.manager.ts
+const defaultGetClientIp = (c) => c.req.raw.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? c.req.raw.headers.get("x-real-ip") ?? null;
+function disposeStreamWhenDone(body, onDone) {
+	const reader = body.getReader();
+	let finished = false;
+	const finish = () => {
+		if (!finished) {
+			finished = true;
+			onDone();
+		}
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					finish();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (error) {
+				controller.error(error);
+				finish();
+			}
+		},
+		cancel(reason) {
+			finish();
+			return reader.cancel(reason);
+		}
+	});
+}
+var RouteManager = class RouteManager {
+	container;
+	static METHOD_REGISTRAR = /* @__PURE__ */ new Map([
+		[HttpMethod.GET, (app, p, h) => app.get(p, h)],
+		[HttpMethod.POST, (app, p, h) => app.post(p, h)],
+		[HttpMethod.PUT, (app, p, h) => app.put(p, h)],
+		[HttpMethod.PATCH, (app, p, h) => app.patch(p, h)],
+		[HttpMethod.DELETE, (app, p, h) => app.delete(p, h)],
+		[HttpMethod.OPTIONS, (app, p, h) => app.options(p, h)],
+		[HttpMethod.HEAD, (app, p, h) => app.get(p, (c, next) => c.req.method === "HEAD" ? h(c) : next())],
+		[HttpMethod.ALL, (app, p, h) => app.all(p, h)]
+	]);
+	controllers = [];
+	globalMiddleware = [];
+	globalPipes = [];
+	globalGuards = [];
+	globalInterceptors = [];
+	globalFilters = [];
+	globalPrefix = "";
+	consumerMiddlewareDefinitions = [];
+	routeDescriptions = [];
+	handlerExecutor;
+	ambientContainer;
+	constructor(container, options = {}) {
+		this.container = container;
+		this.ambientContainer = options.ambientContainer ?? false;
+		const argumentResolver = new ArgumentResolver(options.getClientIp ?? defaultGetClientIp);
+		this.handlerExecutor = new HandlerExecutor(argumentResolver, () => ({
+			guards: this.globalGuards,
+			pipes: this.globalPipes,
+			interceptors: this.globalInterceptors,
+			filters: this.globalFilters
+		}), (c) => this.getRequestContainer(c));
+	}
+	/**
+	* The global-tier components (`APP_*` provider tokens + imperative
+	* `app.useGlobalX()` instances). Exposed so non-HTTP transports (the
+	* WebSocket dispatcher) can apply the same app-wide guards/pipes/interceptors/
+	* filters as HTTP routes, read live so late registrations propagate.
+	*/
+	getGlobalComponents() {
+		return {
+			guards: this.globalGuards,
+			pipes: this.globalPipes,
+			interceptors: this.globalInterceptors,
+			filters: this.globalFilters
+		};
+	}
+	registerConsumerMiddleware(definitions) {
+		this.consumerMiddlewareDefinitions.push(...definitions);
+		return this;
+	}
+	setGlobalPrefix(prefix) {
+		this.globalPrefix = prefix && !prefix.startsWith("/") ? `/${prefix}` : prefix;
+		return this;
+	}
+	useGlobalMiddleware(...middleware) {
+		this.globalMiddleware.push(...middleware);
+		return this;
+	}
+	useGlobalMiddlewareTokens(...middlewareTokens) {
+		this.globalMiddleware.push(...middlewareTokens);
+		return this;
+	}
+	useGlobalPipes(...pipes) {
+		this.globalPipes.push(...pipes);
+		return this;
+	}
+	useGlobalPipeTokens(...pipeTokens) {
+		this.globalPipes.push(...pipeTokens);
+		return this;
+	}
+	useGlobalGuards(...guards) {
+		this.globalGuards.push(...guards);
+		return this;
+	}
+	useGlobalGuardTokens(...guardTokens) {
+		this.globalGuards.push(...guardTokens);
+		return this;
+	}
+	useGlobalInterceptors(...interceptors) {
+		this.globalInterceptors.push(...interceptors);
+		return this;
+	}
+	useGlobalInterceptorTokens(...interceptorTokens) {
+		this.globalInterceptors.push(...interceptorTokens);
+		return this;
+	}
+	useGlobalFilters(...filters) {
+		this.globalFilters.push(...filters);
+		return this;
+	}
+	useGlobalFilterTokens(...filterTokens) {
+		this.globalFilters.push(...filterTokens);
+		return this;
+	}
+	getMiddlewarePriority(entry) {
+		if (entry == null) return 0;
+		if (typeof entry === "function") {
+			const p = entry.priority;
+			if (typeof p === "number") return p;
+		}
+		if (typeof entry === "object") {
+			const inst = entry;
+			if (typeof inst.priority === "number") return inst.priority;
+			if (typeof inst.constructor?.priority === "number") return inst.constructor.priority;
+		}
+		if (this.container.isLazyPending(entry)) return 0;
+		try {
+			const resolved = instantiate(entry, this.container);
+			if (resolved && typeof resolved === "object") {
+				const p = resolved.priority;
+				if (typeof p === "number") return p;
+				const cp = resolved.constructor?.priority;
+				if (typeof cp === "number") return cp;
+			}
+		} catch {}
+		return 0;
+	}
+	getRequestContainer(c) {
+		const existing = c.get("container");
+		if (existing) return existing;
+		const child = this.container.createChild();
+		child.setRequestInstance(REQUEST_CONTEXT, createRequestContext(c));
+		c.set("container", child);
+		return child;
+	}
+	wrapMiddlewareWithFilters(handler) {
+		return async (c, next) => {
+			try {
+				return await handler(c, next);
+			} catch (error) {
+				const response = await this.mapMiddlewareError(c, error);
+				c.res = response;
+				return response;
+			}
+		};
+	}
+	async mapMiddlewareError(c, error) {
+		const requestContainer = this.getRequestContainer(c);
+		const filters = instantiateMany(this.globalFilters, requestContainer);
+		const host = buildMiddlewareExecutionContext(c);
+		for (const filter of filters) if (shouldFilterCatch(filter, error)) try {
+			return mapResponse(c, await filter.catch(error, host));
+		} catch {
+			break;
+		}
+		if (error instanceof HttpException) {
+			const response = error.getResponse();
+			const status = error.getStatus();
+			return c.json(response, status);
+		}
+		throw error;
+	}
+	registerController(controller) {
+		const prefix = MetadataRegistry.getControllerPath(controller);
+		const options = MetadataRegistry.getControllerOptions(controller);
+		const routes = MetadataRegistry.getRoutes(controller);
+		if (!this.container.has(controller)) this.container.register(controller);
+		this.controllers.push({
+			controller,
+			metadata: {
+				prefix,
+				version: options.version
+			},
+			routes
+		});
+		return this;
+	}
+	/** The explicit controller routes recorded by the last `build()`. */
+	getRouteDescriptions() {
+		return [...this.routeDescriptions];
+	}
+	/** The global prefix in effect (set at bootstrap; '' when none). */
+	getGlobalPrefix() {
+		return this.globalPrefix;
+	}
+	async build() {
+		const app = new Hono();
+		this.routeDescriptions = [];
+		app.use("*", async (c, next) => {
+			let threw = false;
+			try {
+				await next();
+			} catch (error) {
+				threw = true;
+				throw error;
+			} finally {
+				const child = c.get("container");
+				if (child?.hasDisposables()) {
+					const body = threw ? null : c.res?.body ?? null;
+					if (body) c.res = new Response(disposeStreamWhenDone(body, () => void child.dispose()), {
+						status: c.res.status,
+						statusText: c.res.statusText,
+						headers: c.res.headers
+					});
+					else await child.dispose();
+				}
+			}
+		});
+		if (this.ambientContainer) app.use("*", contextStorage());
+		const sortedGlobal = this.globalMiddleware.map((entry, index) => ({
+			entry,
+			index,
+			priority: this.getMiddlewarePriority(entry)
+		})).sort((a, b) => a.priority - b.priority || a.index - b.index);
+		for (const { entry } of sortedGlobal) app.use("*", this.wrapMiddlewareWithFilters((c, next) => {
+			const requestContainer = this.getRequestContainer(c);
+			return instantiate(entry, requestContainer).use(c, next);
+		}));
+		const sortedConsumer = this.consumerMiddlewareDefinitions.map((def, index) => ({
+			def,
+			index,
+			priority: def.priority ?? 0
+		})).sort((a, b) => a.priority - b.priority || a.index - b.index);
+		for (const { def } of sortedConsumer) {
+			const matchRoute = this.compileRouteMatcher(def.routes);
+			const matchExclude = this.compileRouteMatcher(def.excludes);
+			app.use("*", this.wrapMiddlewareWithFilters((c, next) => {
+				const path = c.req.path;
+				const method = c.req.method;
+				if (!matchRoute(path, method) || matchExclude(path, method)) return next();
+				const requestContainer = this.getRequestContainer(c);
+				const runChain = (index) => {
+					if (index >= def.middleware.length) return next();
+					return instantiate(def.middleware[index], requestContainer).use(c, () => runChain(index + 1)).then(() => {});
+				};
+				return runChain(0);
+			}));
+		}
+		for (const { controller, metadata, routes } of this.controllers) if (routes.length > 0) {
+			const allParamMetadata = MetadataRegistry.getParameters(controller);
+			for (const route of routes) {
+				const effectiveVersion = route.version ?? metadata.version;
+				const versionedPaths = this.buildVersionedPaths(this.globalPrefix, metadata.prefix, route.path, effectiveVersion);
+				const versionsForPaths = effectiveVersion === void 0 ? [void 0] : Array.isArray(effectiveVersion) ? effectiveVersion : [effectiveVersion];
+				const middlewareItems = ComponentManager.getScopedComponents("middleware", controller, route.handlerName);
+				const handler = this.handlerExecutor.create(route, controller, allParamMetadata);
+				for (const [pathIndex, fullPath] of versionedPaths.entries()) {
+					for (const middlewareItem of middlewareItems) app.use(fullPath, this.wrapMiddlewareWithFilters((c, next) => {
+						const requestContainer = this.getRequestContainer(c);
+						return instantiate(middlewareItem, requestContainer).use(c, next);
+					}));
+					this.registerRoute(app, route.method, fullPath, handler);
+					this.routeDescriptions.push({
+						method: String(route.method),
+						path: fullPath || "/",
+						controller: controller.name,
+						handler: String(route.handlerName),
+						version: versionsForPaths[pathIndex],
+						...route.name !== void 0 ? { name: route.name } : {}
+					});
+				}
+			}
+		}
+		const contributors = getRouteContributors();
+		for (const { controller, metadata, routes } of this.controllers) {
+			for (const contributor of contributors) {
+				const meta = getMetadata(contributor.claimsMetaKey, controller);
+				if (meta === void 0) continue;
+				await contributor.buildRoutes(app, {
+					controller,
+					controllerPrefix: metadata.prefix,
+					meta,
+					globalPrefix: this.globalPrefix,
+					globalGuards: instantiateMany(this.globalGuards, this.container),
+					container: this.container,
+					joinPaths
+				});
+			}
+			if (getMetadata("vela:crud", controller) !== void 0 && routes.length === 0 && !contributors.some((c) => c.claimsMetaKey === "vela:crud")) console.warn(`[vela] ${controller.name} carries @Crud() metadata but produced no routes — install and import '@velajs/crud' (>=1.18), or remove the decorator.`);
+		}
+		return app;
+	}
+	registerRoute(app, method, path, handler) {
+		const normalizedPath = path || "/";
+		const registrar = RouteManager.METHOD_REGISTRAR.get(method);
+		if (registrar) registrar(app, normalizedPath, handler);
+		else app.on(method, normalizedPath, handler);
+	}
+	buildVersionedPaths(globalPrefix, controllerPrefix, routePath, version) {
+		if (version === void 0) return [joinPaths(globalPrefix, joinPaths(controllerPrefix, routePath))];
+		return (Array.isArray(version) ? version : [version]).map((v) => {
+			return joinPaths(globalPrefix, joinPaths(`/v${v}`, joinPaths(controllerPrefix, routePath)));
+		});
+	}
+	compilePathMatcher(routePath) {
+		if (routePath === "*") return () => true;
+		const norm = routePath.startsWith("/") ? routePath : `/${routePath}`;
+		if (norm.endsWith("*")) {
+			const prefix = norm.slice(0, -1);
+			return (p) => p.startsWith(prefix);
+		}
+		return (p) => p === norm || p.startsWith(`${norm}/`);
+	}
+	compileRouteMatcher(routes) {
+		const matchers = routes.map((route) => {
+			const matchPath = this.compilePathMatcher(route.path);
+			return (path, method) => {
+				if (!matchPath(path)) return false;
+				if (route.method && route.method !== HttpMethod.ALL) return method === route.method;
+				return true;
+			};
+		});
+		if (matchers.length === 0) return () => false;
+		if (matchers.length === 1) return matchers[0];
+		return (path, method) => matchers.some((m) => m(path, method));
+	}
+	getControllers() {
+		return [...this.controllers];
+	}
+};
+//#endregion
+export { UseGuards as A, registerRouteContributor as B, Res as C, createParamDecorator as D, applyDecorators as E, shouldFilterCatch as F, getMetadata as G, joinPaths as H, ComponentManager as I, PipelineRunner as L, UseMiddleware as M, UsePipes as N, Catch as O, getCatchTypes as P, buildExecutionContext as R, Req as S, Version as T, toOpenApiPath as U, instantiateMany as V, defineMetadata as W, Post as _, Cookie as a, RawBody as b, Get as c, Headers as d, HttpCode as f, Patch as g, Param as h, Controller as i, UseInterceptors as j, UseFilters as k, Head as l, Options as m, All as n, Cookies as o, Ip as p, Body as r, Delete as s, RouteManager as t, Header as u, Put as v, Sse as w, Redirect as x, Query as y, getRouteContributors as z };
+
+//# sourceMappingURL=route.manager-DRAZ5X04.js.map