@velajs/vela 1.19.0 → 1.19.1

package/dist/http/decorators.js

@@ -1,321 +0,0 @@
-import { HttpMethod, ParamType, Scope } from "../constants.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { normalizePath } from "../registry/paths.js";
-import { buildExecutionContext } from "./execution-context.js";
-/**
- * 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] })
- * ```
- */ export function Controller(pathOrOptions) {
-    return (target)=>{
-        const ctor = target;
-        const path = typeof pathOrOptions === 'string' ? pathOrOptions : pathOrOptions?.path ?? '';
-        const version = typeof pathOrOptions === 'object' ? pathOrOptions?.version : undefined;
-        MetadataRegistry.setControllerPath(ctor, normalizePath(path));
-        if (version !== undefined) {
-            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
- * }
- * ```
- */ export function Version(version) {
-    return (target, propertyKey, _descriptor)=>{
-        const ctor = target.constructor;
-        MetadataRegistry.setRouteVersion(ctor, propertyKey, version);
-        // If route was already registered (decorator ran after @Get), patch it.
-        const route = MetadataRegistry.getRoutes(ctor).find((r)=>r.handlerName === propertyKey);
-        if (route) {
-            route.version = version;
-        }
-    };
-}
-export function getRouteVersion(target, propertyKey) {
-    return MetadataRegistry.getRouteVersion(target, propertyKey);
-}
-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: method,
-                path: normalizedPath,
-                handlerName: propertyKey,
-                ...version !== undefined ? {
-                    version
-                } : {},
-                ...options?.name !== undefined ? {
-                    name: options.name
-                } : {}
-            });
-        };
-    };
-}
-export const Get = createMethodDecorator(HttpMethod.GET);
-export const Post = createMethodDecorator(HttpMethod.POST);
-export const Put = createMethodDecorator(HttpMethod.PUT);
-export const Patch = createMethodDecorator(HttpMethod.PATCH);
-export const Delete = createMethodDecorator(HttpMethod.DELETE);
-export const Options = createMethodDecorator(HttpMethod.OPTIONS);
-export const Head = createMethodDecorator(HttpMethod.HEAD);
-export const All = createMethodDecorator(HttpMethod.ALL);
-export const Sse = createMethodDecorator(HttpMethod.GET);
-// Parameter decorators
-const CUSTOM_PARAM_TYPE = 'custom';
-function createBuiltinParamDecorator(type) {
-    return (nameOrPipe, ...pipes)=>{
-        return (target, propertyKey, parameterIndex)=>{
-            if (propertyKey === undefined) {
-                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 !== undefined) {
-                name = undefined;
-                allPipes = [
-                    nameOrPipe,
-                    ...pipes
-                ];
-            } else {
-                name = undefined;
-                allPipes = pipes;
-            }
-            MetadataRegistry.addParameter(target.constructor, propertyKey, {
-                index: parameterIndex,
-                type,
-                name,
-                ...allPipes.length > 0 ? {
-                    pipes: allPipes
-                } : {}
-            });
-        };
-    };
-}
-export const Param = createBuiltinParamDecorator(ParamType.PARAM);
-export const Query = createBuiltinParamDecorator(ParamType.QUERY);
-export const Body = createBuiltinParamDecorator(ParamType.BODY);
-export const Headers = createBuiltinParamDecorator(ParamType.HEADERS);
-export 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 };
- * }
- * ```
- */ export const Res = createBuiltinParamDecorator(ParamType.RESPONSE);
-export const Ip = createBuiltinParamDecorator(ParamType.IP);
-export 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) { ... }
- * ```
- */ export 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...
- * }
- * ```
- */ export function RawBody() {
-    return (target, propertyKey, parameterIndex)=>{
-        if (propertyKey === undefined) {
-            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) { ... }
- * ```
- */ export function createParamDecorator(factory) {
-    return (data, ...pipes)=>{
-        return (target, propertyKey, parameterIndex)=>{
-            if (propertyKey === undefined) {
-                throw new Error('Parameter decorators can only be used on method parameters');
-            }
-            MetadataRegistry.addParameter(target.constructor, propertyKey, {
-                index: parameterIndex,
-                type: CUSTOM_PARAM_TYPE,
-                name: undefined,
-                factory: (_unused, ctx)=>{
-                    const honoCtx = ctx;
-                    const execCtx = buildExecutionContext(honoCtx, target.constructor, propertyKey);
-                    return factory(data, execCtx);
-                },
-                ...pipes.length > 0 ? {
-                    pipes
-                } : {}
-            });
-        };
-    };
-}
-// Response decorators
-/**
- * Override the HTTP status code for a handler's response.
- *
- * @example
- * ```ts
- * @Post()
- * @HttpCode(201)
- * create(@Body() data: CreateDto) { return data; }
- * ```
- */ export 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 }; }
- * ```
- */ export 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 };
- * }
- * ```
- */ export function Redirect(url, statusCode = 302) {
-    return (target, propertyKey, _descriptor)=>{
-        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
-            redirect: {
-                url,
-                statusCode
-            }
-        });
-    };
-}
-// Metadata readers (used by RouteManager)
-export function getHttpCode(target, method) {
-    return MetadataRegistry.getHandlerHttpMeta(target, method)?.httpCode;
-}
-export function getResponseHeaders(target, method) {
-    return MetadataRegistry.getHandlerHttpMeta(target, method)?.responseHeaders ?? [];
-}
-export function getRedirect(target, method) {
-    return MetadataRegistry.getHandlerHttpMeta(target, method)?.redirect;
-}
-export function applyDecorators(...decorators) {
-    return (target, propertyKey, descriptor)=>{
-        for (const decorator of decorators){
-            if (propertyKey === undefined && typeof descriptor !== 'number') {
-                decorator(target);
-            } else if (typeof descriptor === 'number') {
-                decorator(target, propertyKey, descriptor);
-            } else {
-                decorator(target, propertyKey, descriptor);
-            }
-        }
-    };
-}
-// Helpers
-export function isController(target) {
-    return MetadataRegistry.getControllerPath(target) !== '' || MetadataRegistry.getRoutes(target).length > 0;
-}

package/dist/http/execution-context.d.ts

@@ -1,8 +0,0 @@
-import type { Context } from 'hono';
-import type { Type } from '../container/types';
-import type { ExecutionContext } from '../pipeline/types';
-export declare function buildExecutionContext(c: Context, controller: Type, handlerName: string | symbol): ExecutionContext;
-export declare class VelaMiddlewareHost {
-}
-export declare const VELA_MIDDLEWARE_HANDLER: unique symbol;
-export declare function buildMiddlewareExecutionContext(c: Context): ExecutionContext;

package/dist/http/execution-context.js

@@ -1,35 +0,0 @@
-// Single source of ExecutionContext shape — used by the route pipeline AND
-// by createParamDecorator's deferred factory call.
-export 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.');
-        }
-    };
-}
-// Sentinel marker exposed via `ExecutionContext.getClass()` when the host is a
-// vela-attached middleware rather than a controller handler. Filters that
-// branch on the calling class (rare) can detect the middleware origin without
-// introducing a separate `getType()` value — `getType()` stays `'http'` for
-// NestJS parity.
-export class VelaMiddlewareHost {
-}
-// Synthesizes an ExecutionContext for an exception thrown inside a
-// vela-attached middleware. There is no controller class or handler method
-// on the call stack at that point, so `getClass()` returns the
-// `VelaMiddlewareHost` marker and `getHandler()` returns the
-// `vela.middleware` symbol — both stable, comparable values that filter
-// authors can pattern-match against if needed.
-export const VELA_MIDDLEWARE_HANDLER = Symbol.for('vela.middleware');
-export function buildMiddlewareExecutionContext(c) {
-    return buildExecutionContext(c, VelaMiddlewareHost, VELA_MIDDLEWARE_HANDLER);
-}

package/dist/http/handler-executor.d.ts

@@ -1,20 +0,0 @@
-import type { Context } from 'hono';
-import type { Container } from '../container/container';
-import type { Token, Type } from '../container/types';
-import type { CanActivate, ExceptionFilter, NestInterceptor, PipeTransform } from '../pipeline/types';
-import type { FilterType, GuardType, InterceptorType, ParameterMetadata, PipeType } from '../registry/types';
-import type { ArgumentResolver } from './argument-resolver';
-import type { RouteMetadata } from './types';
-export interface HandlerGlobals {
-    guards: Array<GuardType | Token<CanActivate>>;
-    pipes: Array<PipeType | Token<PipeTransform>>;
-    interceptors: Array<InterceptorType | Token<NestInterceptor>>;
-    filters: Array<FilterType | Token<ExceptionFilter>>;
-}
-export declare class HandlerExecutor {
-    private readonly argumentResolver;
-    private readonly getGlobals;
-    private readonly getRequestContainer;
-    constructor(argumentResolver: ArgumentResolver, getGlobals: () => HandlerGlobals, getRequestContainer: (c: Context) => Container);
-    create(route: RouteMetadata, controller: Type, allParamMetadata: Map<string | symbol, ParameterMetadata[]>): (c: Context) => Promise<Response>;
-}

package/dist/http/handler-executor.js

@@ -1,133 +0,0 @@
-import { STATUS_TO_CODE, toErrorBody } from "@velajs/errors";
-import { HttpException } from "../errors/http-exception.js";
-import { resolveErrorReporter } from "../exceptions/reporter.js";
-import { ComponentManager } from "../pipeline/component.manager.js";
-import { shouldFilterCatch } from "../pipeline/decorators.js";
-import { PipelineRunner } from "../pipeline/pipeline-runner.js";
-import { getHttpCode, getRedirect, getResponseHeaders } from "./decorators.js";
-import { buildExecutionContext } from "./execution-context.js";
-import { instantiateMany } from "./instantiate.js";
-import { applyResponseHeaders, mapRedirect, mapResponse } from "./response-mapper.js";
-// Builds the per-request closure that runs guards, pipes, interceptors, the
-// handler itself, and exception filters. Pure orchestration — Hono route
-// registration stays in RouteManager. Globals are read via a callback so
-// post-create additions (`useGlobalGuards`, etc.) propagate to subsequent
-// requests without rebuilding routes.
-export class HandlerExecutor {
-    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);
-        // Read param types once at build time for metatype population.
-        // Routed via Reflect so the polyfill funnels both src-level and dist-level
-        // consumers to the same registry (matters in tests that import from dist).
-        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);
-        // Filters: reverse order (handler → controller → global) — closest to handler runs first
-        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)=>{
-            // Combine global + method at request time so post-create registrations propagate.
-            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`);
-                }
-                // Args + pipes → guards → interceptor chain → handler, via the shared
-                // runner. `argsBeforeGuards` preserves the deliberate vela HTTP order.
-                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)}`;
-                // Report FIRST, always — rendering (filters included) is a separate
-                // concern; a filter claiming the error must not make it invisible.
-                reporter.report(error, {
-                    edge: 'http',
-                    source
-                });
-                for (const filter of filters){
-                    if (shouldFilterCatch(filter, error)) {
-                        try {
-                            const filtered = await filter.catch(error, executionContext);
-                            return mapResponse(c, filtered);
-                        } catch (filterError) {
-                            // A broken filter is itself a bug worth logs — then fall through
-                            // to the default render instead of silently dying here.
-                            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); // object responses ship verbatim (crud envelope compat)
-                }
-                const { body, status } = toErrorBody(error, {
-                    catalog: reporter.catalog
-                });
-                return c.json(body, status);
-            }
-        };
-    }
-}

package/dist/http/index.d.ts

@@ -1,12 +0,0 @@
-export { RouteManager } from './route.manager';
-export type { RouteManagerOptions } from './route.manager';
-export { MiddlewareBuilder } from '../module/middleware';
-export type { MiddlewareConsumer, MiddlewareConfigProxy, RouteInfo, NestModule, MiddlewareRouteDefinition } from '../module/middleware';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';
-export type { RouteOptions } from './decorators';
-export { createLazyParamDecorator } from './lazy-param.decorator';
-export { UrlGeneratorService, SignedUrlGuard, SignedUrl, URL_SIGNING_SECRET, } from './url/index';
-export type { UrlForOptions, SignedUrlGenerateOptions } from './url/index';
-export type { VelaRouteMap, RouteName, RouteParams } from './route-map';
-export { enableAmbientContainer, getCurrentContainer, getCurrentRequestContext, } from './ambient';
-export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -1,7 +0,0 @@
-export { RouteManager } from "./route.manager.js";
-export { MiddlewareBuilder } from "../module/middleware.js";
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController } from "./decorators.js";
-export { createLazyParamDecorator } from "./lazy-param.decorator.js";
-// Named-route URL generation + signed URLs
-export { UrlGeneratorService, SignedUrlGuard, SignedUrl, URL_SIGNING_SECRET } from "./url/index.js";
-export { enableAmbientContainer, getCurrentContainer, getCurrentRequestContext } from "./ambient.js";

package/dist/http/instantiate.d.ts

@@ -1,4 +0,0 @@
-import type { Container } from '../container/container';
-import type { Token, Type } from '../container/types';
-export declare function instantiate<T>(classOrInstance: Type<T> | Token<T> | T, container: Container): T;
-export declare function instantiateMany<T>(items: Array<Type<T> | Token<T> | T>, container: Container): T[];

package/dist/http/instantiate.js

@@ -1,45 +0,0 @@
-import { getConstructorDependencies, getInjectMetadata } from "../container/decorators.js";
-// Resolve a class/token through the container if registered, otherwise treat
-// the input as a plain instance. Used by RouteManager and HandlerExecutor to
-// materialize middleware, guards, pipes, interceptors, and filters per request.
-//
-// When the input is a class that is NOT registered in the container, we fall
-// back to `new clazz()` so plain parameterless helper classes (e.g. mixin
-// guards, ad-hoc `@UseGuards(LocalGuard)` references) keep working. That
-// fallback is unsafe for classes whose CONSTRUCTOR EXPECTS DEPENDENCIES,
-// because zero-arg construction would leave every injected slot `undefined`
-// — a silent failure mode that surfaces later as
-// `Cannot read properties of undefined (reading '...')` deep inside the
-// class. For those classes we throw a loud, actionable error instead.
-//
-// We treat "expects dependencies" as: any `@Inject(...)` parameter metadata
-// OR a non-empty `design:paramtypes` (the SWC/TS emit for any constructor
-// parameter). `@Injectable()` alone is NOT sufficient — `mixin()` and many
-// parameterless guards are `@Injectable()` and still safe to `new` directly.
-export 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;
-}
-// True when calling `new clazz()` would leave an injected slot `undefined`:
-// either the class has explicit `@Inject(...)` metadata, or it has any typed
-// constructor parameter (TS/SWC's `design:paramtypes` emit). Parameterless
-// `@Injectable()` classes return false — `new()` is safe for them.
-function constructorExpectsDependencies(clazz) {
-    if (getInjectMetadata(clazz).length > 0) return true;
-    return getConstructorDependencies(clazz).length > 0;
-}
-export function instantiateMany(items, container) {
-    return items.map((item)=>instantiate(item, container));
-}

package/dist/http/lazy-param.decorator.d.ts

@@ -1,37 +0,0 @@
-import type { PipeType } from '../registry/types';
-import type { ExecutionContext } from '../pipeline/types';
-/**
- * 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
- * }
- * ```
- */
-export declare function createLazyParamDecorator<TData = unknown>(factory: (data: TData, ctx: ExecutionContext) => unknown): (data?: TData, ...pipes: PipeType[]) => ParameterDecorator;