@hazeljs/inspector 0.2.0-rc.5

package/dist/inspector.module.d.ts

@@ -0,0 +1,25 @@
+/**
+ * InspectorModule - Registers inspector with HazelApp
+ */
+import type { DynamicModule } from '@hazeljs/core';
+import type { InspectorModuleOptions } from './contracts/types';
+/**
+ * Add InspectorModule.forRoot() to your app imports to enable the inspector.
+ *
+ * @example
+ * ```ts
+ * @HazelModule({
+ *   imports: [
+ *     InspectorModule.forRoot({
+ *       inspectorBasePath: '/__hazel',
+ *       developmentOnly: true,
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare const InspectorModule: {
+    forRoot(options?: InspectorModuleOptions): DynamicModule;
+};
+//# sourceMappingURL=inspector.module.d.ts.map

package/dist/inspector.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.module.d.ts","sourceRoot":"","sources":["../src/inspector.module.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAoB,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AA4BlF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe;sBACR,sBAAsB,GAAG,aAAa;CA4CzD,CAAC"}

package/dist/inspector.module.js

@@ -0,0 +1,489 @@
+"use strict";
+/**
+ * InspectorModule - Registers inspector with HazelApp
+ */
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectorModule = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@hazeljs/core");
+const registry_1 = require("./registry/registry");
+const inspector_service_1 = require("./service/inspector.service");
+const core_inspector_1 = require("./plugins/core.inspector");
+const cron_inspector_1 = require("./plugins/cron.inspector");
+const queue_inspector_1 = require("./plugins/queue.inspector");
+const websocket_inspector_1 = require("./plugins/websocket.inspector");
+const agent_inspector_1 = require("./plugins/agent.inspector");
+const ai_inspector_1 = require("./plugins/ai.inspector");
+const rag_inspector_1 = require("./plugins/rag.inspector");
+const prompts_inspector_1 = require("./plugins/prompts.inspector");
+const event_emitter_inspector_1 = require("./plugins/event-emitter.inspector");
+const graphql_inspector_1 = require("./plugins/graphql.inspector");
+const grpc_inspector_1 = require("./plugins/grpc.inspector");
+const kafka_inspector_1 = require("./plugins/kafka.inspector");
+const flow_inspector_1 = require("./plugins/flow.inspector");
+const data_inspector_1 = require("./plugins/data.inspector");
+const serverless_inspector_1 = require("./plugins/serverless.inspector");
+const ml_inspector_1 = require("./plugins/ml.inspector");
+const inspector_config_1 = require("./config/inspector.config");
+const inspector_runtime_1 = require("./runtime/inspector-runtime");
+/** Eagerly resolves InspectorBootstrap so the early handler gets registered */
+let InspectorBootstrapClass = class InspectorBootstrapClass {
+    constructor(_result) { }
+};
+InspectorBootstrapClass = __decorate([
+    (0, core_1.Injectable)(),
+    __param(0, (0, core_1.Inject)('InspectorBootstrap')),
+    __metadata("design:paramtypes", [Object])
+], InspectorBootstrapClass);
+/**
+ * Add InspectorModule.forRoot() to your app imports to enable the inspector.
+ *
+ * @example
+ * ```ts
+ * @HazelModule({
+ *   imports: [
+ *     InspectorModule.forRoot({
+ *       inspectorBasePath: '/__hazel',
+ *       developmentOnly: true,
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+exports.InspectorModule = {
+    forRoot(options) {
+        const config = (0, inspector_config_1.mergeInspectorConfig)(options);
+        const inspectorProvider = {
+            provide: 'InspectorBootstrap',
+            useFactory: () => {
+                if (!(0, inspector_config_1.shouldExposeInspector)(config))
+                    return null;
+                const container = core_1.Container.getInstance();
+                const app = container.resolve(core_1.HazelApp);
+                const registry = new registry_1.HazelInspectorRegistry();
+                const service = new inspector_service_1.HazelInspectorService(registry, config);
+                registry.register(core_inspector_1.coreInspector);
+                registry.register(cron_inspector_1.cronInspector);
+                registry.register(queue_inspector_1.queueInspector);
+                registry.register(websocket_inspector_1.websocketInspector);
+                registry.register(agent_inspector_1.agentInspector);
+                registry.register(ai_inspector_1.aiInspector);
+                registry.register(rag_inspector_1.ragInspector);
+                registry.register(prompts_inspector_1.promptsInspector);
+                registry.register(event_emitter_inspector_1.eventEmitterInspector);
+                registry.register(graphql_inspector_1.graphqlInspector);
+                registry.register(grpc_inspector_1.grpcInspector);
+                registry.register(kafka_inspector_1.kafkaInspector);
+                registry.register(flow_inspector_1.flowInspector);
+                registry.register(data_inspector_1.dataInspector);
+                registry.register(serverless_inspector_1.serverlessInspector);
+                registry.register(ml_inspector_1.mlInspector);
+                const basePath = config.inspectorBasePath ?? '/__hazel';
+                const handler = createInspectorHandler(service, config, app);
+                app.addEarlyHandler(basePath, handler);
+                return true;
+            },
+            inject: [],
+        };
+        return {
+            module: class InspectorRootModule {
+            },
+            providers: [inspectorProvider, InspectorBootstrapClass],
+        };
+    },
+};
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunk && chunks.push(chunk));
+        req.on('end', () => {
+            try {
+                const raw = Buffer.concat(chunks).toString('utf8');
+                resolve(raw ? JSON.parse(raw) : {});
+            }
+            catch {
+                reject(new Error('Invalid JSON body'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function createInspectorHandler(service, config, app) {
+    return async (req, res) => {
+        const url = req.url?.split('?')[0] ?? '/';
+        const basePath = config.inspectorBasePath ?? '/__hazel';
+        const pathSeg = url.replace(basePath, '') || '/';
+        try {
+            if (pathSeg === '/' || pathSeg === '') {
+                if (config.exposeUi) {
+                    const uiPath = path_1.default.join(__dirname, '..', 'ui-dist', 'index.html');
+                    if (fs_1.default.existsSync(uiPath)) {
+                        res.setHeader('Content-Type', 'text/html');
+                        res.writeHead(200);
+                        res.end(fs_1.default.readFileSync(uiPath, 'utf-8'));
+                        return;
+                    }
+                }
+            }
+            if (config.exposeUi && pathSeg.startsWith('/assets/')) {
+                const assetPath = path_1.default.join(__dirname, '..', 'ui-dist', pathSeg);
+                if (fs_1.default.existsSync(assetPath) &&
+                    assetPath.startsWith(path_1.default.join(__dirname, '..', 'ui-dist'))) {
+                    const ext = path_1.default.extname(assetPath);
+                    const types = {
+                        '.js': 'application/javascript',
+                        '.css': 'text/css',
+                    };
+                    res.setHeader('Content-Type', types[ext] ?? 'application/octet-stream');
+                    res.writeHead(200);
+                    res.end(fs_1.default.readFileSync(assetPath, 'utf-8'));
+                    return;
+                }
+            }
+            if (pathSeg === '/stats' || pathSeg === '/stats/') {
+                const mem = process.memoryUsage();
+                const uptime = process.uptime();
+                res.setHeader('Content-Type', 'application/json');
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    memory: { rss: mem.rss, heapUsed: mem.heapUsed, heapTotal: mem.heapTotal },
+                    uptimeSeconds: Math.floor(uptime),
+                    nodeVersion: process.version,
+                    nodeEnv: process.env.NODE_ENV ?? 'development',
+                    inspectorVersion: '0.2.0-rc.2',
+                }));
+                return;
+            }
+            if (pathSeg === '/env' || pathSeg === '/env/') {
+                res.setHeader('Content-Type', 'application/json');
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    nodeVersion: process.version,
+                    nodeEnv: process.env.NODE_ENV ?? 'development',
+                    inspectorVersion: '0.2.0-rc.2',
+                    platform: process.platform,
+                    arch: process.arch,
+                }));
+                return;
+            }
+            if ((pathSeg === '/prompts/render' || pathSeg === '/prompts/render/') &&
+                req.method === 'POST') {
+                const body = await readJsonBody(req);
+                const key = body?.key;
+                const variables = body?.variables ?? {};
+                if (!key || typeof key !== 'string') {
+                    res.setHeader('Content-Type', 'application/json');
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: 'Missing or invalid "key" in request body' }));
+                    return;
+                }
+                try {
+                    const promptsMod = require('@hazeljs/prompts');
+                    const template = promptsMod.PromptRegistry.get(key);
+                    const rendered = template.render(variables);
+                    const tokenEstimate = Math.ceil(rendered.length / 4);
+                    res.setHeader('Content-Type', 'application/json');
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ rendered, tokenEstimate, template: template.template }));
+                }
+                catch (err) {
+                    res.setHeader('Content-Type', 'application/json');
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: String(err) }));
+                }
+                return;
+            }
+            res.setHeader('Content-Type', 'application/json');
+            const context = {
+                moduleType: app.getModuleType(),
+                container: app.getContainer(),
+                router: app.getRouter(),
+            };
+            const rawSnapshot = await service.collectSnapshot(context);
+            // Normalize response so UI never receives non-array entries or non-object summary
+            const snapshot = {
+                ...rawSnapshot,
+                entries: Array.isArray(rawSnapshot?.entries) ? rawSnapshot.entries : [],
+                summary: rawSnapshot?.summary && typeof rawSnapshot.summary === 'object'
+                    ? rawSnapshot.summary
+                    : {},
+            };
+            // Augment with gateway, discovery, resilience overview when available
+            const overview = {};
+            try {
+                const [gatewayData, discoveryData, resilienceData] = await Promise.all([
+                    inspector_runtime_1.InspectorRuntime.getGatewayOverview(),
+                    inspector_runtime_1.InspectorRuntime.getDiscoveryOverview(),
+                    inspector_runtime_1.InspectorRuntime.getResilienceOverview(),
+                ]);
+                if (gatewayData)
+                    overview.gateway = gatewayData;
+                if (discoveryData)
+                    overview.discovery = discoveryData;
+                if (resilienceData)
+                    overview.resilience = resilienceData;
+            }
+            catch {
+                // ignore
+            }
+            if (Object.keys(overview).length > 0) {
+                snapshot.overview = overview;
+            }
+            if (pathSeg === '/inspect' || pathSeg === '/inspect/') {
+                res.writeHead(200);
+                res.end(JSON.stringify(snapshot));
+                return;
+            }
+            if (pathSeg === '/routes' || pathSeg === '/routes/') {
+                const routes = snapshot.entries.filter((e) => e.kind === 'route');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: routes }));
+                return;
+            }
+            if (pathSeg === '/modules' || pathSeg === '/modules/') {
+                const modules = snapshot.entries.filter((e) => e.kind === 'module');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: modules }));
+                return;
+            }
+            if (pathSeg === '/providers' || pathSeg === '/providers/') {
+                const providers = snapshot.entries.filter((e) => e.kind === 'provider');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: providers }));
+                return;
+            }
+            if (pathSeg === '/jobs' || pathSeg === '/jobs/') {
+                const jobs = snapshot.entries.filter((e) => e.kind === 'cron');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: jobs }));
+                return;
+            }
+            if (pathSeg === '/queues' || pathSeg === '/queues/') {
+                const queues = snapshot.entries.filter((e) => e.kind === 'queue');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: queues }));
+                return;
+            }
+            if (pathSeg === '/websocket' || pathSeg === '/websocket/') {
+                const ws = snapshot.entries.filter((e) => e.kind === 'websocket');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: ws }));
+                return;
+            }
+            if (pathSeg === '/agents' || pathSeg === '/agents/') {
+                const agents = snapshot.entries.filter((e) => e.kind === 'agent');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: agents }));
+                return;
+            }
+            const agentRunMatch = pathSeg.match(/^\/agents\/([^/]+)\/run\/?$/);
+            if (agentRunMatch && req.method === 'POST') {
+                const agentName = decodeURIComponent(agentRunMatch[1]);
+                const body = await readJsonBody(req);
+                const input = typeof body?.input === 'string' ? body.input : JSON.stringify(body ?? {});
+                try {
+                    const { AgentService } = require('@hazeljs/agent');
+                    const container = app.getContainer();
+                    const svc = container.resolve(AgentService);
+                    if (!svc?.execute) {
+                        res.writeHead(503);
+                        res.end(JSON.stringify({ error: 'AgentService not found. Ensure AgentModule is configured.' }));
+                        return;
+                    }
+                    const result = await svc.execute(agentName, input);
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ result }));
+                }
+                catch (err) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: String(err) }));
+                }
+                return;
+            }
+            if (pathSeg === '/rag' || pathSeg === '/rag/') {
+                const rag = snapshot.entries.filter((e) => e.kind === 'rag');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: rag }));
+                return;
+            }
+            const ragSearchMatch = pathSeg.match(/^\/rag\/([^/]+)\/search\/?$/);
+            if (ragSearchMatch && req.method === 'GET') {
+                const _pipeline = decodeURIComponent(ragSearchMatch[1]);
+                const q = (req.url?.includes('?')
+                    ? new URL(req.url, 'http://localhost').searchParams.get('q')
+                    : null) ?? '';
+                try {
+                    const _ragMod = require('@hazeljs/rag');
+                    const container = app.getContainer();
+                    const tokensRaw = container.getTokens?.() ?? [];
+                    const tokens = Array.isArray(tokensRaw) ? tokensRaw : [];
+                    let ragService = null;
+                    for (const token of tokens) {
+                        try {
+                            const svc = container.resolve(token);
+                            if (svc && typeof svc.search === 'function') {
+                                ragService = svc;
+                                break;
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    if (!ragService?.search) {
+                        res.writeHead(503);
+                        res.end(JSON.stringify({
+                            error: 'RAG service not found. Ensure a RAG pipeline is registered.',
+                        }));
+                        return;
+                    }
+                    const results = await ragService.search(q, { topK: 10 });
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ results: results ?? [] }));
+                }
+                catch (err) {
+                    res.writeHead(500);
+                    res.end(JSON.stringify({ error: String(err) }));
+                }
+                return;
+            }
+            if (pathSeg === '/prompts' || pathSeg === '/prompts/') {
+                const prompts = snapshot.entries.filter((e) => e.kind === 'prompt');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: prompts }));
+                return;
+            }
+            if ((pathSeg === '/prompts/render' || pathSeg === '/prompts/render/') &&
+                req.method === 'POST') {
+                const body = await readJsonBody(req);
+                const key = body?.key;
+                const variables = body?.variables ?? {};
+                if (!key || typeof key !== 'string') {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: 'Missing or invalid "key" in request body' }));
+                    return;
+                }
+                try {
+                    const promptsMod = require('@hazeljs/prompts');
+                    const template = promptsMod.PromptRegistry.get(key);
+                    const rendered = template.render(variables);
+                    const tokenEstimate = Math.ceil(rendered.length / 4);
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ rendered, tokenEstimate, template: template.template }));
+                }
+                catch (err) {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: String(err) }));
+                }
+                return;
+            }
+            if (pathSeg === '/aifunctions' || pathSeg === '/aifunctions/') {
+                const aifunctions = snapshot.entries.filter((e) => e.kind === 'aifunction');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: aifunctions }));
+                return;
+            }
+            if (pathSeg === '/events' || pathSeg === '/events/') {
+                const events = snapshot.entries.filter((e) => e.kind === 'event');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: events }));
+                return;
+            }
+            if (pathSeg === '/graphql' || pathSeg === '/graphql/') {
+                const graphql = snapshot.entries.filter((e) => e.kind === 'graphql');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: graphql }));
+                return;
+            }
+            if (pathSeg === '/grpc' || pathSeg === '/grpc/') {
+                const grpc = snapshot.entries.filter((e) => e.kind === 'grpc');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: grpc }));
+                return;
+            }
+            if (pathSeg === '/kafka' || pathSeg === '/kafka/') {
+                const kafka = snapshot.entries.filter((e) => e.kind === 'kafka');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: kafka }));
+                return;
+            }
+            if (pathSeg === '/flows' || pathSeg === '/flows/') {
+                const flows = snapshot.entries.filter((e) => e.kind === 'flow');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: flows }));
+                return;
+            }
+            if (pathSeg === '/data' || pathSeg === '/data/') {
+                const data = snapshot.entries.filter((e) => e.kind === 'data');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: data }));
+                return;
+            }
+            if (pathSeg === '/serverless' || pathSeg === '/serverless/') {
+                const serverless = snapshot.entries.filter((e) => e.kind === 'serverless');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: serverless }));
+                return;
+            }
+            if (pathSeg === '/ml' || pathSeg === '/ml/') {
+                const ml = snapshot.entries.filter((e) => e.kind === 'ml');
+                res.writeHead(200);
+                res.end(JSON.stringify({ entries: ml }));
+                return;
+            }
+            if (pathSeg === '/' || pathSeg === '') {
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    inspector: true,
+                    summary: snapshot.summary,
+                    endpoints: [
+                        '/inspect',
+                        '/routes',
+                        '/modules',
+                        '/providers',
+                        '/jobs',
+                        '/queues',
+                        '/websocket',
+                        '/agents',
+                        '/rag',
+                        '/prompts',
+                        '/aifunctions',
+                        '/events',
+                        '/graphql',
+                        '/grpc',
+                        '/kafka',
+                        '/flows',
+                        '/data',
+                        '/serverless',
+                        '/ml',
+                        '/stats',
+                    ],
+                }));
+                return;
+            }
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: 'Not found', path: pathSeg }));
+        }
+        catch (err) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: String(err) }));
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Agent inspector plugin - inspects @Agent decorated classes and their tools
+ * Optional: requires @hazeljs/agent to be installed
+ */
+import 'reflect-metadata';
+import type { HazelInspectorPlugin } from '../contracts/types';
+export declare const agentInspector: HazelInspectorPlugin;
+//# sourceMappingURL=agent.inspector.d.ts.map

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

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

package/dist/plugins/agent.inspector.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Agent inspector plugin - inspects @Agent decorated classes and their tools
+ * Optional: requires @hazeljs/agent to be installed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentInspector = void 0;
+require("reflect-metadata");
+function createId(...parts) {
+    return parts.filter(Boolean).join(':');
+}
+function tryGetAgentModule() {
+    try {
+        return require('@hazeljs/agent');
+    }
+    catch {
+        return null;
+    }
+}
+exports.agentInspector = {
+    name: 'agent',
+    version: '1.0.0',
+    supports: () => tryGetAgentModule() !== null,
+    inspect: async (context) => {
+        const agentMod = tryGetAgentModule();
+        if (!agentMod)
+            return [];
+        const entries = [];
+        const tokens = context.container.getTokens?.() ?? [];
+        for (const token of tokens) {
+            if (typeof token !== 'function')
+                continue;
+            if (!agentMod.isAgent(token))
+                continue;
+            const meta = agentMod.getAgentMetadata(token);
+            const tools = agentMod.getAgentTools(token);
+            const className = token.name ?? 'Unknown';
+            entries.push({
+                id: createId('agent', meta?.name ?? className),
+                kind: 'agent',
+                packageName: '@hazeljs/agent',
+                sourceType: 'class',
+                className,
+                agentName: meta?.name ?? className,
+                tools: tools.length > 0 ? tools : undefined,
+                model: meta?.model,
+            });
+        }
+        return entries;
+    },
+};

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

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

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

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