@hazeljs/inspector 0.2.0-rc.5

package/dist/plugins/ai.inspector.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * AI inspector plugin - inspects @AIFunction decorated methods
+ * Optional: requires @hazeljs/ai to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiInspector = void 0;
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const AI_FUNCTION_METADATA_KEY = 'hazel:ai:function';
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetAIModule() {
+    try {
+        require.resolve('@hazeljs/ai');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.aiInspector = {
+    name: 'ai',
+    version: '1.0.0',
+    supports: () => tryGetAIModule(),
+    inspect: async (context) => {
+        if (!tryGetAIModule())
+            return [];
+        const entries = [];
+        const controllers = (0, core_1.collectControllersFromModule)(context.moduleType);
+        for (const ctrl of controllers) {
+            const proto = ctrl.prototype;
+            if (!proto)
+                continue;
+            const methodNames = Object.getOwnPropertyNames(proto).filter((n) => n !== 'constructor' && typeof proto[n] === 'function');
+            for (const methodName of methodNames) {
+                const meta = Reflect.getMetadata(AI_FUNCTION_METADATA_KEY, proto, methodName);
+                if (!meta)
+                    continue;
+                const className = ctrl.name ?? 'Unknown';
+                entries.push({
+                    id: createId('aifunction', className, methodName),
+                    kind: 'aifunction',
+                    packageName: '@hazeljs/ai',
+                    sourceType: 'method',
+                    className,
+                    methodName,
+                    provider: meta.provider,
+                    model: meta.model,
+                    streaming: meta.streaming,
+                });
+            }
+        }
+        // Also scan providers for AI functions
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const proto = token.prototype;
+            if (!proto)
+                continue;
+            const methodNames = Object.getOwnPropertyNames(proto).filter((n) => n !== 'constructor' && typeof proto[n] === 'function');
+            for (const methodName of methodNames) {
+                const meta = Reflect.getMetadata(AI_FUNCTION_METADATA_KEY, proto, methodName);
+                if (!meta)
+                    continue;
+                const className = token.name ?? 'Unknown';
+                const id = createId('aifunction', className, methodName);
+                if (entries.some((e) => e.id === id))
+                    continue;
+                entries.push({
+                    id,
+                    kind: 'aifunction',
+                    packageName: '@hazeljs/ai',
+                    sourceType: 'method',
+                    className,
+                    methodName,
+                    provider: meta.provider,
+                    model: meta.model,
+                    streaming: meta.streaming,
+                });
+            }
+        }
+        return entries;
+    },
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Core inspector plugin - routes, modules, providers, decorators
+ * Uses @hazeljs/core utilities: collectControllersFromModule, collectModulesFromModule, getModuleMetadata
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const coreInspector: HazelInspectorPlugin;
+//# sourceMappingURL=core.inspector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.inspector.d.ts","sourceRoot":"","sources":["../../src/plugins/core.inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,kBAAkB,CAAC;AA4B1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,eAAO,MAAM,aAAa,EAAE,oBA8M3B,CAAC"}

package/dist/plugins/core.inspector.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Core inspector plugin - routes, modules, providers, decorators
+ * Uses @hazeljs/core utilities: collectControllersFromModule, collectModulesFromModule, getModuleMetadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreInspector = void 0;
+require("reflect-metadata");
+const core_1 = require("@hazeljs/core");
+const CONTROLLER_METADATA_KEY = 'hazel:controller';
+const ROUTE_METADATA_KEY = 'hazel:routes';
+function normalizePath(path) {
+    let p = path || '/';
+    if (!p.startsWith('/'))
+        p = '/' + p;
+    if (p !== '/' && p.endsWith('/'))
+        p = p.slice(0, -1);
+    return p;
+}
+function createId(prefix, ...parts) {
+    return [prefix, ...parts].filter(Boolean).join(':');
+}
+exports.coreInspector = {
+    name: 'core',
+    version: '1.0.0',
+    supports: () => true,
+    inspect: async (context) => {
+        const entries = [];
+        const { moduleType, container } = context;
+        // Routes from controllers
+        const controllersRaw = (0, core_1.collectControllersFromModule)(moduleType);
+        const controllers = Array.isArray(controllersRaw) ? controllersRaw : [];
+        for (const controller of controllers) {
+            const controllerMeta = Reflect.getMetadata(CONTROLLER_METADATA_KEY, controller) || {};
+            const controllerPath = controllerMeta.path || '';
+            const controllerName = controller.name || 'Unknown';
+            const routeMetaRaw = Reflect.getMetadata(ROUTE_METADATA_KEY, controller);
+            const routeMetaList = Array.isArray(routeMetaRaw) ? routeMetaRaw : [];
+            for (const routeMeta of routeMetaList) {
+                const { method, path, propertyKey } = routeMeta;
+                const routePath = path || '';
+                const fullPath = normalizePath(controllerPath + routePath);
+                const guardsRaw = Reflect.getMetadata('hazel:guards', controller.prototype, propertyKey) ||
+                    Reflect.getMetadata('hazel:guards', controller) ||
+                    [];
+                const interceptorsRaw = Reflect.getMetadata('hazel:interceptors', controller, propertyKey) ||
+                    Reflect.getMetadata('hazel:class-interceptors', controller) ||
+                    [];
+                const pipesRaw = Reflect.getMetadata('hazel:pipe', controller.prototype, propertyKey) || [];
+                const guards = Array.isArray(guardsRaw) ? guardsRaw : [];
+                const interceptors = Array.isArray(interceptorsRaw) ? interceptorsRaw : [];
+                const pipes = Array.isArray(pipesRaw) ? pipesRaw : [];
+                const routeEntry = {
+                    id: createId('route', (method || 'GET').toUpperCase(), fullPath, String(propertyKey)),
+                    kind: 'route',
+                    packageName: '@hazeljs/core',
+                    sourceType: 'method',
+                    className: controllerName,
+                    methodName: String(propertyKey),
+                    httpMethod: (method || 'GET').toUpperCase(),
+                    fullPath,
+                    controllerPath: normalizePath(controllerPath),
+                    routePath,
+                    guards: guards.map((g) => g?.name ?? String(g)),
+                    interceptors: interceptors.map((i) => i?.name ?? String(i)),
+                    pipes: pipes.map((p) => p?.type?.name ?? String(p)),
+                };
+                entries.push(routeEntry);
+            }
+        }
+        // Modules
+        const modulesRaw = (0, core_1.collectModulesFromModule)(moduleType);
+        const modules = Array.isArray(modulesRaw) ? modulesRaw : [];
+        for (const { moduleType: modRef, name, isDynamic } of modules) {
+            const metadata = (0, core_1.getModuleMetadata)(modRef);
+            const moduleEntry = {
+                id: createId('module', name),
+                kind: 'module',
+                packageName: '@hazeljs/core',
+                moduleName: name,
+                dynamicModule: isDynamic,
+                imports: (metadata?.imports?.map((m) => m && typeof m === 'object' && 'module' in m
+                    ? (m.module?.name ?? 'DynamicModule')
+                    : (m?.name ?? 'DynamicModule')) ?? []),
+                providers: (metadata?.providers?.map((p) => p && typeof p === 'object' && 'provide' in p
+                    ? String(p.provide)
+                    : (p?.name ?? 'Unknown')) ?? []),
+                controllers: metadata?.controllers?.map((c) => c?.name ?? 'Unknown') ??
+                    [],
+                exports: metadata?.exports?.map((e) => e?.name ?? String(e)) ?? [],
+            };
+            entries.push(moduleEntry);
+        }
+        // Providers from modules + container
+        const seenProviders = new Set();
+        for (const { moduleType: modRef, name: moduleName } of modules) {
+            const metadata = (0, core_1.getModuleMetadata)(modRef);
+            const providerList = metadata?.providers ?? modRef.providers;
+            if (providerList) {
+                for (const provider of providerList) {
+                    if (provider &&
+                        typeof provider === 'object' &&
+                        ('provide' in provider || 'token' in provider)) {
+                        const p = provider;
+                        const token = p.token ?? p.provide;
+                        const displayName = typeof token === 'function'
+                            ? (token.name ?? 'Unknown')
+                            : typeof token === 'symbol'
+                                ? token.toString()
+                                : String(token);
+                        const providerName = p.useClass?.name ?? displayName;
+                        if (!seenProviders.has(providerName)) {
+                            seenProviders.add(providerName);
+                            const scope = (typeof token === 'function'
+                                ? Reflect.getMetadata('hazel:scope', token)
+                                : undefined) ?? 'singleton';
+                            entries.push({
+                                id: createId('provider', providerName),
+                                kind: 'provider',
+                                packageName: '@hazeljs/core',
+                                providerName,
+                                token: providerName,
+                                scope: scope,
+                                moduleName,
+                            });
+                        }
+                    }
+                    else {
+                        const cls = provider;
+                        const name = cls?.name ?? 'Unknown';
+                        if (!seenProviders.has(name)) {
+                            seenProviders.add(name);
+                            const scope = Reflect.getMetadata('hazel:scope', provider) ?? 'singleton';
+                            entries.push({
+                                id: createId('provider', name),
+                                kind: 'provider',
+                                packageName: '@hazeljs/core',
+                                providerName: name,
+                                token: name,
+                                scope: scope,
+                                moduleName,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Container tokens - use class/function name, never String(token) which dumps full source
+        try {
+            const tokensRaw = container.getTokens?.() ?? [];
+            const tokens = Array.isArray(tokensRaw) ? tokensRaw : [];
+            for (const token of tokens) {
+                const displayName = typeof token === 'function'
+                    ? token.name
+                    : typeof token === 'symbol'
+                        ? token.toString()
+                        : typeof token === 'string'
+                            ? token
+                            : null;
+                if (!displayName || seenProviders.has(displayName) || displayName.includes('Object'))
+                    continue;
+                seenProviders.add(displayName);
+                const scope = (typeof token === 'function' ? Reflect.getMetadata('hazel:scope', token) : undefined) ??
+                    'singleton';
+                entries.push({
+                    id: createId('provider', displayName),
+                    kind: 'provider',
+                    packageName: '@hazeljs/core',
+                    providerName: displayName,
+                    token: displayName,
+                    scope: scope,
+                    moduleName: undefined,
+                });
+            }
+        }
+        catch {
+            // ignore
+        }
+        // Decorators on controllers (route decorators)
+        for (const controller of controllers) {
+            const controllerName = controller.name || 'Unknown';
+            const routeMetaRaw2 = Reflect.getMetadata(ROUTE_METADATA_KEY, controller);
+            const routeMetaList2 = Array.isArray(routeMetaRaw2) ? routeMetaRaw2 : [];
+            for (const routeMeta of routeMetaList2) {
+                const { method, propertyKey } = routeMeta;
+                entries.push({
+                    id: createId('decorator', controllerName, String(propertyKey), method),
+                    kind: 'decorator',
+                    packageName: '@hazeljs/core',
+                    sourceType: 'method',
+                    className: controllerName,
+                    methodName: String(propertyKey),
+                    decoratorName: method?.toLowerCase() ?? 'get',
+                    targetType: 'method',
+                    targetClass: controllerName,
+                    targetMethod: String(propertyKey),
+                    rawMetadataKey: ROUTE_METADATA_KEY,
+                });
+            }
+        }
+        return entries;
+    },
+};

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

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

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

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

package/dist/plugins/cron.inspector.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Cron inspector plugin - inspects @Cron decorated methods
+ * Optional: requires @hazeljs/cron to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cronInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function getNextRuns(cronExpression, count = 5) {
+    try {
+        const parser = require('cron-parser');
+        const interval = parser.parseExpression(cronExpression);
+        const runs = [];
+        for (let i = 0; i < count; i++) {
+            runs.push(interval.next().toDate().toISOString());
+        }
+        return runs;
+    }
+    catch {
+        return [];
+    }
+}
+function tryGetCronModule() {
+    try {
+        return require('@hazeljs/cron');
+    }
+    catch {
+        return null;
+    }
+}
+exports.cronInspector = {
+    name: 'cron',
+    version: '1.0.0',
+    supports: (_context) => {
+        return tryGetCronModule() !== null;
+    },
+    inspect: async (_context) => {
+        const cronMod = tryGetCronModule();
+        if (!cronMod)
+            return [];
+        const entries = [];
+        const tokensRaw = _context.container.getTokens?.() ?? [];
+        const tokens = Array.isArray(tokensRaw) ? tokensRaw : [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const jobsRaw = cronMod.getCronMetadata(token.prototype ?? token);
+            const jobs = Array.isArray(jobsRaw) ? jobsRaw : [];
+            if (!jobs.length)
+                continue;
+            const className = token.name ?? 'Unknown';
+            for (const job of jobs) {
+                const opts = job.options || {};
+                const nextRuns = opts.cronTime ? getNextRuns(opts.cronTime) : [];
+                entries.push({
+                    id: createId('cron', opts.name ?? `${className}.${job.methodName}`),
+                    kind: 'cron',
+                    packageName: '@hazeljs/cron',
+                    sourceType: 'method',
+                    className,
+                    methodName: job.methodName,
+                    jobName: opts.name ?? `${className}.${job.methodName}`,
+                    cronExpression: opts.cronTime,
+                    enabled: opts.enabled !== false,
+                    nextRuns: nextRuns.length ? nextRuns : undefined,
+                });
+            }
+        }
+        return entries;
+    },
+};

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

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

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

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

package/dist/plugins/data.inspector.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Data pipeline inspector plugin - inspects @Pipeline
+ * Optional: requires @hazeljs/data to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataInspector = void 0;
+require("reflect-metadata");
+const _PIPELINE_METADATA_KEY = 'hazel:data:pipeline';
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetDataModule() {
+    try {
+        return require('@hazeljs/data');
+    }
+    catch {
+        return null;
+    }
+}
+exports.dataInspector = {
+    name: 'data',
+    version: '1.0.0',
+    supports: () => tryGetDataModule() !== null,
+    inspect: async (context) => {
+        const dataMod = tryGetDataModule();
+        if (!dataMod)
+            return [];
+        const entries = [];
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            if (!dataMod.hasPipelineMetadata(token))
+                continue;
+            const meta = dataMod.getPipelineMetadata(token);
+            const className = token.name ?? 'Unknown';
+            const pipelineName = meta?.name ?? className;
+            entries.push({
+                id: createId('data', pipelineName),
+                kind: 'data',
+                packageName: '@hazeljs/data',
+                sourceType: 'class',
+                className,
+                pipelineName,
+            });
+        }
+        return entries;
+    },
+};

package/dist/plugins/event-emitter.inspector.d.ts

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

package/dist/plugins/event-emitter.inspector.d.ts.map

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

package/dist/plugins/event-emitter.inspector.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Event emitter inspector plugin - inspects @OnEvent listeners
+ * Optional: requires @hazeljs/event-emitter to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventEmitterInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetEventEmitterModule() {
+    try {
+        return require('@hazeljs/event-emitter');
+    }
+    catch {
+        return null;
+    }
+}
+exports.eventEmitterInspector = {
+    name: 'event-emitter',
+    version: '1.0.0',
+    supports: () => tryGetEventEmitterModule() !== null,
+    inspect: async (context) => {
+        const eeMod = tryGetEventEmitterModule();
+        if (!eeMod)
+            return [];
+        const entries = [];
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const target = token.prototype ?? token;
+            const listeners = eeMod.getOnEventMetadata(target);
+            if (!listeners?.length)
+                continue;
+            const className = token.name ?? 'Unknown';
+            for (const l of listeners) {
+                const eventStr = Array.isArray(l.event) ? l.event.join(', ') : String(l.event);
+                entries.push({
+                    id: createId('event', className, l.methodName, eventStr),
+                    kind: 'event',
+                    packageName: '@hazeljs/event-emitter',
+                    sourceType: 'method',
+                    className,
+                    methodName: l.methodName,
+                    eventName: eventStr,
+                });
+            }
+        }
+        return entries;
+    },
+};

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

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

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

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

package/dist/plugins/flow.inspector.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Flow inspector plugin - inspects @Flow definitions with @Node
+ * Optional: requires @hazeljs/flow to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+const FLOW_METADATA_KEY = 'flow:definition';
+const NODE_METADATA_KEY = 'flow:nodes';
+const EDGE_METADATA_KEY = 'flow:edges';
+const ENTRY_METADATA_KEY = 'flow:entry';
+function tryGetFlowModule() {
+    try {
+        require.resolve('@hazeljs/flow');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.flowInspector = {
+    name: 'flow',
+    version: '1.0.0',
+    supports: () => tryGetFlowModule(),
+    inspect: async (context) => {
+        if (!tryGetFlowModule())
+            return [];
+        const entries = [];
+        const tokensRaw = context.container.getTokens?.() ?? [];
+        const tokens = Array.isArray(tokensRaw) ? tokensRaw : [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            const flowMeta = Reflect.getMetadata(FLOW_METADATA_KEY, token);
+            if (!flowMeta)
+                continue;
+            const className = token.name ?? 'Unknown';
+            const flowId = flowMeta.flowId ?? className;
+            const version = flowMeta.version;
+            const proto = token.prototype;
+            let entryNodeId = null;
+            const allEdges = [];
+            const nodeIds = [];
+            if (proto) {
+                const methodNames = Object.getOwnPropertyNames(proto).filter((n) => n !== 'constructor' && typeof proto[n] === 'function');
+                for (const methodName of methodNames) {
+                    const nodeMeta = Reflect.getMetadata(NODE_METADATA_KEY, proto, methodName);
+                    if (nodeMeta) {
+                        const nodeId = nodeMeta.id ?? methodName;
+                        nodeIds.push(nodeId);
+                        if (Reflect.getMetadata(ENTRY_METADATA_KEY, proto, methodName)) {
+                            entryNodeId = nodeId;
+                        }
+                        const nodeEdgesRaw = Reflect.getMetadata(EDGE_METADATA_KEY, proto, methodName);
+                        const nodeEdges = Array.isArray(nodeEdgesRaw) ? nodeEdgesRaw : [];
+                        for (const e of nodeEdges) {
+                            allEdges.push(`${e.from}→${e.to}`);
+                        }
+                    }
+                }
+            }
+            // Flow definition entry (one per @Flow class)
+            entries.push({
+                id: createId('flow', flowId, version ?? ''),
+                kind: 'flow',
+                packageName: '@hazeljs/flow',
+                sourceType: 'class',
+                className,
+                flowId,
+                version,
+                nodeName: entryNodeId ?? undefined,
+                entryNode: entryNodeId ?? undefined,
+                nodes: nodeIds.join(', '),
+                edges: allEdges.join('; ') || undefined,
+            });
+            // Node entries (one per @Node method)
+            if (proto) {
+                const methodNames = Object.getOwnPropertyNames(proto).filter((n) => n !== 'constructor' && typeof proto[n] === 'function');
+                for (const methodName of methodNames) {
+                    const nodeMeta = Reflect.getMetadata(NODE_METADATA_KEY, proto, methodName);
+                    if (nodeMeta) {
+                        const nodeId = nodeMeta.id ?? methodName;
+                        const nodeEdgesRaw = Reflect.getMetadata(EDGE_METADATA_KEY, proto, methodName);
+                        const nodeEdges = Array.isArray(nodeEdgesRaw) ? nodeEdgesRaw : [];
+                        const edgesStr = nodeEdges
+                            .map((e) => `${e.from}→${e.to}`)
+                            .join(', ');
+                        const isEntry = Reflect.getMetadata(ENTRY_METADATA_KEY, proto, methodName);
+                        entries.push({
+                            id: createId('flow', flowId, 'node', nodeId),
+                            kind: 'flow',
+                            packageName: '@hazeljs/flow',
+                            sourceType: 'method',
+                            className,
+                            methodName,
+                            flowId,
+                            version,
+                            nodeName: nodeId,
+                            entryNode: isEntry ? nodeId : undefined,
+                            edges: edgesStr || undefined,
+                        });
+                    }
+                }
+            }
+        }
+        return entries;
+    },
+};

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

@@ -0,0 +1,8 @@
+/**
+ * GraphQL inspector plugin - inspects @Resolver with @Query/@Mutation
+ * Optional: requires @hazeljs/graphql to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const graphqlInspector: HazelInspectorPlugin;
+//# sourceMappingURL=graphql.inspector.d.ts.map

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

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