@velajs/vela 1.10.0 → 1.13.0

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 {};

package/dist/seeder/seeder.module.js

@@ -5,28 +5,32 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { Module } from "../module/decorators.js";
+import { defineModule } from "../module/define-module.js";
 import { stableHash } from "../module/stable-hash.js";
 import { SeederRegistry } from "./seeder.registry.js";
-export 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 = {}) {
-        const seeders = options.seeders ?? [];
-        return {
-            module: SeederModule,
-            key: stableHash({
-                seeders: seeders.map((s)=>s.name)
-            }),
+const { ConfigurableModuleClass } = defineModule({
+    name: 'Seeder',
+    // Class references aren't value-hashable — key on the seeder names, the same
+    // identity the hand-rolled forRoot used.
+    key: (options)=>stableHash({
+            seeders: (options.seeders ?? []).map((s)=>s.name)
+        }),
+    setup: ({ options })=>({
+            // 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.)
             providers: [
-                ...seeders
+                ...options.seeders ?? []
             ]
-        };
-    }
+        })
+});
+export class SeederModule extends ConfigurableModuleClass {
 }
 SeederModule = _ts_decorate([
     Module({
+        // Lazy: the @Seeder metadata scan runs when SeederRegistry is first
+        // resolved (runSeeders) — hook replay repopulates it correctly.
+        lazy: true,
         providers: [
             SeederRegistry
         ],

package/dist/websocket/index.d.ts

@@ -1,7 +1,7 @@
 export { WebSocketGateway, SubscribeMessage, MessageBody, ConnectedSocket, WebSocketServer, } from './websocket.decorators';
 export { WebSocketModule } from './websocket.module';
 export type { WebSocketModuleOptions } from './websocket.module';
-export { WsDispatcher } from './ws-dispatcher';
+export { WsDispatcher, type WsEntrypointMeta } from './ws-dispatcher';
 export { WsServerImpl, BroadcastOperatorImpl } from './ws-server';
 export { InMemoryRoomRegistry, local } from './ws-sync';
 export type { SyncDriver, RoomRegistry } from './ws-sync';

package/dist/websocket/index.js

@@ -2,7 +2,7 @@
 export { WebSocketGateway, SubscribeMessage, MessageBody, ConnectedSocket, WebSocketServer } from "./websocket.decorators.js";
 // Module
 export { WebSocketModule } from "./websocket.module.js";
-// Dispatcher (injected/called by transports)
+// Dispatcher (injected/called by transports) + the 'websocket' entrypoint meta
 export { WsDispatcher } from "./ws-dispatcher.js";
 // Server handle + rooms + sync
 export { WsServerImpl, BroadcastOperatorImpl } from "./ws-server.js";

package/dist/websocket/websocket.module.d.ts

@@ -1,4 +1,3 @@
-import type { DynamicModule } from '../module/types';
 import { type RoomRegistry, type SyncDriver } from './ws-sync';
 export interface WebSocketModuleOptions {
     /**
@@ -13,6 +12,24 @@ export interface WebSocketModuleOptions {
      */
     registry?: RoomRegistry;
 }
-export declare class WebSocketModule {
-    static forRoot(options?: WebSocketModuleOptions): DynamicModule;
+/**
+ * Registers the WebSocket gateway machinery: the message dispatcher (discovers
+ * `@WebSocketGateway` classes via DiscoveryService at bootstrap), the room
+ * registry, the sync driver, and the `@WebSocketServer()`-injected server
+ * handle.
+ *
+ * Construction lives in chained provider factories — registry → driver
+ * (bound to THAT registry) → server — so the single shared registry instance
+ * is preserved and everything materializes at bootstrap's eager
+ * instantiation, before any lifecycle hook or message dispatch.
+ *
+ * The instance key derives from the sync driver kind: two `forRoot()` calls
+ * with the same driver kind dedup (HMR-idempotent); pass an explicit `key`
+ * to run multiple same-kind instances side by side.
+ */
+declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<WebSocketModuleOptions, "forRoot", "create", {
+    isGlobal?: boolean;
+}>;
+export declare class WebSocketModule extends ConfigurableModuleClass {
 }
+export {};

package/dist/websocket/websocket.module.js

@@ -1,52 +1,63 @@
+import { defineModule } from "../module/define-module.js";
 import { WsDispatcher } from "./ws-dispatcher.js";
 import { WsServerImpl } from "./ws-server.js";
 import { InMemoryRoomRegistry, local } from "./ws-sync.js";
 import { WS_MODULE_OPTIONS, WS_ROOM_REGISTRY, WS_SERVER, WS_SYNC_DRIVER } from "./websocket.tokens.js";
 /**
  * Registers the WebSocket gateway machinery: the message dispatcher (discovers
- * `@WebSocketGateway` classes at bootstrap), the room registry, the sync driver,
- * and the `@WebSocketServer()`-injected server handle. Mirrors
- * `CacheModule.forRoot` / `ScheduleModule.forRoot`.
- */ // forRoot() carries non-serializable per-call state (a fresh registry/driver/
-// server), so each call is its own module instance. A unique key prevents the
-// module loader from deduping two distinct configurations into one (which would
-// silently discard the second registry/server).
-let instanceCounter = 0;
-export class WebSocketModule {
-    static forRoot(options = {}) {
-        const registry = options.registry ?? new InMemoryRoomRegistry();
-        const driver = options.sync ?? local();
-        driver.bind(registry);
-        const server = new WsServerImpl(driver);
-        const providers = [
-            {
-                provide: WS_MODULE_OPTIONS,
-                useValue: options
-            },
-            {
-                provide: WS_ROOM_REGISTRY,
-                useValue: registry
-            },
-            {
-                provide: WS_SYNC_DRIVER,
-                useValue: driver
-            },
-            {
-                provide: WS_SERVER,
-                useValue: server
-            },
-            WsDispatcher
-        ];
-        return {
-            module: WebSocketModule,
-            key: `${driver.kind}#${instanceCounter += 1}`,
-            providers,
+ * `@WebSocketGateway` classes via DiscoveryService at bootstrap), the room
+ * registry, the sync driver, and the `@WebSocketServer()`-injected server
+ * handle.
+ *
+ * Construction lives in chained provider factories — registry → driver
+ * (bound to THAT registry) → server — so the single shared registry instance
+ * is preserved and everything materializes at bootstrap's eager
+ * instantiation, before any lifecycle hook or message dispatch.
+ *
+ * The instance key derives from the sync driver kind: two `forRoot()` calls
+ * with the same driver kind dedup (HMR-idempotent); pass an explicit `key`
+ * to run multiple same-kind instances side by side.
+ */ const { ConfigurableModuleClass } = defineModule({
+    name: 'WebSocket',
+    optionsToken: WS_MODULE_OPTIONS,
+    key: (options)=>`ws#${options.sync?.kind ?? 'local'}`,
+    setup: ({ OPTIONS })=>({
+            providers: [
+                {
+                    provide: WS_ROOM_REGISTRY,
+                    useFactory: (o)=>o.registry ?? new InMemoryRoomRegistry(),
+                    inject: [
+                        OPTIONS
+                    ]
+                },
+                {
+                    provide: WS_SYNC_DRIVER,
+                    useFactory: (o, registry)=>{
+                        const driver = o.sync ?? local();
+                        driver.bind(registry);
+                        return driver;
+                    },
+                    inject: [
+                        OPTIONS,
+                        WS_ROOM_REGISTRY
+                    ]
+                },
+                {
+                    provide: WS_SERVER,
+                    useFactory: (driver)=>new WsServerImpl(driver),
+                    inject: [
+                        WS_SYNC_DRIVER
+                    ]
+                },
+                WsDispatcher
+            ],
             exports: [
                 WS_SERVER,
                 WS_SYNC_DRIVER,
                 WS_ROOM_REGISTRY,
                 WsDispatcher
             ]
-        };
-    }
+        })
+});
+export class WebSocketModule extends ConfigurableModuleClass {
 }

package/dist/websocket/websocket.tokens.d.ts

@@ -1,4 +1,5 @@
 import { InjectionToken } from '../container/types';
+import type { WebSocketModuleOptions } from './websocket.module';
 import type { RoomRegistry, SyncDriver } from './ws-sync';
 import type { WsServer } from './websocket.types';
 export declare const WS_GATEWAY_METADATA = "vela:ws-gateway";
@@ -19,4 +20,4 @@ export declare const WS_SERVER: InjectionToken<WsServer>;
 export declare const WS_SYNC_DRIVER: InjectionToken<SyncDriver>;
 /** The local room-membership registry a transport reads/writes. */
 export declare const WS_ROOM_REGISTRY: InjectionToken<RoomRegistry>;
-export declare const WS_MODULE_OPTIONS = "vela:ws-module-options";
+export declare const WS_MODULE_OPTIONS: InjectionToken<WebSocketModuleOptions>;

package/dist/websocket/websocket.tokens.js

@@ -16,5 +16,6 @@ export const WsParamType = {
  */ export const WS_SERVER = new InjectionToken('WS_SERVER');
 /** The active cross-instance sync driver (`local()` by default). */ export const WS_SYNC_DRIVER = new InjectionToken('WS_SYNC_DRIVER');
 /** The local room-membership registry a transport reads/writes. */ export const WS_ROOM_REGISTRY = new InjectionToken('WS_ROOM_REGISTRY');
-// forRoot() options carrier.
-export const WS_MODULE_OPTIONS = 'vela:ws-module-options';
+// forRoot() options carrier — a typed InjectionToken like every other module
+// options token (the raw-string form was the odd one out).
+export const WS_MODULE_OPTIONS = new InjectionToken('WS_MODULE_OPTIONS');

package/dist/websocket/ws-dispatcher.d.ts

@@ -1,24 +1,37 @@
 import { Container } from '../container/container';
+import { DiscoveryService } from '../discovery/discovery.service';
+import type { ContributesEntrypoints, Entrypoint } from '../entrypoint/entrypoint.types';
 import { RouteManager } from '../http/route.manager';
 import type { OnApplicationBootstrap } from '../lifecycle/index';
 import type { WsClient, WsServer } from './websocket.types';
+/** Metadata carried by each `'websocket'` entrypoint a transport consumes. */
+export interface WsEntrypointMeta {
+    /** The gateway's route path (from `@WebSocketGateway({ path })`). */
+    path: string;
+    /** The dispatcher that routes frames for this gateway. */
+    dispatcher: WsDispatcher;
+}
 /**
- * Discovers `@WebSocketGateway` classes at bootstrap (same `container.getTokens()`
- * scan as `EventEmitterSubscriber` / `ScheduleRegistry`) and routes inbound
- * messages to `@SubscribeMessage` handlers. Transports call `handleOpen`,
- * `dispatchMessage`, `handleClose`, and `handleError`; the guard → pipe →
- * interceptor → filter pipeline (including `APP_*` global components) is reused
- * from `ComponentManager`.
+ * Discovers `@WebSocketGateway` classes at bootstrap (via `DiscoveryService`)
+ * and routes inbound messages to `@SubscribeMessage` handlers. Transports read
+ * the gateways from `app.entrypoints.ofKind('websocket')` (this dispatcher
+ * contributes them) and call `handleOpen`, `dispatchMessage`, `handleClose`,
+ * and `handleError`; the guard → pipe → interceptor → filter pipeline
+ * (including `APP_*` global components) runs through the shared
+ * `PipelineRunner`.
  */
-export declare class WsDispatcher implements OnApplicationBootstrap {
+export declare class WsDispatcher implements OnApplicationBootstrap, ContributesEntrypoints {
     private readonly container;
+    private readonly discovery;
     private readonly server?;
     private readonly routeManager?;
     private readonly gateways;
-    constructor(container: Container, server?: WsServer | undefined, routeManager?: RouteManager | undefined);
+    constructor(container: Container, discovery: DiscoveryService, server?: WsServer | undefined, routeManager?: RouteManager | undefined);
     /** Paths of every discovered `@WebSocketGateway` — used by transports to register routes. */
     get gatewayPaths(): string[];
     onApplicationBootstrap(): Promise<void>;
+    /** One `'websocket'` entrypoint per discovered gateway (authoritative). */
+    collectEntrypoints(): Entrypoint<WsEntrypointMeta>[];
     handleOpen(path: string, client: WsClient): Promise<void>;
     handleClose(path: string, client: WsClient, _code: number, _reason: string): Promise<void>;
     handleError(path: string, _client: WsClient, err: unknown): Promise<void>;
@@ -28,6 +41,5 @@ export declare class WsDispatcher implements OnApplicationBootstrap {
     private trySend;
     private reportBootstrapError;
     private parse;
-    private resolveGateway;
     private buildGatewayEntry;
 }

package/dist/websocket/ws-dispatcher.js

@@ -14,10 +14,12 @@ function _ts_param(paramIndex, decorator) {
 }
 import { Container } from "../container/container.js";
 import { Inject, Injectable, Optional } from "../container/decorators.js";
+import { DiscoveryService } from "../discovery/discovery.service.js";
 import { instantiateMany } from "../http/instantiate.js";
 import { RouteManager } from "../http/route.manager.js";
 import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
+import { PipelineRunner } from "../pipeline/pipeline-runner.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { resolveWsArgs } from "./ws-argument-resolver.js";
 import { buildWsExecutionContext } from "./ws-execution-context.js";
@@ -37,11 +39,13 @@ function isWsResponse(x) {
 }
 export class WsDispatcher {
     container;
+    discovery;
     server;
     routeManager;
     gateways = new Map();
-    constructor(container, server, routeManager){
+    constructor(container, discovery, server, routeManager){
         this.container = container;
+        this.discovery = discovery;
         this.server = server;
         this.routeManager = routeManager;
     }
@@ -51,17 +55,15 @@ export class WsDispatcher {
         ];
     }
     async onApplicationBootstrap() {
-        for (const token of this.container.getTokens()){
-            if (typeof token !== 'function') continue;
-            const options = MetadataRegistry.getCustomClassMeta(token, WS_GATEWAY_METADATA);
-            if (!options) continue;
-            const instance = this.resolveGateway(token);
-            if (!instance) continue;
-            const entry = this.buildGatewayEntry(token, options, instance);
+        for (const found of this.discovery.providersWithMeta(WS_GATEWAY_METADATA)){
+            if (!found.instance) continue;
+            const gatewayClass = found.metatype;
+            const instance = found.instance;
+            const entry = this.buildGatewayEntry(gatewayClass, found.meta, instance);
             // Two gateways on the same path (or both defaulting to '') would silently
             // overwrite each other in the routing Map — surface it instead.
             if (this.gateways.has(entry.path)) {
-                const msg = `[vela] duplicate @WebSocketGateway path '${entry.path}' ` + `(${token.name}); keeping the first. Give each gateway a distinct path.`;
+                const msg = `[vela] duplicate @WebSocketGateway path '${entry.path}' ` + `(${gatewayClass.name}); keeping the first. Give each gateway a distinct path.`;
                 if (this.container.getDiagnostics() === 'throw') throw new Error(msg);
                 console.warn(msg);
                 continue;
@@ -71,11 +73,24 @@ export class WsDispatcher {
                 try {
                     await instance.afterInit(this.server);
                 } catch (err) {
-                    this.reportBootstrapError(token.name, err);
+                    this.reportBootstrapError(gatewayClass.name, err);
                 }
             }
         }
     }
+    /** One `'websocket'` entrypoint per discovered gateway (authoritative). */ collectEntrypoints() {
+        return [
+            ...this.gateways.values()
+        ].map((entry)=>({
+                kind: 'websocket',
+                token: entry.gatewayClass,
+                instance: entry.instance,
+                meta: {
+                    path: entry.path,
+                    dispatcher: this
+                }
+            }));
+    }
     async handleOpen(path, client) {
         const entry = this.gateways.get(path);
         if (entry && hasHandleConnection(entry.instance)) {
@@ -131,15 +146,17 @@ export class WsDispatcher {
             ...instantiateMany(globals?.filters ?? [], this.container)
         ];
         try {
-            for (const guard of guards){
-                if (!await guard.canActivate(ctx)) {
-                    throw new WsException('Forbidden');
-                }
-            }
-            const args = await resolveWsArgs(handler.paramMeta, client, message.data, pipes, handler.paramTypes);
             const method = entry.instance[handler.methodName];
-            const core = async ()=>method.apply(entry.instance, args);
-            const result = await ComponentManager.runInterceptorChain(interceptors, ctx, core);
+            // Guards → args + pipes → interceptor chain → handler, via the shared
+            // runner (WS keeps guards-first, unlike HTTP's args-before-guards).
+            const result = await PipelineRunner.run({
+                context: ctx,
+                guards,
+                interceptors,
+                resolveArgs: ()=>resolveWsArgs(handler.paramMeta, client, message.data, pipes, handler.paramTypes),
+                invoke: async (args)=>method.apply(entry.instance, args),
+                onGuardReject: ()=>new WsException('Forbidden')
+            });
             this.reply(client, message, result);
         } catch (error) {
             await this.runFilters(client, message, error, filters, ctx);
@@ -193,19 +210,6 @@ export class WsDispatcher {
         }
         return parsed;
     }
-    resolveGateway(token) {
-        try {
-            return this.container.resolve(token);
-        } catch (err) {
-            const mode = this.container.getDiagnostics();
-            if (mode === 'throw') throw err;
-            if (mode === 'log') {
-                const name = typeof token === 'function' ? token.name : String(token);
-                console.warn(`[vela] websocket gateway discovery: cannot resolve ${name}:`, err);
-            }
-            return undefined;
-        }
-    }
     buildGatewayEntry(gatewayClass, options, instance) {
         const ctor = gatewayClass;
         const subs = MetadataRegistry.getCustomClassMeta(ctor, WS_SUBSCRIBE_METADATA) ?? [];
@@ -220,12 +224,12 @@ export class WsDispatcher {
                 methodName,
                 paramMeta,
                 paramTypes,
-                guards: ComponentManager.getComponents('guard', ctor, methodName),
-                pipes: ComponentManager.getComponents('pipe', ctor, methodName),
-                interceptors: ComponentManager.getComponents('interceptor', ctor, methodName),
+                guards: ComponentManager.getScopedComponents('guard', ctor, methodName),
+                pipes: ComponentManager.getScopedComponents('pipe', ctor, methodName),
+                interceptors: ComponentManager.getScopedComponents('interceptor', ctor, methodName),
                 // Handler → controller → global, so the closest filter runs first (mirrors HandlerExecutor).
                 filters: [
-                    ...ComponentManager.getComponents('filter', ctor, methodName)
+                    ...ComponentManager.getScopedComponents('filter', ctor, methodName)
                 ].reverse()
             });
         }
@@ -240,13 +244,15 @@ export class WsDispatcher {
 WsDispatcher = _ts_decorate([
     Injectable(),
     _ts_param(0, Inject(Container)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(WS_SERVER)),
+    _ts_param(1, Inject(DiscoveryService)),
     _ts_param(2, Optional()),
-    _ts_param(2, Inject(RouteManager)),
+    _ts_param(2, Inject(WS_SERVER)),
+    _ts_param(3, Optional()),
+    _ts_param(3, Inject(RouteManager)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof Container === "undefined" ? Object : Container,
+        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
         typeof WsServer === "undefined" ? Object : WsServer,
         typeof RouteManager === "undefined" ? Object : RouteManager
     ])

package/dist/websocket-node/register-gateways.js

@@ -1,4 +1,4 @@
-import { WsDispatcher, WS_ROOM_REGISTRY } from "../websocket/index.js";
+import { WS_ROOM_REGISTRY } from "../websocket/index.js";
 import { NodeWsClient } from "./node-ws-client.js";
 function toText(data) {
     if (typeof data === 'string') return data;
@@ -24,9 +24,9 @@ function toText(data) {
  * ```
  */ export function registerWebSocketGateways(app, upgradeWebSocket) {
     const hono = app.getHonoApp();
-    const dispatcher = app.get(WsDispatcher);
     const registry = app.get(WS_ROOM_REGISTRY);
-    for (const path of dispatcher.gatewayPaths){
+    for (const { meta } of app.entrypoints.ofKind('websocket')){
+        const { path, dispatcher } = meta;
         hono.get(path, upgradeWebSocket((c)=>{
             const roomId = c.req.param('id') ?? path;
             let client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "1.10.0",
+  "version": "1.13.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",