@hazeljs/inspector 0.2.0-rc.5

package/dist/plugins/graphql.inspector.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * GraphQL inspector plugin - inspects @Resolver with @Query/@Mutation
+ * Optional: requires @hazeljs/graphql to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlInspector = void 0;
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetGraphQLModule() {
+    try {
+        return require('@hazeljs/graphql');
+    }
+    catch {
+        return null;
+    }
+}
+exports.graphqlInspector = {
+    name: 'graphql',
+    version: '1.0.0',
+    supports: () => tryGetGraphQLModule() !== null,
+    inspect: async (context) => {
+        const gqlMod = tryGetGraphQLModule();
+        if (!gqlMod)
+            return [];
+        const entries = [];
+        const controllers = (0, core_1.collectControllersFromModule)(context.moduleType);
+        const tokens = context.container.getTokens?.() ?? [];
+        const allClasses = [
+            ...controllers,
+            ...tokens.filter((t) => typeof t === 'function'),
+        ];
+        for (const ctrl of allClasses) {
+            if (typeof ctrl !== 'function')
+                continue;
+            const resolverMeta = gqlMod.getResolverMetadata(ctrl);
+            const queries = gqlMod.getQueryMetadata(ctrl) ?? [];
+            const mutations = gqlMod.getMutationMetadata(ctrl) ?? [];
+            if (queries.length === 0 && mutations.length === 0)
+                continue;
+            const className = ctrl.name ?? 'Unknown';
+            const resolverName = resolverMeta?.name ?? className;
+            for (const q of queries) {
+                entries.push({
+                    id: createId('graphql', 'query', resolverName, q.name ?? q.method ?? ''),
+                    kind: 'graphql',
+                    packageName: '@hazeljs/graphql',
+                    sourceType: 'method',
+                    className,
+                    methodName: q.method,
+                    resolverName,
+                    operationType: 'query',
+                    operationName: q.name ?? q.method ?? 'unknown',
+                });
+            }
+            for (const m of mutations) {
+                entries.push({
+                    id: createId('graphql', 'mutation', resolverName, m.name ?? m.method ?? ''),
+                    kind: 'graphql',
+                    packageName: '@hazeljs/graphql',
+                    sourceType: 'method',
+                    className,
+                    methodName: m.method,
+                    resolverName,
+                    operationType: 'mutation',
+                    operationName: m.name ?? m.method ?? 'unknown',
+                });
+            }
+        }
+        return entries;
+    },
+};

package/dist/plugins/grpc.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * gRPC inspector plugin - inspects @GrpcMethod handlers
+ * Optional: requires @hazeljs/grpc to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const grpcInspector: HazelInspectorPlugin;
+//# sourceMappingURL=grpc.inspector.d.ts.map

package/dist/plugins/grpc.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpc.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/grpc.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAsC,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAkBnG,eAAO,MAAM,aAAa,EAAE,oBAkC3B,CAAC"}

package/dist/plugins/grpc.inspector.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * gRPC inspector plugin - inspects @GrpcMethod handlers
+ * Optional: requires @hazeljs/grpc to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetGrpcModule() {
+    try {
+        return require('@hazeljs/grpc');
+    }
+    catch {
+        return null;
+    }
+}
+exports.grpcInspector = {
+    name: 'grpc',
+    version: '1.0.0',
+    supports: () => tryGetGrpcModule() !== null,
+    inspect: async (context) => {
+        const grpcMod = tryGetGrpcModule();
+        if (!grpcMod)
+            return [];
+        const entries = [];
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            // getGrpcMethodMetadata expects target.constructor to be the class; pass prototype when token is a class
+            const target = token.prototype ?? token;
+            const methods = grpcMod.getGrpcMethodMetadata(target);
+            if (!methods?.length)
+                continue;
+            const className = token.name ?? 'Unknown';
+            for (const m of methods) {
+                entries.push({
+                    id: createId('grpc', m.service, m.method),
+                    kind: 'grpc',
+                    packageName: '@hazeljs/grpc',
+                    sourceType: 'method',
+                    className,
+                    methodName: m.method,
+                    serviceName: m.service,
+                });
+            }
+        }
+        return entries;
+    },
+};

package/dist/plugins/kafka.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Kafka inspector plugin - inspects @KafkaConsumer and @KafkaSubscribe
+ * Optional: requires @hazeljs/kafka to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const kafkaInspector: HazelInspectorPlugin;
+//# sourceMappingURL=kafka.inspector.d.ts.map

package/dist/plugins/kafka.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/kafka.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAuC,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAkBpG,eAAO,MAAM,cAAc,EAAE,oBAwC5B,CAAC"}

package/dist/plugins/kafka.inspector.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Kafka inspector plugin - inspects @KafkaConsumer and @KafkaSubscribe
+ * Optional: requires @hazeljs/kafka to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kafkaInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetKafkaModule() {
+    try {
+        return require('@hazeljs/kafka');
+    }
+    catch {
+        return null;
+    }
+}
+exports.kafkaInspector = {
+    name: 'kafka',
+    version: '1.0.0',
+    supports: () => tryGetKafkaModule() !== null,
+    inspect: async (context) => {
+        const kafkaMod = tryGetKafkaModule();
+        if (!kafkaMod)
+            return [];
+        const entries = [];
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const ctor = token;
+            if (!kafkaMod.isKafkaConsumer(ctor))
+                continue;
+            const consumerMeta = kafkaMod.getKafkaConsumerMetadata(ctor);
+            // getKafkaSubscribeMetadata expects target.constructor to be the class; pass prototype
+            const target = ctor.prototype ?? ctor;
+            const subs = kafkaMod.getKafkaSubscribeMetadata(target);
+            if (!subs?.length)
+                continue;
+            const className = token.name ?? 'Unknown';
+            for (const s of subs) {
+                entries.push({
+                    id: createId('kafka', className, s.topic, s.methodName),
+                    kind: 'kafka',
+                    packageName: '@hazeljs/kafka',
+                    sourceType: 'method',
+                    className,
+                    methodName: s.methodName,
+                    consumerName: className,
+                    groupId: consumerMeta?.groupId,
+                    topic: s.topic,
+                });
+            }
+        }
+        return entries;
+    },
+};

package/dist/plugins/ml.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ML inspector plugin - inspects @Model and ModelRegistry
+ * Optional: requires @hazeljs/ml to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const mlInspector: HazelInspectorPlugin;
+//# sourceMappingURL=ml.inspector.d.ts.map

package/dist/plugins/ml.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ml.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/ml.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAkB5B,eAAO,MAAM,WAAW,EAAE,oBA0DzB,CAAC"}

package/dist/plugins/ml.inspector.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * ML inspector plugin - inspects @Model and ModelRegistry
+ * Optional: requires @hazeljs/ml to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mlInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetMLModule() {
+    try {
+        return require('@hazeljs/ml');
+    }
+    catch {
+        return null;
+    }
+}
+exports.mlInspector = {
+    name: 'ml',
+    version: '1.0.0',
+    supports: () => tryGetMLModule() !== null,
+    inspect: async (context) => {
+        const mlMod = tryGetMLModule();
+        if (!mlMod)
+            return [];
+        const entries = [];
+        const seen = new Set();
+        // From container tokens with @Model
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            if (!mlMod.hasModelMetadata(token))
+                continue;
+            const meta = mlMod.getModelMetadata(token);
+            const className = token.name ?? 'Unknown';
+            const key = `${meta?.name ?? className}@${meta?.version ?? 'latest'}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            entries.push({
+                id: createId('ml', meta?.name ?? className, meta?.version ?? ''),
+                kind: 'ml',
+                packageName: '@hazeljs/ml',
+                sourceType: 'class',
+                className,
+                modelName: meta?.name ?? className,
+                version: meta?.version,
+            });
+        }
+        // From ModelRegistry if available
+        try {
+            const registry = context.container.resolve(mlMod.ModelRegistry);
+            if (registry?.list) {
+                const models = registry.list();
+                for (const m of models) {
+                    const key = `${m.name}@${m.version ?? 'latest'}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    entries.push({
+                        id: createId('ml', m.name ?? 'unknown', m.version ?? ''),
+                        kind: 'ml',
+                        packageName: '@hazeljs/ml',
+                        modelName: m.name ?? 'unknown',
+                        version: m.version,
+                    });
+                }
+            }
+        }
+        catch {
+            // ModelRegistry not in container
+        }
+        return entries;
+    },
+};

package/dist/plugins/prompts.inspector.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prompts inspector plugin - inspects registered prompts in PromptRegistry
+ * Optional: requires @hazeljs/prompts to be installed
+ */
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const promptsInspector: HazelInspectorPlugin;
+//# sourceMappingURL=prompts.inspector.d.ts.map

package/dist/plugins/prompts.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/prompts.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAc5B,eAAO,MAAM,gBAAgB,EAAE,oBAuB9B,CAAC"}

package/dist/plugins/prompts.inspector.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Prompts inspector plugin - inspects registered prompts in PromptRegistry
+ * Optional: requires @hazeljs/prompts to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptsInspector = void 0;
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetPromptsModule() {
+    try {
+        return require('@hazeljs/prompts');
+    }
+    catch {
+        return null;
+    }
+}
+exports.promptsInspector = {
+    name: 'prompts',
+    version: '1.0.0',
+    supports: () => tryGetPromptsModule() !== null,
+    inspect: async () => {
+        const promptsMod = tryGetPromptsModule();
+        if (!promptsMod)
+            return [];
+        const keys = promptsMod.PromptRegistry.list();
+        const entries = keys.map((key) => {
+            const parts = key.split(':');
+            const scope = parts.length >= 2 ? parts[0] : undefined;
+            return {
+                id: createId('prompt', key),
+                kind: 'prompt',
+                packageName: '@hazeljs/prompts',
+                promptKey: key,
+                scope,
+            };
+        });
+        return entries;
+    },
+};

package/dist/plugins/queue.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Queue inspector plugin - inspects @Queue decorated methods
+ * Optional: requires @hazeljs/queue to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const queueInspector: HazelInspectorPlugin;
+//# sourceMappingURL=queue.inspector.d.ts.map

package/dist/plugins/queue.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/queue.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAuC,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAkBpG,eAAO,MAAM,cAAc,EAAE,oBAoC5B,CAAC"}

package/dist/plugins/queue.inspector.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Queue inspector plugin - inspects @Queue decorated methods
+ * Optional: requires @hazeljs/queue to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queueInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetQueueModule() {
+    try {
+        return require('@hazeljs/queue');
+    }
+    catch {
+        return null;
+    }
+}
+exports.queueInspector = {
+    name: 'queue',
+    version: '1.0.0',
+    supports: (_context) => {
+        return tryGetQueueModule() !== null;
+    },
+    inspect: async (_context) => {
+        const queueMod = tryGetQueueModule();
+        if (!queueMod)
+            return [];
+        const entries = [];
+        const tokens = _context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const processors = queueMod.getQueueProcessorMetadata(token.prototype ?? token);
+            if (!processors?.length)
+                continue;
+            const className = token.name ?? 'Unknown';
+            for (const p of processors) {
+                entries.push({
+                    id: createId('queue', p.queueName, className, p.methodName),
+                    kind: 'queue',
+                    packageName: '@hazeljs/queue',
+                    sourceType: 'method',
+                    className,
+                    methodName: p.methodName,
+                    queueName: p.queueName,
+                    consumerName: p.options?.name ?? `${className}.${p.methodName}`,
+                    jobName: p.methodName,
+                });
+            }
+        }
+        return entries;
+    },
+};

package/dist/plugins/rag.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * RAG inspector plugin - inspects @RAG and RAG-related modules
+ * Optional: requires @hazeljs/rag to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const ragInspector: HazelInspectorPlugin;
+//# sourceMappingURL=rag.inspector.d.ts.map

package/dist/plugins/rag.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rag.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/rag.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAqC,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAmBlG,eAAO,MAAM,YAAY,EAAE,oBAqD1B,CAAC"}

package/dist/plugins/rag.inspector.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * RAG inspector plugin - inspects @RAG and RAG-related modules
+ * Optional: requires @hazeljs/rag to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ragInspector = void 0;
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetRagModule() {
+    try {
+        return require('@hazeljs/rag');
+    }
+    catch {
+        return null;
+    }
+}
+exports.ragInspector = {
+    name: 'rag',
+    version: '1.0.0',
+    supports: () => tryGetRagModule() !== null,
+    inspect: async (context) => {
+        const ragMod = tryGetRagModule();
+        if (!ragMod)
+            return [];
+        const entries = [];
+        const modules = (0, core_1.collectModulesFromModule)(context.moduleType);
+        for (const { moduleType: modRef, name } of modules) {
+            const modType = modRef.module ?? modRef;
+            const config = ragMod.getRAGConfig(modType);
+            if (!config)
+                continue;
+            entries.push({
+                id: createId('rag', name),
+                kind: 'rag',
+                packageName: '@hazeljs/rag',
+                sourceType: 'class',
+                pipelineName: name,
+                vectorStore: config.vectorDB,
+                embeddingProvider: config.embeddingModel,
+                chunkingStrategy: config.chunkSize ? `${config.chunkSize} chars` : undefined,
+            });
+        }
+        // Also check container for RAGService or similar
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const config = ragMod.getRAGConfig(token);
+            if (!config)
+                continue;
+            const className = token.name ?? 'Unknown';
+            if (entries.some((e) => e.id === createId('rag', className)))
+                continue;
+            entries.push({
+                id: createId('rag', className),
+                kind: 'rag',
+                packageName: '@hazeljs/rag',
+                sourceType: 'class',
+                className,
+                pipelineName: className,
+                vectorStore: config.vectorDB,
+                embeddingProvider: config.embeddingModel,
+                chunkingStrategy: config.chunkSize ? `${config.chunkSize} chars` : undefined,
+            });
+        }
+        return entries;
+    },
+};

package/dist/plugins/serverless.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Serverless inspector plugin - inspects @Serverless controllers
+ * Optional: requires @hazeljs/serverless to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const serverlessInspector: HazelInspectorPlugin;
+//# sourceMappingURL=serverless.inspector.d.ts.map

package/dist/plugins/serverless.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverless.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/serverless.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAqB5B,eAAO,MAAM,mBAAmB,EAAE,oBAgCjC,CAAC"}

package/dist/plugins/serverless.inspector.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Serverless inspector plugin - inspects @Serverless controllers
+ * Optional: requires @hazeljs/serverless to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverlessInspector = void 0;
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const _SERVERLESS_METADATA_KEY = 'hazel:serverless';
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetServerlessModule() {
+    try {
+        return require('@hazeljs/serverless');
+    }
+    catch {
+        return null;
+    }
+}
+exports.serverlessInspector = {
+    name: 'serverless',
+    version: '1.0.0',
+    supports: () => tryGetServerlessModule() !== null,
+    inspect: async (context) => {
+        const slsMod = tryGetServerlessModule();
+        if (!slsMod)
+            return [];
+        const entries = [];
+        const controllers = (0, core_1.collectControllersFromModule)(context.moduleType);
+        for (const ctrl of controllers) {
+            if (typeof ctrl !== 'function')
+                continue;
+            const meta = slsMod.getServerlessMetadata(ctrl);
+            if (!meta)
+                continue;
+            const className = ctrl.name ?? 'Unknown';
+            entries.push({
+                id: createId('serverless', className),
+                kind: 'serverless',
+                packageName: '@hazeljs/serverless',
+                sourceType: 'class',
+                className,
+                controllerName: className,
+                runtime: meta.runtime,
+                memory: meta.memory,
+                timeout: meta.timeout,
+            });
+        }
+        return entries;
+    },
+};

package/dist/plugins/websocket.inspector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WebSocket inspector plugin - inspects @Realtime gateways and @Subscribe handlers
+ * Optional: requires @hazeljs/websocket to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const websocketInspector: HazelInspectorPlugin;
+//# sourceMappingURL=websocket.inspector.d.ts.map

package/dist/plugins/websocket.inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/websocket.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAkB5B,eAAO,MAAM,kBAAkB,EAAE,oBA0DhC,CAAC"}

package/dist/plugins/websocket.inspector.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * WebSocket inspector plugin - inspects @Realtime gateways and @Subscribe handlers
+ * Optional: requires @hazeljs/websocket to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.websocketInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetWebSocketModule() {
+    try {
+        return require('@hazeljs/websocket');
+    }
+    catch {
+        return null;
+    }
+}
+exports.websocketInspector = {
+    name: 'websocket',
+    version: '1.0.0',
+    supports: (_context) => {
+        return tryGetWebSocketModule() !== null;
+    },
+    inspect: async (_context) => {
+        const wsMod = tryGetWebSocketModule();
+        if (!wsMod)
+            return [];
+        const entries = [];
+        const tokens = _context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            if (!wsMod.isRealtimeGateway(token))
+                continue;
+            const meta = wsMod.getRealtimeMetadata(token);
+            const className = token.name ?? 'Unknown';
+            const gatewayEntry = {
+                id: createId('websocket', className),
+                kind: 'websocket',
+                packageName: '@hazeljs/websocket',
+                sourceType: 'class',
+                className,
+                gatewayName: className,
+                namespace: meta?.namespace ?? meta?.path ?? '/',
+            };
+            entries.push(gatewayEntry);
+            // Scan for @Subscribe handlers
+            const proto = token.prototype;
+            if (proto) {
+                const methods = Object.getOwnPropertyNames(proto).filter((n) => n !== 'constructor' && typeof proto[n] === 'function');
+                for (const methodName of methods) {
+                    const event = wsMod.getSubscribeMetadata(proto, methodName);
+                    if (event) {
+                        entries.push({
+                            id: createId('websocket', className, methodName, event),
+                            kind: 'websocket',
+                            packageName: '@hazeljs/websocket',
+                            sourceType: 'method',
+                            className,
+                            methodName,
+                            gatewayName: className,
+                            namespace: meta?.namespace ?? meta?.path ?? '/',
+                            eventName: event,
+                        });
+                    }
+                }
+            }
+        }
+        return entries;
+    },
+};