@velajs/vela 1.10.0 → 1.13.0

package/dist/openapi/document.js

@@ -1,5 +1,5 @@
-import { METADATA_KEYS, ParamType } from "../constants.js";
-import { getCrudBridge } from "../http/crud-bridge.js";
+import { ParamType } from "../constants.js";
+import { getRouteContributors } from "../http/route-contributor.js";
 import { getMetadata } from "../metadata.js";
 import { collectControllers } from "../module/graph.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
@@ -215,25 +215,26 @@ export function createOpenApiDocument(rootModule, options = {}) {
             paths[pathString] = pathItem;
         }
     }
-    // Second pass: include `@Crud()`-generated routes via the registered
-    // CrudBridge. The bridge knows how to turn its own metadata config into
-    // OpenAPI path items; this loop is silent when no bridge is registered or
-    // no controller carries `vela:crud` metadata, so consumers without
-    // `@velajs/crud` see no behavioral change.
-    const bridge = getCrudBridge();
-    if (bridge) {
+    // Second pass: include contributor-generated routes (e.g. `@Crud()` via
+    // `@velajs/crud`'s registered RouteContributor). Silent when no contributor
+    // is registered or no controller carries claiming metadata, so consumers
+    // without contributor packages see no behavioral change.
+    for (const contributor of getRouteContributors()){
+        if (!contributor.buildOpenApiPaths) continue;
         for (const controller of controllers){
-            const crudConfig = getMetadata(METADATA_KEYS.CRUD, controller);
-            if (!crudConfig) continue;
+            const meta = getMetadata(contributor.claimsMetaKey, controller);
+            if (meta === undefined) continue;
             const controllerPrefix = MetadataRegistry.getControllerPath(controller);
-            const crudPaths = bridge.buildOpenApiPaths(controller, crudConfig, {
+            const contributedPaths = contributor.buildOpenApiPaths({
+                controller: controller,
+                meta,
                 globalPrefix,
                 controllerPrefix
             });
-            for (const [pathKey, pathItem] of Object.entries(crudPaths)){
+            for (const [pathKey, pathItem] of Object.entries(contributedPaths)){
                 // Verb-level merge: a hand-written `@Get('/')` on the same controller
-                // is preserved when the bridge contributes `post`/`patch`/etc. on
-                // the same path key.
+                // is preserved when the contributor adds `post`/`patch`/etc. on the
+                // same path key.
                 paths[pathKey] = {
                     ...paths[pathKey] ?? {},
                     ...pathItem

package/dist/pipeline/component.manager.d.ts

@@ -1,19 +1,25 @@
 import type { Container } from '../container/container';
 import type { ComponentType, ComponentTypeMap, Constructor, FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
 import type { ArgumentMetadata, CanActivate, ExceptionFilter, ExecutionContext, NestInterceptor, NestMiddleware, PipeTransform } from './types';
+/**
+ * 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 declare class ComponentManager {
-    private static container;
-    static init(container: Container): void;
-    static registerGlobal<T extends ComponentType>(type: T, ...components: ComponentTypeMap[T][]): void;
     static registerController<T extends ComponentType>(type: T, controller: Constructor, ...components: ComponentTypeMap[T][]): void;
     static registerHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol, ...components: ComponentTypeMap[T][]): void;
-    static getComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
+    static getScopedComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
     private static resolveAll;
-    static resolveMiddleware(items: MiddlewareType[]): NestMiddleware[];
-    static resolveGuards(items: GuardType[]): CanActivate[];
-    static resolvePipes(items: PipeType[]): PipeTransform[];
-    static resolveInterceptors(items: InterceptorType[]): NestInterceptor[];
-    static resolveFilters(items: FilterType[]): ExceptionFilter[];
+    static resolveMiddleware(items: MiddlewareType[], container: Container): NestMiddleware[];
+    static resolveGuards(items: GuardType[], container: Container): CanActivate[];
+    static resolvePipes(items: PipeType[], container: Container): PipeTransform[];
+    static resolveInterceptors(items: InterceptorType[], container: Container): NestInterceptor[];
+    static resolveFilters(items: FilterType[], container: Container): ExceptionFilter[];
     static executePipes(value: unknown, metadata: ArgumentMetadata, pipes: PipeTransform[]): Promise<unknown>;
     static runInterceptorChain(interceptors: NestInterceptor[], context: ExecutionContext, coreHandler: () => Promise<unknown>): Promise<unknown>;
 }

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/registry/types.d.ts

@@ -81,6 +81,13 @@ export interface DynamicModule {
     controllers?: Type[];
     exports?: Array<Type | InjectionToken>;
     global?: boolean;
+    /**
+     * Defer this module instance's providers/controllers to first use: nothing
+     * constructs at bootstrap; the first resolution of any of its tokens
+     * materializes the whole group and replays its lifecycle hooks (memoized).
+     * See MODULE_AUTHORING.md "Lazy modules" for the contract.
+     */
+    lazy?: boolean;
 }
 export interface ModuleOptions {
     providers?: Array<Type | ProviderOptions>;
@@ -88,6 +95,8 @@ export interface ModuleOptions {
     imports?: ModuleImport[];
     exports?: Array<Type | InjectionToken>;
     isGlobal?: boolean;
+    /** Defer to first use (see {@link DynamicModule.lazy}). */
+    lazy?: boolean;
 }
 export interface ModuleMetadata {
     providers: Array<Type | ProviderOptions>;
@@ -95,4 +104,5 @@ export interface ModuleMetadata {
     imports: ModuleImport[];
     exports: Array<Type | InjectionToken>;
     isGlobal: boolean;
+    lazy: boolean;
 }

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,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.registry.js";
 export class ScheduleModule {
     static forRoot() {
-        const providers = [
-            ScheduleRegistry
-        ];
         return {
-            module: ScheduleModule,
-            providers,
-            exports: [
-                ScheduleRegistry
-            ]
+            module: ScheduleModule
         };
     }
 }
+ScheduleModule = _ts_decorate([
+    Module({
+        // Lazy: the @Cron/@Interval discovery pass runs when ScheduleRegistry is
+        // first resolved (executor bootstrap, introspection, first dispatch).
+        lazy: true,
+        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[];