@velajs/vela 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # Changelog
 
+## 1.1.0 (2026-04-30)
+
+Architectural remodel: one metadata model, one storage, public surface trimmed, internal primitives exposed via a stable subpath.
+
+### Breaking changes
+
+- **`createApplication` removed.** Use `VelaFactory.create(AppModule)` directly.
+
+  ```diff
+  - import { createApplication } from '@velajs/vela';
+  - const app = await createApplication(AppModule);
+  + import { VelaFactory } from '@velajs/vela';
+  + const app = await VelaFactory.create(AppModule);
+  ```
+
+- **`RequestMethod` removed; `HttpMethod` is canonical and now uppercase.** The two enums had the same purpose but different cases (`'get'` vs `'GET'`). Unified to uppercase to match HTTP spec and Hono's request `method` field.
+
+  ```diff
+  - import { RequestMethod } from '@velajs/vela';
+  - .forRoutes({ path: '/api', method: RequestMethod.POST });
+  + import { HttpMethod } from '@velajs/vela';
+  + .forRoutes({ path: '/api', method: HttpMethod.POST });
+  ```
+
+- **`@Controller({ prefix })` removed; `@Controller({ path })` only.** `prefix` was a non-canonical alias.
+
+  ```diff
+  - @Controller({ prefix: '/users', version: 1 })
+  + @Controller({ path: '/users', version: 1 })
+  ```
+
+- **`HttpModule.register` / `registerAsync` renamed to `forRoot` / `forRootAsync`.** Same for `CacheModule.registerAsync` → `forRootAsync`. Matches NestJS canonical naming and aligns the rest of the framework's dynamic-module shape.
+
+  ```diff
+  - HttpModule.register({ baseURL: '...' })
+  - HttpModule.registerAsync({ ... })
+  - CacheModule.registerAsync({ ... })
+  + HttpModule.forRoot({ baseURL: '...' })
+  + HttpModule.forRootAsync({ ... })
+  + CacheModule.forRootAsync({ ... })
+  ```
+
+- **`MetadataRegistry`, `RouteManager`, `ModuleLoader`, `ComponentManager`, `Container`, `VelaApplication` (the class), `bindAppProviders`, and the `APP_*` tokens moved to a stable internal subpath.** The public root barrel still re-exports `MetadataRegistry` (used by tests for `clear()`), but plugin authors should consume framework primitives from `/internal`:
+
+  ```diff
+  - import { RouteManager, ModuleLoader, ComponentManager } from '@velajs/vela';
+  + import { RouteManager, ModuleLoader, ComponentManager } from '@velajs/vela/internal';
+  ```
+
+- **`Test`, `TestingModule`, `TestingModuleBuilder` removed from `@velajs/vela`'s root barrel.** Use `@velajs/testing` (≥ 0.2.0) — it's the canonical home and was rewritten on top of `@velajs/vela/internal`.
+
+- **`HttpException._response` typed as `string | Record<string, unknown>`** (was `string | object`). `getResponse()` now returns `Record<string, unknown>`.
+
+- **`applyDecorators` return type** changed from the impossible-at-runtime `ClassDecorator & MethodDecorator & PropertyDecorator` intersection to a `ComposedDecorator` polymorphic shape that matches every decorator slot structurally.
+
+- **`Reflector` API takes `ExecutionContext` directly.** Was a duck-typed `{ getClass(): Constructor; getHandler(): string|symbol }` parameter; now the real type. Existing call sites that already pass an `ExecutionContext` need no change.
+
+- **Inverted peer dep removed**: `@velajs/vela` no longer declares `peerDependencies['@velajs/crud']`. Crud is the consumer; that line was reversed.
+
+### New
+
+- **`@velajs/vela/internal` subpath export.** Re-exports `MetadataRegistry`, `Container`, `ModuleRef`, `RouteManager`, `ModuleLoader`, `ComponentManager`, `VelaApplication`, `bindAppProviders`, `APP_GUARD`/`APP_PIPE`/`APP_INTERCEPTOR`/`APP_FILTER`/`APP_MIDDLEWARE`, `getModuleMetadata`, `isModule`. Stable target for plugins.
+
+### Internal cleanup
+
+- **One metadata storage.** Decorators no longer dual-write to a typed `MetadataRegistry` slot AND a parallel `WeakMap` polyfill. The `Reflect.metadata` polyfill now funnels into `MetadataRegistry.classMeta`/`handlerMeta`, which also backs `setCustomClassMeta`/`setCustomHandlerMeta` and the `appendCustomClassMeta`/`appendCustomHandlerMeta` helpers.
+- **`MetadataRegistry.clear()`** now clears only app-time global components (the only mutable run-time slot). Decoration metadata persists across `clear()`, so tests no longer need a fallback path. Use `MetadataRegistry.reset()` for a full wipe.
+- **No `!` non-null assertions** in `MetadataRegistry`. New `getOrCreate`/`getOrCreateMap`/`getOrCreateArray` helpers in `registry/util.ts`.
+- **No `as unknown as` casts** in `MetadataRegistry`. Component stores are now mapped-typed instead of union-typed.
+- **`Constructor` is now `abstract new (...args: any[]) => unknown`** (was the bare unsafe `Function`). Every decorator's `target` casts to `Constructor` consistently.
+- **Single home for shared types**: `Type`, `Token`, `Constructor`, `ProviderOptions`, `InjectableOptions`, etc. canonical in `container/types.ts`. `ModuleOptions`, `DynamicModule`, `ModuleImport`, `AsyncModuleOptions`, `ModuleMetadata` canonical in `registry/types.ts`. `module/types.ts` is a thin re-export. The `InjectionTokenLike` duck-type and the duplicated `ProviderOptions` are gone.
+- **Layering fixed**: `MiddlewareConsumer`/`MiddlewareBuilder`/`NestModule`/`RouteInfo` moved from `http/` to `module/`. `module/module-loader.ts` no longer imports from `http/`.
+- **`module-loader` `new moduleClass()` footgun fixed.** `NestModule.configure()` modules are now resolved through the container, so they can have constructor-injected deps.
+- **One path util** (`registry/paths.ts`: `normalizePath`, `joinPaths`, `toOpenApiPath`). Replaces 2× duplicated implementations in `http/decorators.ts`, `openapi/document.ts`, and `route.manager.ts`.
+- **One `ExecutionContext` factory** (`http/execution-context.ts`: `buildExecutionContext`). Replaces 2× duplicated literal construction.
+- **One `bindAppProviders` helper** (`pipeline/app-providers.ts`). Implements the NestJS APP_* provider convention in one place; replaces 5× duplicated APP_* wiring blocks across `factory.ts` and `testing.builder.ts`.
+- **One module-graph walk** (`module/graph.ts`: `collectControllers`). Replaces the duplicate implementation in `openapi/document.ts`.
+- **schedule/event-emitter/openapi decorators** now use `MetadataRegistry.appendCustomClassMeta`/`appendCustomHandlerMeta` instead of direct `Reflect.defineMetadata` calls.
+- **Stub `pnpm-workspace.yaml` and `bunfig.toml` deleted** — they only set `onlyBuiltDependencies`, which lives in `package.json#pnpm`. `bun.lock` deleted; pnpm is the source of truth.
+
 ## 0.10.0 (2026-04-28)
 
 Edge-runtime audit and AI-drift cleanup.

package/README.md

@@ -73,13 +73,47 @@ Vela runs on any runtime that supports the Web Standards API:
 
 No Node.js-specific APIs (`node:fs`, `Buffer`, `process`) are used.
 
-## CRUD Module (Optional)
+## Dynamic modules
+
+Configurable modules use `forRoot` (sync) and `forRootAsync` (DI-resolved):
+
+```ts
+@Module({
+  imports: [
+    CacheModule.forRoot({ ttl: 60 }),
+    HttpModule.forRoot({ baseURL: 'https://api.example.com' }),
+    ConfigModule.forRootAsync({
+      useFactory: async (loader: ConfigLoader) => loader.load(),
+      inject: [ConfigLoader],
+    }),
+  ],
+})
+class AppModule {}
+```
+
+## Companion packages
+
+| Package | Purpose |
+|---|---|
+| [`@velajs/cloudflare`](https://github.com/velajs/cloudflare) | Cloudflare Workers adapter — typed services for KV, D1, R2, Queues, DO, AI, Vectorize, Hyperdrive |
+| [`@velajs/crud`](https://github.com/velajs/crud) | NestJS-style CRUD controllers on top of `hono-crud` |
+| [`@velajs/testing`](https://github.com/velajs/testing) | `Test.createTestingModule()` with `overrideProvider/Guard/Pipe/Interceptor/Filter` |
 
 ```bash
+pnpm add @velajs/testing -D
+pnpm add @velajs/cloudflare @cloudflare/workers-types
 pnpm add @velajs/crud hono-crud @hono/zod-openapi zod
 ```
 
-See [`@velajs/crud`](https://github.com/velajs/crud) for documentation.
+## `/internal` subpath (for plugin authors)
+
+Framework primitives — `MetadataRegistry`, `Container`, `RouteManager`, `ModuleLoader`, `ComponentManager`, `VelaApplication`, `bindAppProviders`, `APP_*` tokens — are exposed at `@velajs/vela/internal`. This is the stable target for plugin packages that need to reach below the public API.
+
+```ts
+import { MetadataRegistry, Container } from '@velajs/vela/internal';
+```
+
+The public root barrel still exports `MetadataRegistry` (used by tests for `clear()` between cases). Everything else lives at `/internal` only.
 
 ## License
 

package/dist/cache/cache.decorators.d.ts

@@ -1,2 +1,2 @@
-export declare const CacheKey: (key: string) => (target: Function | object, propertyKey?: string | symbol) => void;
-export declare const CacheTTL: (seconds: number) => (target: Function | object, propertyKey?: string | symbol) => void;
+export declare const CacheKey: (key: string) => (target: object, propertyKey?: string | symbol) => void;
+export declare const CacheTTL: (seconds: number) => (target: object, propertyKey?: string | symbol) => void;

package/dist/cache/cache.module.d.ts

@@ -2,7 +2,7 @@ import type { AsyncModuleOptions, DynamicModule } from '../module/types';
 import type { CacheModuleOptions } from './cache.types';
 export declare class CacheModule {
     static forRoot(options?: CacheModuleOptions): DynamicModule;
-    static registerAsync(options: AsyncModuleOptions<CacheModuleOptions> & {
+    static forRootAsync(options: AsyncModuleOptions<CacheModuleOptions> & {
         isGlobal?: boolean;
     }): DynamicModule;
 }

package/dist/cache/cache.module.js

@@ -36,7 +36,7 @@ export class CacheModule {
             ]
         };
     }
-    static registerAsync(options) {
+    static forRootAsync(options) {
         const providers = [
             {
                 provide: CACHE_MODULE_OPTIONS,

package/dist/constants.d.ts

@@ -14,14 +14,14 @@ export declare const METADATA_KEYS: {
     readonly CRUD: "vela:crud";
 };
 export declare const HttpMethod: {
-    readonly GET: "get";
-    readonly POST: "post";
-    readonly PUT: "put";
-    readonly PATCH: "patch";
-    readonly DELETE: "delete";
-    readonly OPTIONS: "options";
-    readonly HEAD: "head";
-    readonly ALL: "all";
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly PATCH: "PATCH";
+    readonly DELETE: "DELETE";
+    readonly OPTIONS: "OPTIONS";
+    readonly HEAD: "HEAD";
+    readonly ALL: "ALL";
 };
 export type HttpMethod = (typeof HttpMethod)[keyof typeof HttpMethod];
 export declare const ParamType: {

package/dist/constants.js

@@ -19,14 +19,14 @@ export const METADATA_KEYS = {
     CRUD: 'vela:crud'
 };
 export const HttpMethod = {
-    GET: 'get',
-    POST: 'post',
-    PUT: 'put',
-    PATCH: 'patch',
-    DELETE: 'delete',
-    OPTIONS: 'options',
-    HEAD: 'head',
-    ALL: 'all'
+    GET: 'GET',
+    POST: 'POST',
+    PUT: 'PUT',
+    PATCH: 'PATCH',
+    DELETE: 'DELETE',
+    OPTIONS: 'OPTIONS',
+    HEAD: 'HEAD',
+    ALL: 'ALL'
 };
 export const ParamType = {
     BODY: 'body',

package/dist/container/container.js

@@ -211,10 +211,10 @@ export class Container {
         }
         return this.resolve(token);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     createLazyProxy(token) {
         const container = this;
-        return new Proxy({}, {
+        const target = Object.create(null);
+        return new Proxy(target, {
             get (_target, prop) {
                 const instance = container.resolve(token);
                 const value = instance[prop];

package/dist/container/decorators.js

@@ -1,14 +1,10 @@
-import { METADATA_KEYS, Scope } from "../constants.js";
-import { defineMetadata, getMetadata } from "../metadata.js";
+import { Scope } from "../constants.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 export function Injectable(options = {}) {
     return (target)=>{
         const { scope = Scope.SINGLETON } = options;
         MetadataRegistry.markInjectable(target);
         MetadataRegistry.setScope(target, scope);
-        // Keep WeakMap write for external package compat
-        defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
-        defineMetadata(METADATA_KEYS.SCOPE, scope, target);
     };
 }
 export function Optional() {
@@ -24,7 +20,6 @@ export function Optional() {
             });
         }
         MetadataRegistry.setInjectTokens(target, existing);
-        defineMetadata(METADATA_KEYS.INJECT, existing, target);
     };
 }
 export function Inject(token) {
@@ -40,18 +35,20 @@ export function Inject(token) {
             });
         }
         MetadataRegistry.setInjectTokens(target, existing);
-        defineMetadata(METADATA_KEYS.INJECT, existing, target);
     };
 }
 export function isInjectable(target) {
-    return MetadataRegistry.hasInjectable(target) || getMetadata(METADATA_KEYS.INJECTABLE, target) === true;
+    return MetadataRegistry.hasInjectable(target);
 }
 export function getScope(target) {
-    return MetadataRegistry.getScope(target) ?? getMetadata(METADATA_KEYS.SCOPE, target) ?? Scope.SINGLETON;
+    return MetadataRegistry.getScope(target) ?? Scope.SINGLETON;
 }
 export function getConstructorDependencies(target) {
-    return Reflect.getMetadata('design:paramtypes', target) || [];
+    // Read through Reflect so dist/src coexistence in tests routes through the
+    // single polyfill-installed registry — SWC writes `design:paramtypes` via
+    // Reflect, so reads must too.
+    return Reflect.getMetadata('design:paramtypes', target) ?? [];
 }
 export function getInjectMetadata(target) {
-    return MetadataRegistry.getInjectTokens(target) ?? getMetadata(METADATA_KEYS.INJECT, target) ?? [];
+    return MetadataRegistry.getInjectTokens(target) ?? [];
 }

package/dist/container/types.d.ts

@@ -1,5 +1,6 @@
 import type { Scope } from '../constants';
 export type Type<T = any> = new (...args: any[]) => T;
+export type Constructor<T = unknown> = abstract new (...args: any[]) => T;
 export interface InjectionTokenOptions<T> {
     factory?: () => T;
 }

package/dist/errors/http-exception.d.ts

@@ -1,61 +1,62 @@
+export type ExceptionResponse = string | Record<string, unknown>;
 export declare class HttpException extends Error {
     readonly statusCode: number;
     private readonly _response;
-    constructor(response: string | object, statusCode: number);
+    constructor(response: ExceptionResponse, statusCode: number);
     getStatus(): number;
-    getResponse(): unknown;
+    getResponse(): Record<string, unknown>;
 }
 export declare class BadRequestException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class UnauthorizedException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class ForbiddenException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class NotFoundException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class MethodNotAllowedException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class NotAcceptableException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class RequestTimeoutException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class ConflictException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class GoneException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class PayloadTooLargeException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class UnsupportedMediaTypeException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class UnprocessableEntityException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class TooManyRequestsException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class InternalServerErrorException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class NotImplementedException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class BadGatewayException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class ServiceUnavailableException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }
 export declare class GatewayTimeoutException extends HttpException {
-    constructor(message?: string | object);
+    constructor(message?: ExceptionResponse);
 }

package/dist/errors/http-exception.js

@@ -13,13 +13,13 @@ export class HttpException extends Error {
         return this.statusCode;
     }
     getResponse() {
-        if (typeof this._response === 'object' && this._response !== null) {
-            return this._response;
+        if (typeof this._response === 'string') {
+            return {
+                statusCode: this.statusCode,
+                message: this._response
+            };
         }
-        return {
-            statusCode: this.statusCode,
-            message: this._response
-        };
+        return this._response;
     }
 }
 // 4xx

package/dist/event-emitter/event-emitter.decorators.js

@@ -1,11 +1,10 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
 export function OnEvent(event) {
     return (target, propertyKey)=>{
-        const existing = Reflect.getMetadata(ON_EVENT_METADATA, target.constructor) ?? [];
-        existing.push({
+        MetadataRegistry.appendCustomClassMeta(target.constructor, ON_EVENT_METADATA, {
             event,
             methodName: String(propertyKey)
         });
-        Reflect.defineMetadata(ON_EVENT_METADATA, existing, target.constructor);
     };
 }

package/dist/event-emitter/event-emitter.subscriber.js

@@ -14,6 +14,7 @@ function _ts_param(paramIndex, decorator) {
 }
 import { Injectable, Inject } from "../container/index.js";
 import { Container } from "../container/container.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { EventEmitter } from "./event-emitter.service.js";
 import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
 export class EventEmitterSubscriber {
@@ -28,7 +29,7 @@ export class EventEmitterSubscriber {
         for (const token of tokens){
             // Skip non-class tokens
             if (typeof token !== 'function') continue;
-            const metadata = Reflect.getMetadata(ON_EVENT_METADATA, token);
+            const metadata = MetadataRegistry.getCustomClassMeta(token, ON_EVENT_METADATA);
             if (!metadata || metadata.length === 0) continue;
             let instance;
             try {

package/dist/factory.d.ts

@@ -4,4 +4,3 @@ import type { RouteManagerOptions } from './http/route.manager';
 export declare const VelaFactory: {
     create(rootModule: Type, options?: RouteManagerOptions): Promise<VelaApplication>;
 };
-export declare const createApplication: typeof VelaFactory.create;

package/dist/factory.js

@@ -1,10 +1,10 @@
 import { VelaApplication } from "./application.js";
 import { Container } from "./container/container.js";
 import { ModuleRef } from "./container/module-ref.js";
+import { bindAppProviders } from "./pipeline/app-providers.js";
 import { RouteManager } from "./http/route.manager.js";
 import { ModuleLoader } from "./module/module-loader.js";
 import { ComponentManager } from "./pipeline/component.manager.js";
-import { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/tokens.js";
 export const VelaFactory = {
     async create (rootModule, options = {}) {
         const container = new Container();
@@ -23,36 +23,7 @@ export const VelaFactory = {
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
         loader.load(rootModule);
-        const appGuards = loader.getAppProviderTokens(APP_GUARD);
-        if (appGuards.length > 0) {
-            routeManager.useGlobalGuardTokens(...appGuards);
-        } else if (container.has(APP_GUARD)) {
-            routeManager.useGlobalGuardTokens(APP_GUARD);
-        }
-        const appPipes = loader.getAppProviderTokens(APP_PIPE);
-        if (appPipes.length > 0) {
-            routeManager.useGlobalPipeTokens(...appPipes);
-        } else if (container.has(APP_PIPE)) {
-            routeManager.useGlobalPipeTokens(APP_PIPE);
-        }
-        const appInterceptors = loader.getAppProviderTokens(APP_INTERCEPTOR);
-        if (appInterceptors.length > 0) {
-            routeManager.useGlobalInterceptorTokens(...appInterceptors);
-        } else if (container.has(APP_INTERCEPTOR)) {
-            routeManager.useGlobalInterceptorTokens(APP_INTERCEPTOR);
-        }
-        const appFilters = loader.getAppProviderTokens(APP_FILTER);
-        if (appFilters.length > 0) {
-            routeManager.useGlobalFilterTokens(...appFilters);
-        } else if (container.has(APP_FILTER)) {
-            routeManager.useGlobalFilterTokens(APP_FILTER);
-        }
-        const appMiddleware = loader.getAppProviderTokens(APP_MIDDLEWARE);
-        if (appMiddleware.length > 0) {
-            routeManager.useGlobalMiddlewareTokens(...appMiddleware);
-        } else if (container.has(APP_MIDDLEWARE)) {
-            routeManager.useGlobalMiddlewareTokens(APP_MIDDLEWARE);
-        }
+        bindAppProviders(routeManager, container, loader);
         routeManager.registerConsumerMiddleware(loader.getConsumerMiddlewareDefinitions());
         if (options.globalPrefix) {
             routeManager.setGlobalPrefix(options.globalPrefix);
@@ -73,4 +44,3 @@ export const VelaFactory = {
         return app;
     }
 };
-export const createApplication = VelaFactory.create.bind(VelaFactory);

package/dist/fetch/fetch.module.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncModuleOptions, DynamicModule } from '../module/types';
 import type { HttpModuleOptions } from './fetch.types';
 export declare class HttpModule {
-    static register(options?: HttpModuleOptions): DynamicModule;
-    static registerAsync(options: AsyncModuleOptions<HttpModuleOptions>): DynamicModule;
+    static forRoot(options?: HttpModuleOptions): DynamicModule;
+    static forRootAsync(options: AsyncModuleOptions<HttpModuleOptions>): DynamicModule;
 }

package/dist/fetch/fetch.module.js

@@ -8,7 +8,7 @@ import { createModuleRef } from "../module/decorators.js";
 import { Module } from "../module/decorators.js";
 import { HttpService, HTTP_MODULE_OPTIONS } from "./fetch.service.js";
 export class HttpModule {
-    static register(options = {}) {
+    static forRoot(options = {}) {
         return {
             module: createModuleRef('HttpModule'),
             providers: [
@@ -24,7 +24,7 @@ export class HttpModule {
             ]
         };
     }
-    static registerAsync(options) {
+    static forRootAsync(options) {
         return {
             module: createModuleRef('HttpModule'),
             imports: options.imports ?? [],

package/dist/health/health.service.js

@@ -19,7 +19,9 @@ export class HealthCheckService {
                 error: {},
                 details: {}
             };
-            throw new ServiceUnavailableException(result);
+            throw new ServiceUnavailableException({
+                ...result
+            });
         }
         const results = await Promise.allSettled(indicators.map((fn)=>fn()));
         const info = {};
@@ -55,7 +57,9 @@ export class HealthCheckService {
             details
         };
         if (status === 'error') {
-            throw new ServiceUnavailableException(checkResult);
+            throw new ServiceUnavailableException({
+                ...checkResult
+            });
         }
         return checkResult;
     }

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;