@velajs/vela 0.10.0 → 1.1.0

package/dist/http/decorators.d.ts

@@ -3,16 +3,16 @@ import type { ControllerOptions } from './types';
 import type { ExecutionContext } from '../pipeline/types';
 /**
  * Marks a class as a controller.
- * Accepts a prefix string or an options object with prefix and version.
+ * Accepts a path string or an options object with `path` and `version`.
  *
  * @example
  * ```ts
  * @Controller('/users')
- * @Controller({ prefix: '/users', version: 1 })
- * @Controller({ prefix: '/users', version: [1, 2] })
+ * @Controller({ path: '/users', version: 1 })
+ * @Controller({ path: '/users', version: [1, 2] })
  * ```
  */
-export declare function Controller(prefixOrOptions?: string | ControllerOptions): ClassDecorator;
+export declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
 /**
  * Override the version for a specific route method.
  *
@@ -184,5 +184,6 @@ export declare function getRedirect(target: Constructor, method: string | symbol
  * handle() { ... }
  * ```
  */
-export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ClassDecorator & MethodDecorator & PropertyDecorator;
+export type ComposedDecorator = <T>(target: T, propertyKey?: string | symbol, descriptor?: PropertyDescriptor | number) => void;
+export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ComposedDecorator;
 export declare function isController(target: Constructor): boolean;

package/dist/http/decorators.js

@@ -1,43 +1,30 @@
-import { HttpMethod, METADATA_KEYS, ParamType, Scope } from "../constants.js";
-import { defineMetadata, getMetadata } from "../metadata.js";
+import { HttpMethod, ParamType, Scope } from "../constants.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
-function normalizePath(path) {
-    return path && !path.startsWith('/') ? `/${path}` : path;
-}
+import { normalizePath } from "../registry/paths.js";
+import { buildExecutionContext } from "./execution-context.js";
 /**
  * Marks a class as a controller.
- * Accepts a prefix string or an options object with prefix and version.
+ * Accepts a path string or an options object with `path` and `version`.
  *
  * @example
  * ```ts
  * @Controller('/users')
- * @Controller({ prefix: '/users', version: 1 })
- * @Controller({ prefix: '/users', version: [1, 2] })
+ * @Controller({ path: '/users', version: 1 })
+ * @Controller({ path: '/users', version: [1, 2] })
  * ```
- */ export function Controller(prefixOrOptions) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+ */ export function Controller(pathOrOptions) {
     return (target)=>{
-        let prefix;
-        let version;
-        if (typeof prefixOrOptions === 'string') {
-            prefix = prefixOrOptions;
-        } else if (prefixOrOptions) {
-            prefix = prefixOrOptions.path ?? prefixOrOptions.prefix ?? '';
-            version = prefixOrOptions.version;
-        } else {
-            prefix = '';
-        }
-        MetadataRegistry.setControllerPath(target, normalizePath(prefix));
+        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(target, {
+            MetadataRegistry.setControllerOptions(ctor, {
                 version
             });
         }
-        MetadataRegistry.markInjectable(target);
-        MetadataRegistry.setScope(target, Scope.SINGLETON);
-        // Keep WeakMap write for external package compat
-        defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
-        defineMetadata(METADATA_KEYS.SCOPE, Scope.SINGLETON, target);
+        MetadataRegistry.markInjectable(ctor);
+        MetadataRegistry.setScope(ctor, Scope.SINGLETON);
     };
 }
 /**
@@ -57,28 +44,25 @@ function normalizePath(path) {
  * ```
  */ export function Version(version) {
     return (target, propertyKey, _descriptor)=>{
-        MetadataRegistry.setRouteVersion(target.constructor, propertyKey, version);
-        // Keep WeakMap write for compat
-        const versionKey = `vela:route-version:${String(propertyKey)}`;
-        defineMetadata(versionKey, version, target.constructor);
-        // If route was already registered (decorator ran after @Get), patch it
-        const routes = MetadataRegistry.getRoutes(target.constructor);
-        const route = routes.find((r)=>r.handlerName === propertyKey);
+        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) ?? getMetadata(`vela:route-version:${String(propertyKey)}`, target);
+    return MetadataRegistry.getRouteVersion(target, propertyKey);
 }
 function createMethodDecorator(method) {
     return (path = '')=>{
         return (target, propertyKey, _descriptor)=>{
+            const ctor = target.constructor;
             const normalizedPath = normalizePath(path);
-            // Check for @Version metadata on this method
-            const version = MetadataRegistry.getRouteVersion(target.constructor, propertyKey) ?? getMetadata(`vela:route-version:${String(propertyKey)}`, target.constructor);
-            MetadataRegistry.addRoute(target.constructor, {
+            const version = MetadataRegistry.getRouteVersion(ctor, propertyKey);
+            MetadataRegistry.addRoute(ctor, {
                 method: method,
                 path: normalizedPath,
                 handlerName: propertyKey,
@@ -229,17 +213,7 @@ export const Cookie = createBuiltinParamDecorator(ParamType.COOKIE);
                 name: undefined,
                 factory: (_unused, ctx)=>{
                     const honoCtx = ctx;
-                    const execCtx = {
-                        getType: ()=>'http',
-                        getClass: ()=>target.constructor,
-                        getHandler: ()=>propertyKey,
-                        getContext: ()=>honoCtx,
-                        getRequest: ()=>honoCtx.req.raw,
-                        switchToHttp: ()=>({
-                                getRequest: ()=>honoCtx.req.raw,
-                                getResponse: ()=>honoCtx
-                            })
-                    };
+                    const execCtx = buildExecutionContext(honoCtx, target.constructor, propertyKey);
                     return factory(data, execCtx);
                 },
                 ...pipes.length > 0 ? {
@@ -317,37 +291,16 @@ export const Cookie = createBuiltinParamDecorator(ParamType.COOKIE);
 }
 // Metadata readers (used by RouteManager)
 export function getHttpCode(target, method) {
-    const meta = MetadataRegistry.getHandlerHttpMeta(target, method);
-    if (meta?.httpCode !== undefined) return meta.httpCode;
-    return getMetadata(METADATA_KEYS.HTTP_CODE, target, method);
+    return MetadataRegistry.getHandlerHttpMeta(target, method)?.httpCode;
 }
 export function getResponseHeaders(target, method) {
-    const meta = MetadataRegistry.getHandlerHttpMeta(target, method);
-    if (meta?.responseHeaders) return meta.responseHeaders;
-    return getMetadata(METADATA_KEYS.RESPONSE_HEADERS, target, method) ?? [];
+    return MetadataRegistry.getHandlerHttpMeta(target, method)?.responseHeaders ?? [];
 }
 export function getRedirect(target, method) {
-    const meta = MetadataRegistry.getHandlerHttpMeta(target, method);
-    if (meta?.redirect) return meta.redirect;
-    return getMetadata(METADATA_KEYS.REDIRECT, target, method);
+    return MetadataRegistry.getHandlerHttpMeta(target, method)?.redirect;
 }
-/**
- * Composes multiple decorators into one. Applies them in order (top to bottom),
- * matching how stacked decorators behave when written separately.
- *
- * @example
- * ```ts
- * const Auth = (...roles: string[]) => applyDecorators(
- *   UseGuards(JwtGuard, RolesGuard),
- *   SetMetadata('roles', roles),
- * );
- *
- * @Auth('admin')
- * @Get('/admin')
- * handle() { ... }
- * ```
- */ export function applyDecorators(...decorators) {
-    const composed = (target, propertyKey, descriptor)=>{
+export function applyDecorators(...decorators) {
+    return (target, propertyKey, descriptor)=>{
         for (const decorator of decorators){
             if (propertyKey === undefined && typeof descriptor !== 'number') {
                 decorator(target);
@@ -358,7 +311,6 @@ export function getRedirect(target, method) {
             }
         }
     };
-    return composed;
 }
 // Helpers
 export function isController(target) {

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

@@ -0,0 +1,4 @@
+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;

package/dist/http/execution-context.js

@@ -0,0 +1,15 @@
+// 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
+            })
+    };
+}

package/dist/http/index.d.ts

@@ -1,6 +1,6 @@
 export { RouteManager } from './route.manager';
 export type { RouteManagerOptions } from './route.manager';
-export { MiddlewareBuilder, RequestMethod } from './middleware-consumer';
-export type { MiddlewareConsumer, MiddlewareConfigProxy, RouteInfo, NestModule, MiddlewareRouteDefinition } from './middleware-consumer';
+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 { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -1,3 +1,3 @@
 export { RouteManager } from "./route.manager.js";
-export { MiddlewareBuilder, RequestMethod } from "./middleware-consumer.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";

package/dist/http/route.manager.d.ts

@@ -1,7 +1,7 @@
 import { type Context, type MiddlewareHandler, Hono } from 'hono';
 import type { Container } from '../container/container';
 import type { Token, Type } from '../container/types';
-import type { MiddlewareRouteDefinition } from './middleware-consumer';
+import type { MiddlewareRouteDefinition } from '../module/middleware';
 import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
 import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
 import type { ControllerRegistration } from './types';
@@ -49,7 +49,6 @@ export declare class RouteManager {
     private createResponse;
     private registerRoute;
     private buildVersionedPaths;
-    private joinPaths;
     private compilePathMatcher;
     private compileRouteMatcher;
     getControllers(): ControllerRegistration[];

package/dist/http/route.manager.js

@@ -2,7 +2,8 @@ import { Hono } from "hono";
 import { getCookie } from "hono/cookie";
 import { HttpMethod, ParamType } from "../constants.js";
 import { getMetadata } from "../metadata.js";
-import { RequestMethod } from "./middleware-consumer.js";
+import { joinPaths } from "../registry/paths.js";
+import { buildExecutionContext } from "./execution-context.js";
 import { ForbiddenException, HttpException } from "../errors/http-exception.js";
 import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
@@ -50,7 +51,7 @@ export class RouteManager {
         ],
         [
             HttpMethod.HEAD,
-            (app, p, h)=>app.get(p, h)
+            (app, p, h)=>app.get(p, (c, next)=>c.req.method === 'HEAD' ? h(c) : next())
         ],
         [
             HttpMethod.ALL,
@@ -175,11 +176,6 @@ export class RouteManager {
     instantiateMany(items, container) {
         return items.map((item)=>this.instantiate(item, container));
     }
-    // Resolve middleware priority at build time. Supports three sources:
-    //   1. static priority on the class constructor
-    //   2. priority property on the instance
-    //   3. for container tokens, resolve and inspect the instance (+ its ctor)
-    // Falls back to 0 on any error or when no priority is set.
     getMiddlewarePriority(entry) {
         if (entry == null) return 0;
         if (typeof entry === 'function') {
@@ -306,31 +302,25 @@ export class RouteManager {
                     await buildCrudRoutes(app, controller, metadata.prefix, crudConfig, {
                         globalPrefix: this.globalPrefix,
                         globalGuards: this.instantiateMany(this.globalGuards, this.container),
-                        joinPaths: this.joinPaths.bind(this)
+                        joinPaths
+                    });
+                } catch (err) {
+                    throw new Error(`@Crud() requires '@velajs/crud'. Install it: pnpm add @velajs/crud`, {
+                        cause: err
                     });
-                } catch  {
-                    throw new Error(`@Crud() requires '@velajs/crud'. Install it: bun add @velajs/crud`);
                 }
             }
         }
         return app;
     }
     createExecutionContext(c, controller, route) {
-        return {
-            getType: ()=>'http',
-            getClass: ()=>controller,
-            getHandler: ()=>route.handlerName,
-            getContext: ()=>c,
-            getRequest: ()=>c.req.raw,
-            switchToHttp: ()=>({
-                    getRequest: ()=>c.req.raw,
-                    getResponse: ()=>c
-                })
-        };
+        return buildExecutionContext(c, controller, route.handlerName);
     }
     createHandler(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
+        // 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);
         // Collect controller + method level components at build time
         const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
@@ -475,12 +465,16 @@ export class RouteManager {
     registerRoute(app, method, path, handler) {
         const normalizedPath = path || '/';
         const registrar = RouteManager.METHOD_REGISTRAR.get(method);
-        registrar ? registrar(app, normalizedPath, handler) : app.on(method.toUpperCase(), normalizedPath, handler);
+        if (registrar) {
+            registrar(app, normalizedPath, handler);
+        } else {
+            app.on(method, normalizedPath, handler);
+        }
     }
     buildVersionedPaths(globalPrefix, controllerPrefix, routePath, version) {
         if (version === undefined) {
             return [
-                this.joinPaths(globalPrefix, this.joinPaths(controllerPrefix, routePath))
+                joinPaths(globalPrefix, joinPaths(controllerPrefix, routePath))
             ];
         }
         const versions = Array.isArray(version) ? version : [
@@ -488,14 +482,9 @@ export class RouteManager {
         ];
         return versions.map((v)=>{
             const versionSegment = `/v${v}`;
-            return this.joinPaths(globalPrefix, this.joinPaths(versionSegment, this.joinPaths(controllerPrefix, routePath)));
+            return joinPaths(globalPrefix, joinPaths(versionSegment, joinPaths(controllerPrefix, routePath)));
         });
     }
-    joinPaths(prefix, path) {
-        const cleanPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-        const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
-        return `${cleanPrefix}${cleanPath}` || '/';
-    }
     compilePathMatcher(routePath) {
         if (routePath === '*') return ()=>true;
         const norm = routePath.startsWith('/') ? routePath : `/${routePath}`;
@@ -510,7 +499,7 @@ export class RouteManager {
             const matchPath = this.compilePathMatcher(route.path);
             return (path, method)=>{
                 if (!matchPath(path)) return false;
-                if (route.method && route.method !== RequestMethod.ALL) return method === route.method;
+                if (route.method && route.method !== HttpMethod.ALL) return method === route.method;
                 return true;
             };
         });

package/dist/http/types.d.ts

@@ -8,7 +8,6 @@ export interface RouteMetadata {
     version?: number | number[];
 }
 export interface ControllerOptions {
-    prefix?: string;
     path?: string;
     version?: number | number[];
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import './metadata';
 export { defineMetadata, getMetadata } from './metadata';
-export { VelaFactory, createApplication } from './factory';
+export { VelaFactory } from './factory';
 export { VelaApplication } from './application';
 export { createOpenApiDocument, ApiDoc, ApiTags, ApiResponse, zodToJsonSchema, } from './openapi/index';
 export type { OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiRequestBody, OpenApiResponse, ApiDocMetadata, ApiResponseEntry, ApiResponseOptions, CreateOpenApiDocumentOptions, HttpVerb, JsonSchema, } from './openapi/index';
@@ -20,15 +20,14 @@ export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey
 export type { CacheModuleOptions, CacheStore, CacheEntry } from './cache/index';
 export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_EVENT_METADATA, } from './event-emitter/index';
 export type { EventHandler, OnEventMetadata } from './event-emitter/index';
-export { ScheduleModule, ScheduleRegistry, ScheduleExecutor, Cron, Interval, SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA, } from './schedule/index';
-export type { RegisteredCronJob, RegisteredIntervalJob, CronMetadata, IntervalMetadata, ScheduleModuleOptions, } from './schedule/index';
+export { ScheduleModule, ScheduleRegistry, Cron, Interval, parseCron, CRON_METADATA, INTERVAL_METADATA, } from './schedule/index';
+export type { RegisteredCronJob, RegisteredIntervalJob, CronMetadata, IntervalMetadata, CronMatcher, } from './schedule/index';
 export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthIndicator, } from './health/index';
 export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, HttpPingOptions, } from './health/index';
 export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA, } from './throttler/index';
 export type { ThrottlerModuleOptions, ThrottleConfig, ThrottlerStore, ThrottlerStorageRecord, RateLimitInfo, } from './throttler/index';
 export { Global, Module, createModuleRef } from './module/index';
 export type { ModuleOptions, DynamicModule, AsyncModuleOptions, ModuleImport } from './module/index';
-export { RequestMethod } from './http/index';
 export type { MiddlewareConsumer, NestModule, RouteInfo } from './http/index';
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, } from './pipeline/index';
 export type { HttpArgumentsHost, ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, ReflectableDecorator, CreateDecoratorOptions, } from './pipeline/index';
@@ -37,13 +36,8 @@ export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPi
 export type { ParseUUIDPipeOptions, ParseArrayPipeOptions } from './pipeline/index';
 export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './errors/index';
 export type { OnModuleInit, OnApplicationBootstrap, OnModuleDestroy, OnApplicationShutdown, BeforeApplicationShutdown, } from './lifecycle/index';
-export { MetadataRegistry } from './registry/index';
-export { RouteManager } from './http/index';
-export type { RouteManagerOptions } from './http/index';
-export { ModuleLoader } from './module/index';
-export { ComponentManager } from './pipeline/index';
+export { MetadataRegistry } from './registry/metadata.registry';
 export { createZodDto, ValidationPipe } from './validation/index';
 export type { CreateZodDtoOptions } from './validation/index';
 export { Serialize, SerializerInterceptor, SERIALIZE_METADATA } from './serialization/index';
-export { Test, TestingModule, TestingModuleBuilder } from './testing/index';
 export { getRuntimeKey, env } from 'hono/adapter';

package/dist/index.js

@@ -1,7 +1,7 @@
 import "./metadata.js";
 export { defineMetadata, getMetadata } from "./metadata.js";
 // Factory & Application
-export { VelaFactory, createApplication } from "./factory.js";
+export { VelaFactory } from "./factory.js";
 export { VelaApplication } from "./application.js";
 // OpenAPI
 export { createOpenApiDocument, ApiDoc, ApiTags, ApiResponse, zodToJsonSchema } from "./openapi/index.js";
@@ -24,32 +24,27 @@ export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey
 // Event Emitter
 export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_EVENT_METADATA } from "./event-emitter/index.js";
 // Schedule
-export { ScheduleModule, ScheduleRegistry, ScheduleExecutor, Cron, Interval, SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from "./schedule/index.js";
+export { ScheduleModule, ScheduleRegistry, Cron, Interval, parseCron, CRON_METADATA, INTERVAL_METADATA } from "./schedule/index.js";
 // Health
 export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthIndicator } from "./health/index.js";
 // Throttler
 export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler/index.js";
 // Module
 export { Global, Module, createModuleRef } from "./module/index.js";
-export { RequestMethod } from "./http/index.js";
 // Pipeline Decorators
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/index.js";
 // Built-in Pipes
 export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipeline/index.js";
 // Errors
 export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException } from "./errors/index.js";
-// Registry (for advanced usage)
-export { MetadataRegistry } from "./registry/index.js";
-// Module internals (for @velajs/testing and advanced usage)
-export { RouteManager } from "./http/index.js";
-export { ModuleLoader } from "./module/index.js";
-// Component Manager (for advanced usage)
-export { ComponentManager } from "./pipeline/index.js";
+// MetadataRegistry — the central decoration store. Test setup typically
+// uses `MetadataRegistry.clear()` between cases. Internal primitives like
+// RouteManager/ModuleLoader/ComponentManager live only at @velajs/vela/internal.
+export { MetadataRegistry } from "./registry/metadata.registry.js";
 // Validation
 export { createZodDto, ValidationPipe } from "./validation/index.js";
 // Serialization
 export { Serialize, SerializerInterceptor, SERIALIZE_METADATA } from "./serialization/index.js";
-// Testing
-export { Test, TestingModule, TestingModuleBuilder } from "./testing/index.js";
+// Testing utilities live in @velajs/testing — see https://github.com/velajs/testing
 // Hono Adapter Utilities
 export { getRuntimeKey, env } from "hono/adapter";

package/dist/internal.d.ts

@@ -0,0 +1,11 @@
+export { Container } from './container/container';
+export { ModuleRef } from './container/module-ref';
+export { bindAppProviders } from './pipeline/app-providers';
+export { RouteManager } from './http/route.manager';
+export type { RouteManagerOptions } from './http/route.manager';
+export { ModuleLoader } from './module/module-loader';
+export { ComponentManager } from './pipeline/component.manager';
+export { VelaApplication } from './application';
+export { MetadataRegistry } from './registry/metadata.registry';
+export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, } from './pipeline/tokens';
+export { getModuleMetadata, isModule } from './module/decorators';

package/dist/internal.js

@@ -0,0 +1,13 @@
+// Internal framework primitives — exposed for first-party consumers like
+// @velajs/testing and advanced integration. Not covered by semver guarantees
+// to the same degree as the public surface (./index).
+export { Container } from "./container/container.js";
+export { ModuleRef } from "./container/module-ref.js";
+export { bindAppProviders } from "./pipeline/app-providers.js";
+export { RouteManager } from "./http/route.manager.js";
+export { ModuleLoader } from "./module/module-loader.js";
+export { ComponentManager } from "./pipeline/component.manager.js";
+export { VelaApplication } from "./application.js";
+export { MetadataRegistry } from "./registry/metadata.registry.js";
+export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/tokens.js";
+export { getModuleMetadata, isModule } from "./module/decorators.js";

package/dist/metadata.js

@@ -1,22 +1,13 @@
-// Lightweight metadata store — replaces the `reflect-metadata` npm package.
-// All custom vela:* keys go through defineMetadata/getMetadata.
-// The Reflect.metadata polyfill keeps SWC's auto-emitted design:paramtypes working.
-const store = new WeakMap();
-function compositeKey(key, prop) {
-    return prop !== undefined ? `${key}\0${String(prop)}` : key;
-}
+// Single funnel: every Reflect.* metadata write/read routes into MetadataRegistry.
+// SWC emits Reflect.metadata('design:paramtypes', ...) calls in compiled code;
+// the polyfill catches those and parks them in the registry alongside vela's typed slots.
+import { MetadataRegistry } from "./registry/metadata.registry.js";
 export function defineMetadata(key, value, target, propertyKey) {
-    let map = store.get(target);
-    if (!map) {
-        map = new Map();
-        store.set(target, map);
-    }
-    map.set(compositeKey(key, propertyKey), value);
+    MetadataRegistry.setReflectMetadata(target, key, value, propertyKey);
 }
 export function getMetadata(key, target, propertyKey) {
-    return store.get(target)?.get(compositeKey(key, propertyKey));
+    return MetadataRegistry.getReflectMetadata(target, key, propertyKey);
 }
-// Minimal Reflect polyfill so the compiler's `Reflect.metadata(...)` calls work.
 if (typeof Reflect.defineMetadata !== 'function') {
     Reflect.defineMetadata = defineMetadata;
     Reflect.getMetadata = getMetadata;

package/dist/module/decorators.d.ts

@@ -1,6 +1,4 @@
-import type { Constructor } from '../registry/types';
-import type { Type } from '../container/types';
-import type { ModuleMetadata, ModuleOptions } from './types';
+import type { Constructor, ModuleMetadata, ModuleOptions, Type } from '../registry/types';
 export declare function Global(): ClassDecorator;
 export declare function Module(options?: ModuleOptions): ClassDecorator;
 export declare function isModule(target: Constructor): boolean;

package/dist/module/decorators.js

@@ -1,34 +1,27 @@
-import { METADATA_KEYS } from "../constants.js";
-import { defineMetadata, getMetadata } from "../metadata.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 export function Global() {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return (target)=>{
-        const existing = MetadataRegistry.getModuleOptions(target);
-        MetadataRegistry.setModuleOptions(target, {
+        const ctor = target;
+        const existing = MetadataRegistry.getModuleOptions(ctor);
+        MetadataRegistry.setModuleOptions(ctor, {
             ...existing,
             isGlobal: true
         });
     };
 }
 export function Module(options = {}) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return (target)=>{
-        const normalized = {
+        MetadataRegistry.setModuleOptions(target, {
             imports: options.imports,
             providers: options.providers,
             controllers: options.controllers,
             exports: options.exports,
             isGlobal: options.isGlobal
-        };
-        // WeakMap store survives MetadataRegistry.clear() — needed for framework modules
-        // decorated at import time (e.g. HttpModule, CorsModule).
-        defineMetadata(METADATA_KEYS.MODULE_OPTIONS, normalized, target);
-        MetadataRegistry.setModuleOptions(target, normalized);
+        });
     };
 }
 export function isModule(target) {
-    return MetadataRegistry.getModuleOptions(target) !== undefined || getMetadata(METADATA_KEYS.MODULE, target) === true || getMetadata(METADATA_KEYS.MODULE_OPTIONS, target) !== undefined;
+    return MetadataRegistry.getModuleOptions(target) !== undefined;
 }
 export function createModuleRef(name) {
     const moduleClass = class {
@@ -39,13 +32,8 @@ export function createModuleRef(name) {
     return moduleClass;
 }
 export function getModuleMetadata(target) {
-    if (!isModule(target)) {
-        return undefined;
-    }
-    const options = MetadataRegistry.getModuleOptions(target) ?? getMetadata(METADATA_KEYS.MODULE_OPTIONS, target);
-    if (!options || typeof options !== 'object') {
-        return undefined;
-    }
+    const options = MetadataRegistry.getModuleOptions(target);
+    if (!options) return undefined;
     return {
         providers: options.providers ?? [],
         controllers: options.controllers ?? [],

package/dist/module/graph.d.ts

@@ -0,0 +1,10 @@
+import type { Type } from '../container/types';
+/**
+ * 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.
+ */
+export declare function collectControllers(rootModule: Type): Type[];