@velajs/vela 1.10.0 → 1.12.0

package/dist/pipeline/component.manager.js

@@ -1,18 +1,18 @@
 import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { PipelineRunner } from "./pipeline-runner.js";
 function isObject(value) {
     return typeof value === 'object' && value !== null;
 }
-export class ComponentManager {
-    static container;
-    static init(container) {
-        this.container = container;
-    }
-    // 3-level registration
-    static registerGlobal(type, ...components) {
-        for (const component of components){
-            MetadataRegistry.registerGlobal(type, component);
-        }
-    }
+/**
+ * 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.
+ */ export class ComponentManager {
+    // Scoped registration: controller → handler
     static registerController(type, controller, ...components) {
         for (const component of components){
             MetadataRegistry.registerController(type, controller, component);
@@ -23,34 +23,32 @@ export class ComponentManager {
             MetadataRegistry.registerHandler(type, controller, handlerName, component);
         }
     }
-    // 3-level resolution: global → controller → handler
-    static getComponents(type, controller, handlerName) {
-        const controllerComponents = MetadataRegistry.getController(type, controller);
-        const handlerComponents = MetadataRegistry.getHandler(type, controller, handlerName);
+    // Scoped resolution: controller → handler. App-wide components come from
+    // RouteManager (APP_* tokens + useGlobalX()) — merged by the caller.
+    static getScopedComponents(type, controller, handlerName) {
         return [
-            ...MetadataRegistry.getGlobal(type),
-            ...controllerComponents,
-            ...handlerComponents
+            ...MetadataRegistry.getController(type, controller),
+            ...MetadataRegistry.getHandler(type, controller, handlerName)
         ];
     }
-    // Type-specific resolvers
-    static resolveAll(items, methodKey) {
-        return items.map((item)=>isObject(item) && methodKey in item ? item : this.container.resolve(item));
+    // Type-specific resolvers — explicit container, always.
+    static resolveAll(items, methodKey, container) {
+        return items.map((item)=>isObject(item) && methodKey in item ? item : container.resolve(item));
     }
-    static resolveMiddleware(items) {
-        return this.resolveAll(items, 'use');
+    static resolveMiddleware(items, container) {
+        return this.resolveAll(items, 'use', container);
     }
-    static resolveGuards(items) {
-        return this.resolveAll(items, 'canActivate');
+    static resolveGuards(items, container) {
+        return this.resolveAll(items, 'canActivate', container);
     }
-    static resolvePipes(items) {
-        return this.resolveAll(items, 'transform');
+    static resolvePipes(items, container) {
+        return this.resolveAll(items, 'transform', container);
     }
-    static resolveInterceptors(items) {
-        return this.resolveAll(items, 'intercept');
+    static resolveInterceptors(items, container) {
+        return this.resolveAll(items, 'intercept', container);
     }
-    static resolveFilters(items) {
-        return this.resolveAll(items, 'catch');
+    static resolveFilters(items, container) {
+        return this.resolveAll(items, 'catch', container);
     }
     // Pipe execution
     static async executePipes(value, metadata, pipes) {
@@ -60,21 +58,9 @@ export class ComponentManager {
         }
         return transformed;
     }
-    // Interceptor chain (onion pattern)
+    // Interceptor chain (onion pattern) — canonical implementation lives in
+    // PipelineRunner; kept here as a stable alias.
     static async runInterceptorChain(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();
+        return PipelineRunner.chainInterceptors(interceptors, context, coreHandler);
     }
 }

package/dist/pipeline/index.d.ts

@@ -1,4 +1,6 @@
 export { ComponentManager } from './component.manager';
+export { PipelineRunner } from './pipeline-runner';
+export type { PipelineRunOptions } from './pipeline-runner';
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, getCatchTypes, shouldFilterCatch, } from './decorators';
 export { SetMetadata, Reflector } from './reflector';
 export type { ReflectableDecorator, CreateDecoratorOptions } from './reflector';

package/dist/pipeline/index.js

@@ -1,4 +1,5 @@
 export { ComponentManager } from "./component.manager.js";
+export { PipelineRunner } from "./pipeline-runner.js";
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, getCatchTypes, shouldFilterCatch } from "./decorators.js";
 export { SetMetadata, Reflector } from "./reflector.js";
 export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./tokens.js";

package/dist/pipeline/pipeline-runner.d.ts

@@ -0,0 +1,31 @@
+import type { CanActivate, ExecutionContext, NestInterceptor } from './types';
+export interface PipelineRunOptions {
+    context: ExecutionContext;
+    /** Pre-merged (global ++ scoped), pre-instantiated. */
+    guards: CanActivate[];
+    interceptors: NestInterceptor[];
+    /** Extract handler arguments (pipes already bound inside the closure). */
+    resolveArgs: () => Promise<unknown[]>;
+    /** Call the actual handler. */
+    invoke: (args: unknown[]) => Promise<unknown>;
+    /**
+     * HTTP runs argument extraction + pipes BEFORE guards (a deliberate vela
+     * deviation — see handler-executor); WebSocket runs guards first. Default
+     * false (guards first).
+     */
+    argsBeforeGuards?: boolean;
+    /** Error thrown when a guard rejects (default `ForbiddenException`). */
+    onGuardReject?: () => Error;
+}
+/**
+ * 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).
+ */
+export declare class PipelineRunner {
+    static run(options: PipelineRunOptions): Promise<unknown>;
+    /** Interceptor onion — innermost is the core handler. */
+    static chainInterceptors(interceptors: NestInterceptor[], context: ExecutionContext, coreHandler: () => Promise<unknown>): Promise<unknown>;
+}

package/dist/pipeline/pipeline-runner.js

@@ -0,0 +1,40 @@
+import { ForbiddenException } from "../errors/http-exception.js";
+/**
+ * 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).
+ */ export class PipelineRunner {
+    static async run(options) {
+        let args;
+        if (options.argsBeforeGuards) {
+            args = await options.resolveArgs();
+        }
+        for (const guard of options.guards){
+            const canActivate = await guard.canActivate(options.context);
+            if (!canActivate) {
+                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();
+    }
+}

package/dist/registry/metadata.registry.d.ts

@@ -18,9 +18,10 @@ export declare class MetadataRegistry {
     private static get routeVersions();
     private static get classMeta();
     private static get handlerMeta();
+    private static get classMetaIndex();
+    private static get handlerMetaIndex();
     private static get controllerComponents();
     private static get handlerComponents();
-    private static get globalComponents();
     static getRoutes(controller: Constructor): RouteDefinition[];
     static addRoute(controller: Constructor, route: RouteDefinition): void;
     static getControllerPath(controller: Constructor): string;
@@ -31,8 +32,6 @@ export declare class MetadataRegistry {
     static setModuleOptions(module: Constructor, options: ModuleOptions): void;
     static getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]>;
     static addParameter(controller: Constructor, methodName: string | symbol, param: ParameterMetadata): void;
-    static registerGlobal<T extends ComponentType>(type: T, component: ComponentTypeMap[T]): void;
-    static getGlobal<T extends ComponentType>(type: T): Set<ComponentTypeMap[T]>;
     static registerController<T extends ComponentType>(type: T, controller: Constructor, component: ComponentTypeMap[T]): void;
     static getController<T extends ComponentType>(type: T, controller: Constructor): ComponentTypeMap[T][];
     static registerHandler<T extends ComponentType>(type: T, controller: Constructor, methodName: string | symbol, component: ComponentTypeMap[T]): void;
@@ -58,6 +57,13 @@ export declare class MetadataRegistry {
     static getCustomHandlerMetaAll(target: object, handler: string | symbol): Map<string, unknown> | undefined;
     static appendCustomClassMeta<T>(target: object, key: string, item: T): void;
     static appendCustomHandlerMeta<T>(target: object, handler: string | symbol, key: string, item: T): void;
+    static getClassesWithClassMeta(key: string): ReadonlySet<object>;
+    static getClassesWithHandlerMeta(key: string): ReadonlySet<object>;
+    /** Every (handler, value) pair on `target` carrying metadata under `key`. */
+    static getHandlersWithMeta(target: object, key: string): Array<{
+        handler: string | symbol;
+        value: unknown;
+    }>;
     static setReflectMetadata(target: object, key: string, value: unknown, propertyKey?: string | symbol): void;
     static getReflectMetadata<T = unknown>(target: object, key: string, propertyKey?: string | symbol): T | undefined;
     static getParamTypes(target: object, propertyKey?: string | symbol): unknown[] | undefined;

package/dist/registry/metadata.registry.js

@@ -1,13 +1,4 @@
 import { getOrCreate, getOrCreateArray, getOrCreateMap } from "./util.js";
-function emptyComponentStore() {
-    return {
-        middleware: new Set(),
-        guard: new Set(),
-        pipe: new Set(),
-        interceptor: new Set(),
-        filter: new Set()
-    };
-}
 function emptyComponentByOwner() {
     return {
         middleware: new Map(),
@@ -32,6 +23,8 @@ function createRegistryState() {
         routeVersions: new Map(),
         classMeta: new Map(),
         handlerMeta: new Map(),
+        classMetaIndex: new Map(),
+        handlerMetaIndex: new Map(),
         controllerComponents: emptyComponentByOwner(),
         handlerComponents: {
             middleware: new Map(),
@@ -39,8 +32,7 @@ function createRegistryState() {
             pipe: new Map(),
             interceptor: new Map(),
             filter: new Map()
-        },
-        globalComponents: emptyComponentStore()
+        }
     };
 }
 // HMR-safe: anchor ALL backing state on `globalThis` so a Vite dev re-eval of
@@ -50,9 +42,17 @@ function createRegistryState() {
 // versioned symbol avoids collisions across framework major versions in one
 // process. `globalThis` + `Symbol.for` exist on every target runtime; no node:*.
 const REGISTRY_STATE_KEY = Symbol.for('vela:registry:v1');
+// Shared empty result for index misses — avoids allocating per lookup.
+const EMPTY_TARGET_SET = new Set();
 function registryState() {
     const g = globalThis;
-    return g[REGISTRY_STATE_KEY] ??= createRegistryState();
+    const state = g[REGISTRY_STATE_KEY] ??= createRegistryState();
+    // Backfill fields added after the v1 state shape was first anchored: a state
+    // created by an older copy of this module (dist/src coexistence in tests,
+    // mixed package versions in one process) must not crash newer readers.
+    state.classMetaIndex ??= new Map();
+    state.handlerMetaIndex ??= new Map();
+    return state;
 }
 export class MetadataRegistry {
     // Every field is a getter over the globalThis-anchored state (registryState).
@@ -97,15 +97,18 @@ export class MetadataRegistry {
     static get handlerMeta() {
         return registryState().handlerMeta;
     }
+    static get classMetaIndex() {
+        return registryState().classMetaIndex;
+    }
+    static get handlerMetaIndex() {
+        return registryState().handlerMetaIndex;
+    }
     static get controllerComponents() {
         return registryState().controllerComponents;
     }
     static get handlerComponents() {
         return registryState().handlerComponents;
     }
-    static get globalComponents() {
-        return registryState().globalComponents;
-    }
     // Routes
     static getRoutes(controller) {
         return this.routes.get(controller) ?? [];
@@ -141,14 +144,9 @@ export class MetadataRegistry {
         const methodMap = getOrCreateMap(this.parameters, controller);
         getOrCreateArray(methodMap, methodName).push(param);
     }
-    // Component registration — global
-    static registerGlobal(type, component) {
-        this.globalComponents[type].add(component);
-    }
-    static getGlobal(type) {
-        return this.globalComponents[type];
-    }
-    // Component registration — controller-level
+    // Component registration — controller-level. (There is deliberately NO
+    // global tier here: app-wide components live on the per-app RouteManager,
+    // one source, never process-global state.)
     static registerController(type, controller, component) {
         const map = this.controllerComponents[type];
         getOrCreateArray(map, controller).push(component);
@@ -228,6 +226,9 @@ export class MetadataRegistry {
     // external Reflect.defineMetadata calls — one model, one source of truth.
     static setCustomClassMeta(target, key, value) {
         getOrCreate(this.classMeta, target, ()=>new Map()).set(key, value);
+        if (!key.startsWith('design:')) {
+            getOrCreate(this.classMetaIndex, key, ()=>new Set()).add(target);
+        }
     }
     static getCustomClassMeta(target, key) {
         return this.classMeta.get(target)?.get(key);
@@ -238,6 +239,9 @@ export class MetadataRegistry {
     static setCustomHandlerMeta(target, handler, key, value) {
         const byHandler = getOrCreate(this.handlerMeta, target, ()=>new Map());
         getOrCreate(byHandler, handler, ()=>new Map()).set(key, value);
+        if (!key.startsWith('design:')) {
+            getOrCreate(this.handlerMetaIndex, key, ()=>new Set()).add(target);
+        }
     }
     static getCustomHandlerMeta(target, handler, key) {
         return this.handlerMeta.get(target)?.get(handler)?.get(key);
@@ -256,6 +260,28 @@ export class MetadataRegistry {
         list.push(item);
         this.setCustomHandlerMeta(target, handler, key, list);
     }
+    // Reverse-index readers — the DiscoveryService seam. Return the constructors
+    // known to carry class-level (resp. handler-level) metadata under `key`.
+    // Callers must still intersect with container-registered tokens: decoration
+    // alone does not make a class a provider.
+    static getClassesWithClassMeta(key) {
+        return this.classMetaIndex.get(key) ?? EMPTY_TARGET_SET;
+    }
+    static getClassesWithHandlerMeta(key) {
+        return this.handlerMetaIndex.get(key) ?? EMPTY_TARGET_SET;
+    }
+    /** Every (handler, value) pair on `target` carrying metadata under `key`. */ static getHandlersWithMeta(target, key) {
+        const byHandler = this.handlerMeta.get(target);
+        if (!byHandler) return [];
+        const out = [];
+        for (const [handler, metaMap] of byHandler){
+            if (metaMap.has(key)) out.push({
+                handler,
+                value: metaMap.get(key)
+            });
+        }
+        return out;
+    }
     // Reflect-style API — same storage as the typed setters above. Lets external
     // code (and the SWC shim's Reflect.metadata polyfill) write/read uniformly.
     static setReflectMetadata(target, key, value, propertyKey) {
@@ -294,8 +320,11 @@ export class MetadataRegistry {
     }
     // Clear app-time state. Decoration metadata persists — once a class is
     // decorated, that fact is permanent for the lifetime of the process.
+    // Currently a no-op: the last piece of app-time registry state (the global
+    // component tier) moved to the per-app RouteManager. Kept because test
+    // suites call it between cases and future app-time state belongs here.
     static clear() {
-        registryState().globalComponents = emptyComponentStore();
+    // no app-time state to clear
     }
     // Full reset, including decoration metadata. Used in framework-internal scenarios.
     static reset() {
@@ -312,6 +341,8 @@ export class MetadataRegistry {
         this.routeVersions.clear();
         this.classMeta.clear();
         this.handlerMeta.clear();
+        this.classMetaIndex.clear();
+        this.handlerMetaIndex.clear();
         for (const type of [
             'middleware',
             'guard',
@@ -322,6 +353,5 @@ export class MetadataRegistry {
             this.controllerComponents[type].clear();
             this.handlerComponents[type].clear();
         }
-        registryState().globalComponents = emptyComponentStore();
     }
 }

package/dist/schedule/schedule.module.d.ts

@@ -1,4 +1,9 @@
 import type { DynamicModule } from '../module/types';
+/**
+ * Zero-config module (Tier C): providers live on the `@Module` bag; the
+ * `forRoot()` static is NestJS-parity sugar returning the bare dynamic module
+ * (default key — repeated calls dedup).
+ */
 export declare class ScheduleModule {
     static forRoot(): DynamicModule;
 }

package/dist/schedule/schedule.module.js

@@ -1,15 +1,25 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/decorators.js";
 import { ScheduleRegistry } from "./schedule.registry.js";
 export class ScheduleModule {
     static forRoot() {
-        const providers = [
-            ScheduleRegistry
-        ];
         return {
-            module: ScheduleModule,
-            providers,
-            exports: [
-                ScheduleRegistry
-            ]
+            module: ScheduleModule
         };
     }
 }
+ScheduleModule = _ts_decorate([
+    Module({
+        providers: [
+            ScheduleRegistry
+        ],
+        exports: [
+            ScheduleRegistry
+        ]
+    })
+], ScheduleModule);

package/dist/schedule/schedule.registry.d.ts

@@ -1,4 +1,4 @@
-import { Container } from '../container/container';
+import { DiscoveryService } from '../discovery/discovery.service';
 import type { OnApplicationBootstrap } from '../lifecycle/index';
 export interface RegisteredCronJob {
     expression: string;
@@ -13,10 +13,10 @@ export interface RegisteredIntervalJob {
     target: Function;
 }
 export declare class ScheduleRegistry implements OnApplicationBootstrap {
-    private container;
+    private readonly discovery;
     private cronJobs;
     private intervalJobs;
-    constructor(container: Container);
+    constructor(discovery: DiscoveryService);
     onApplicationBootstrap(): void;
     getCronJobs(): RegisteredCronJob[];
     getIntervalJobs(): RegisteredIntervalJob[];

package/dist/schedule/schedule.registry.js

@@ -13,54 +13,33 @@ 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 { DiscoveryService } from "../discovery/discovery.service.js";
 import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
 export class ScheduleRegistry {
-    container;
+    discovery;
     cronJobs = [];
     intervalJobs = [];
-    constructor(container){
-        this.container = container;
+    constructor(discovery){
+        this.discovery = discovery;
     }
     onApplicationBootstrap() {
-        const tokens = this.container.getTokens();
-        for (const token of tokens){
-            if (typeof token !== 'function') continue;
-            const cronMeta = MetadataRegistry.getCustomClassMeta(token, CRON_METADATA);
-            const intervalMeta = MetadataRegistry.getCustomClassMeta(token, INTERVAL_METADATA);
-            if (!cronMeta && !intervalMeta) continue;
-            let instance;
-            try {
-                instance = this.container.resolve(token);
-            } catch (err) {
-                const mode = this.container.getDiagnostics();
-                if (mode === 'throw') throw err;
-                if (mode === 'log') {
-                    console.warn(`[vela] schedule discovery: cannot resolve ${token.name || String(token)}:`, err);
-                }
-                continue;
-            }
-            if (cronMeta) {
-                for (const { expression, methodName } of cronMeta){
-                    this.cronJobs.push({
-                        expression,
-                        methodName,
-                        instance,
-                        target: token
-                    });
-                }
-            }
-            if (intervalMeta) {
-                for (const { ms, methodName } of intervalMeta){
-                    this.intervalJobs.push({
-                        ms,
-                        methodName,
-                        instance,
-                        target: token
-                    });
-                }
-            }
+        for (const found of this.discovery.methodsWithMeta(CRON_METADATA)){
+            if (!found.class.instance) continue;
+            this.cronJobs.push({
+                expression: found.meta.expression,
+                methodName: String(found.methodName),
+                instance: found.class.instance,
+                target: found.class.metatype
+            });
+        }
+        for (const found of this.discovery.methodsWithMeta(INTERVAL_METADATA)){
+            if (!found.class.instance) continue;
+            this.intervalJobs.push({
+                ms: found.meta.ms,
+                methodName: String(found.methodName),
+                instance: found.class.instance,
+                target: found.class.metatype
+            });
         }
     }
     getCronJobs() {
@@ -76,9 +55,9 @@ export class ScheduleRegistry {
 }
 ScheduleRegistry = _ts_decorate([
     Injectable(),
-    _ts_param(0, Inject(Container)),
+    _ts_param(0, Inject(DiscoveryService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof Container === "undefined" ? Object : Container
+        typeof DiscoveryService === "undefined" ? Object : DiscoveryService
     ])
 ], ScheduleRegistry);

package/dist/schedule-node/schedule-node.module.d.ts

@@ -1,4 +1,9 @@
 import type { DynamicModule } from '../module/types';
+/**
+ * Zero-config module (Tier C): providers live on the `@Module` bag; the
+ * `forRoot()` static is NestJS-parity sugar returning the bare dynamic module
+ * (default key — repeated calls dedup).
+ */
 export declare class ScheduleNodeModule {
     static forRoot(): DynamicModule;
 }

package/dist/schedule-node/schedule-node.module.js

@@ -1,18 +1,28 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/decorators.js";
 import { ScheduleRegistry } from "../schedule/schedule.registry.js";
 import { ScheduleExecutor } from "./schedule.executor.js";
 export class ScheduleNodeModule {
     static forRoot() {
-        const providers = [
-            ScheduleRegistry,
-            ScheduleExecutor
-        ];
         return {
-            module: ScheduleNodeModule,
-            providers,
-            exports: [
-                ScheduleRegistry,
-                ScheduleExecutor
-            ]
+            module: ScheduleNodeModule
         };
     }
 }
+ScheduleNodeModule = _ts_decorate([
+    Module({
+        providers: [
+            ScheduleRegistry,
+            ScheduleExecutor
+        ],
+        exports: [
+            ScheduleRegistry,
+            ScheduleExecutor
+        ]
+    })
+], ScheduleNodeModule);

package/dist/seeder/seeder.module.d.ts

@@ -1,18 +1,16 @@
 import type { VelaApplication } from '../application';
-import type { DynamicModule } from '../module/types';
 import type { Type } from '../container/types';
 import type { SeederResult } from './seeder.types';
-export declare class SeederModule {
-    /**
-     * Register seeder classes as providers so they're discovered at bootstrap.
-     * (Seeders declared in other modules' providers are also discovered — this is
-     * just a convenience to co-locate them.)
-     */
-    static forRoot(options?: {
-        seeders?: Type[];
-    }): DynamicModule;
+export interface SeederModuleOptions {
+    seeders?: Type[];
+}
+declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<SeederModuleOptions, "forRoot", "create", {
+    isGlobal?: boolean;
+}>;
+export declare class SeederModule extends ConfigurableModuleClass {
 }
 /** Convenience runner: resolve the registry from a built app and run all seeders. */
 export declare function runSeeders(app: VelaApplication, options?: {
     stopOnError?: boolean;
 }): Promise<SeederResult[]>;
+export {};