monomind 1.11.13 → 1.11.14

package/packages/@monomind/cli/dist/src/eval/dataset-runner.js

@@ -0,0 +1,59 @@
+/**
+ * DatasetRunner - Run eval datasets against agents and detect regressions (Task 33)
+ */
+import { randomUUID } from 'crypto';
+export class DatasetRunner {
+    /**
+     * Run all traces through the agent runner and compute stats.
+     * Optionally compare against a baseline to detect regressions.
+     */
+    async run(opts) {
+        const { datasetId, agentVersion, traces, agentRunner, baselineResult, regressionThreshold = 0.1, } = opts;
+        const results = [];
+        for (const trace of traces) {
+            const result = await agentRunner(trace);
+            results.push({ trace, result });
+        }
+        const passCount = results.filter((r) => r.result.outcome === 'success').length;
+        const failCount = results.length - passCount;
+        const totalQuality = results.reduce((sum, r) => sum + r.result.qualityScore, 0);
+        const totalLatency = results.reduce((sum, r) => sum + r.result.latencyMs, 0);
+        const avgQualityScore = results.length > 0 ? totalQuality / results.length : 0;
+        const avgLatencyMs = results.length > 0 ? totalLatency / results.length : 0;
+        // Regression detection
+        const regressionDetails = [];
+        let regressionDetected = false;
+        if (baselineResult) {
+            const delta = baselineResult.avgQualityScore - avgQualityScore;
+            if (delta > regressionThreshold) {
+                regressionDetected = true;
+                // Report per-trace regressions for traces with quality below baseline average
+                for (const { trace, result } of results) {
+                    if (result.qualityScore < baselineResult.avgQualityScore) {
+                        regressionDetails.push({
+                            traceId: trace.traceId,
+                            agentSlug: trace.agentSlug,
+                            baselineScore: baselineResult.avgQualityScore,
+                            currentScore: result.qualityScore,
+                            delta: baselineResult.avgQualityScore - result.qualityScore,
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            runId: randomUUID(),
+            datasetId,
+            runAt: new Date().toISOString(),
+            agentVersion,
+            entriesTested: results.length,
+            passCount,
+            failCount,
+            avgQualityScore,
+            avgLatencyMs,
+            regressionDetected,
+            regressionDetails,
+        };
+    }
+}
+//# sourceMappingURL=dataset-runner.js.map

package/packages/@monomind/cli/dist/src/eval/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Eval Module - Automated eval dataset from production traces (Task 33)
+ */
+export { TraceCollector } from './trace-collector.js';
+export type { RecordTraceInput } from './trace-collector.js';
+export { DatasetManager } from './dataset-manager.js';
+export type { CreateFromTracesOpts } from './dataset-manager.js';
+export { DatasetRunner } from './dataset-runner.js';
+export type { AgentRunnerResult, DatasetRunOpts } from './dataset-runner.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/eval/index.js

@@ -0,0 +1,7 @@
+/**
+ * Eval Module - Automated eval dataset from production traces (Task 33)
+ */
+export { TraceCollector } from './trace-collector.js';
+export { DatasetManager } from './dataset-manager.js';
+export { DatasetRunner } from './dataset-runner.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/eval/trace-collector.d.ts

@@ -0,0 +1,40 @@
+import type { EvalTrace } from '../../../shared/src/types/eval.js';
+export interface RecordTraceInput {
+    agentSlug: string;
+    agentVersion: string;
+    taskDescription: string;
+    taskInput: string;
+    agentOutput: string;
+    retryCount: number;
+    qualityScore?: number;
+    outcome: 'success' | 'failure' | 'timeout';
+    latencyMs: number;
+    tokenCount?: number;
+    costUsd?: number;
+    correctedOutput?: string;
+}
+export declare class TraceCollector {
+    private filePath;
+    constructor(filePath: string);
+    /**
+     * Determine auto review status based on trace quality signals.
+     */
+    autoReviewStatus(input: RecordTraceInput): 'pending' | 'approved';
+    /**
+     * Auto-generate tags based on trace characteristics.
+     */
+    autoTag(input: RecordTraceInput): string[];
+    /**
+     * Record a trace, auto-generating traceId, capturedAt, reviewStatus, and tags.
+     */
+    record(input: RecordTraceInput): EvalTrace;
+    /**
+     * Read all traces from the JSONL file.
+     */
+    readAll(): EvalTrace[];
+    /**
+     * Get traces pending review, with optional limit.
+     */
+    getTracesPendingReview(limit?: number): EvalTrace[];
+}
+//# sourceMappingURL=trace-collector.d.ts.map

package/packages/@monomind/cli/dist/src/eval/trace-collector.js

@@ -0,0 +1,102 @@
+/**
+ * TraceCollector - JSONL-based production trace collection (Task 33)
+ */
+import { randomUUID } from 'crypto';
+import { appendFileSync, readFileSync, existsSync, statSync } from 'fs';
+import { parseJsonl } from '../utils/parse-jsonl.js';
+export class TraceCollector {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /**
+     * Determine auto review status based on trace quality signals.
+     */
+    autoReviewStatus(input) {
+        if (input.retryCount > 1)
+            return 'pending';
+        if (input.qualityScore !== undefined && input.qualityScore < 0.6)
+            return 'pending';
+        if (input.outcome === 'failure')
+            return 'pending';
+        return 'approved';
+    }
+    /**
+     * Auto-generate tags based on trace characteristics.
+     */
+    autoTag(input) {
+        const tags = [];
+        if (input.retryCount > 1)
+            tags.push('high-retry');
+        if (input.outcome === 'failure')
+            tags.push('failure');
+        if (input.outcome === 'timeout')
+            tags.push('timeout');
+        return tags;
+    }
+    /**
+     * Record a trace, auto-generating traceId, capturedAt, reviewStatus, and tags.
+     */
+    record(input) {
+        const trace = {
+            traceId: randomUUID(),
+            agentSlug: input.agentSlug,
+            agentVersion: input.agentVersion,
+            taskDescription: input.taskDescription,
+            taskInput: input.taskInput,
+            agentOutput: input.agentOutput,
+            retryCount: input.retryCount,
+            qualityScore: input.qualityScore,
+            outcome: input.outcome,
+            latencyMs: input.latencyMs,
+            tokenCount: input.tokenCount,
+            costUsd: input.costUsd,
+            capturedAt: new Date().toISOString(),
+            reviewStatus: this.autoReviewStatus(input),
+            correctedOutput: input.correctedOutput,
+            tags: this.autoTag(input),
+        };
+        // Defensive serialization — agent outputs may contain circular references
+        // or BigInt; without this guard the writer crashes mid-trace.
+        let serialized;
+        try {
+            serialized = JSON.stringify(trace);
+        }
+        catch {
+            serialized = JSON.stringify({
+                traceId: trace.traceId,
+                agentSlug: trace.agentSlug,
+                capturedAt: trace.capturedAt,
+                reviewStatus: trace.reviewStatus,
+                outcome: 'serialize_failed',
+            });
+        }
+        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
+        return trace;
+    }
+    /**
+     * Read all traces from the JSONL file.
+     */
+    readAll() {
+        if (!existsSync(this.filePath))
+            return [];
+        const stat = statSync(this.filePath);
+        if (stat.size > 256 * 1024 * 1024) {
+            throw new Error(`Trace file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
+        }
+        const content = readFileSync(this.filePath, 'utf-8').trim();
+        if (!content)
+            return [];
+        return parseJsonl(content);
+    }
+    /**
+     * Get traces pending review, with optional limit.
+     */
+    getTracesPendingReview(limit) {
+        const all = this.readAll().filter((t) => t.reviewStatus === 'pending');
+        if (limit !== undefined)
+            return all.slice(0, limit);
+        return all;
+    }
+}
+//# sourceMappingURL=trace-collector.js.map

package/packages/@monomind/cli/dist/src/infrastructure/in-memory-repositories.d.ts

@@ -0,0 +1,68 @@
+/**
+ * In-Memory Repositories - CLI Infrastructure
+ *
+ * Lightweight in-memory implementations for CLI use.
+ *
+ * @module v1/cli/infrastructure
+ */
+import { Agent, AgentStatus, AgentRole } from '../../../swarm/src/domain/entities/agent.js';
+import { Task, TaskStatus, TaskPriority } from '../../../swarm/src/domain/entities/task.js';
+import { IAgentRepository, AgentQueryOptions, AgentStatistics } from '../../../swarm/src/domain/repositories/agent-repository.interface.js';
+import { ITaskRepository, TaskQueryOptions, TaskStatistics } from '../../../swarm/src/domain/repositories/task-repository.interface.js';
+/**
+ * In-Memory Agent Repository
+ */
+export declare class InMemoryAgentRepository implements IAgentRepository {
+    private agents;
+    private initialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    clear(): Promise<void>;
+    save(agent: Agent): Promise<void>;
+    findById(id: string): Promise<Agent | null>;
+    findByName(name: string): Promise<Agent | null>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    saveMany(agents: Agent[]): Promise<void>;
+    findByIds(ids: string[]): Promise<Agent[]>;
+    deleteMany(ids: string[]): Promise<number>;
+    findAll(options?: AgentQueryOptions): Promise<Agent[]>;
+    findByStatus(status: AgentStatus): Promise<Agent[]>;
+    findByRole(role: AgentRole): Promise<Agent[]>;
+    findByDomain(domain: string): Promise<Agent[]>;
+    findByParent(parentId: string): Promise<Agent[]>;
+    findByCapability(capability: string): Promise<Agent[]>;
+    findAvailable(): Promise<Agent[]>;
+    getStatistics(): Promise<AgentStatistics>;
+    count(options?: AgentQueryOptions): Promise<number>;
+}
+/**
+ * In-Memory Task Repository
+ */
+export declare class InMemoryTaskRepository implements ITaskRepository {
+    private tasks;
+    private initialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    clear(): Promise<void>;
+    save(task: Task): Promise<void>;
+    findById(id: string): Promise<Task | null>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): Promise<boolean>;
+    saveMany(tasks: Task[]): Promise<void>;
+    findByIds(ids: string[]): Promise<Task[]>;
+    deleteMany(ids: string[]): Promise<number>;
+    findAll(options?: TaskQueryOptions): Promise<Task[]>;
+    findByStatus(status: TaskStatus): Promise<Task[]>;
+    findByPriority(priority: TaskPriority): Promise<Task[]>;
+    findByAgent(agentId: string): Promise<Task[]>;
+    findPending(): Promise<Task[]>;
+    findQueued(): Promise<Task[]>;
+    findRunning(): Promise<Task[]>;
+    findTimedOut(): Promise<Task[]>;
+    getNextTask(agentCapabilities?: string[]): Promise<Task | null>;
+    getTaskQueue(limit?: number): Promise<Task[]>;
+    getStatistics(): Promise<TaskStatistics>;
+    count(options?: TaskQueryOptions): Promise<number>;
+}
+//# sourceMappingURL=in-memory-repositories.d.ts.map

package/packages/@monomind/cli/dist/src/infrastructure/in-memory-repositories.js

@@ -0,0 +1,264 @@
+/**
+ * In-Memory Repositories - CLI Infrastructure
+ *
+ * Lightweight in-memory implementations for CLI use.
+ *
+ * @module v1/cli/infrastructure
+ */
+/**
+ * In-Memory Agent Repository
+ */
+export class InMemoryAgentRepository {
+    agents = new Map();
+    initialized = false;
+    async initialize() {
+        this.initialized = true;
+    }
+    async shutdown() {
+        this.agents.clear();
+        this.initialized = false;
+    }
+    async clear() {
+        this.agents.clear();
+    }
+    async save(agent) {
+        this.agents.set(agent.id, agent);
+    }
+    async findById(id) {
+        return this.agents.get(id) ?? null;
+    }
+    async findByName(name) {
+        for (const agent of this.agents.values()) {
+            if (agent.name === name)
+                return agent;
+        }
+        return null;
+    }
+    async delete(id) {
+        return this.agents.delete(id);
+    }
+    async exists(id) {
+        return this.agents.has(id);
+    }
+    async saveMany(agents) {
+        for (const agent of agents) {
+            this.agents.set(agent.id, agent);
+        }
+    }
+    async findByIds(ids) {
+        return ids.map((id) => this.agents.get(id)).filter((a) => a !== undefined);
+    }
+    async deleteMany(ids) {
+        let deleted = 0;
+        for (const id of ids) {
+            if (this.agents.delete(id))
+                deleted++;
+        }
+        return deleted;
+    }
+    async findAll(options) {
+        let result = Array.from(this.agents.values());
+        if (options?.status)
+            result = result.filter((a) => a.status === options.status);
+        if (options?.role)
+            result = result.filter((a) => a.role === options.role);
+        if (options?.domain)
+            result = result.filter((a) => a.domain === options.domain);
+        if (options?.limit)
+            result = result.slice(0, options.limit);
+        return result;
+    }
+    async findByStatus(status) {
+        return this.findAll({ status });
+    }
+    async findByRole(role) {
+        return this.findAll({ role });
+    }
+    async findByDomain(domain) {
+        return this.findAll({ domain });
+    }
+    async findByParent(parentId) {
+        return Array.from(this.agents.values()).filter((a) => a.parentId === parentId);
+    }
+    async findByCapability(capability) {
+        return Array.from(this.agents.values()).filter((a) => a.hasCapability(capability));
+    }
+    async findAvailable() {
+        return Array.from(this.agents.values()).filter((a) => a.isAvailable());
+    }
+    async getStatistics() {
+        const agents = Array.from(this.agents.values());
+        const byStatus = {
+            idle: 0,
+            active: 0,
+            busy: 0,
+            paused: 0,
+            terminated: 0,
+            error: 0,
+        };
+        const byRole = {};
+        const byDomain = {};
+        let totalCompleted = 0;
+        let totalUtilization = 0;
+        for (const agent of agents) {
+            byStatus[agent.status]++;
+            byRole[agent.role] = (byRole[agent.role] ?? 0) + 1;
+            byDomain[agent.domain] = (byDomain[agent.domain] ?? 0) + 1;
+            totalCompleted += agent.completedTaskCount;
+            totalUtilization += agent.getUtilization();
+        }
+        return {
+            total: agents.length,
+            byStatus,
+            byRole,
+            byDomain,
+            totalTasksCompleted: totalCompleted,
+            averageUtilization: agents.length > 0 ? totalUtilization / agents.length : 0,
+        };
+    }
+    async count(options) {
+        return (await this.findAll(options)).length;
+    }
+}
+/**
+ * In-Memory Task Repository
+ */
+export class InMemoryTaskRepository {
+    tasks = new Map();
+    initialized = false;
+    async initialize() {
+        this.initialized = true;
+    }
+    async shutdown() {
+        this.tasks.clear();
+        this.initialized = false;
+    }
+    async clear() {
+        this.tasks.clear();
+    }
+    async save(task) {
+        this.tasks.set(task.id, task);
+    }
+    async findById(id) {
+        return this.tasks.get(id) ?? null;
+    }
+    async delete(id) {
+        return this.tasks.delete(id);
+    }
+    async exists(id) {
+        return this.tasks.has(id);
+    }
+    async saveMany(tasks) {
+        for (const task of tasks) {
+            this.tasks.set(task.id, task);
+        }
+    }
+    async findByIds(ids) {
+        return ids.map((id) => this.tasks.get(id)).filter((t) => t !== undefined);
+    }
+    async deleteMany(ids) {
+        let deleted = 0;
+        for (const id of ids) {
+            if (this.tasks.delete(id))
+                deleted++;
+        }
+        return deleted;
+    }
+    async findAll(options) {
+        let result = Array.from(this.tasks.values());
+        if (options?.status)
+            result = result.filter((t) => t.status === options.status);
+        if (options?.priority)
+            result = result.filter((t) => t.priority === options.priority);
+        if (options?.type)
+            result = result.filter((t) => t.type === options.type);
+        if (options?.assignedAgentId)
+            result = result.filter((t) => t.assignedAgentId === options.assignedAgentId);
+        if (options?.limit)
+            result = result.slice(0, options.limit);
+        return result;
+    }
+    async findByStatus(status) {
+        return this.findAll({ status });
+    }
+    async findByPriority(priority) {
+        return this.findAll({ priority });
+    }
+    async findByAgent(agentId) {
+        return this.findAll({ assignedAgentId: agentId });
+    }
+    async findPending() {
+        return this.findByStatus('pending');
+    }
+    async findQueued() {
+        return this.findByStatus('queued');
+    }
+    async findRunning() {
+        return this.findByStatus('running');
+    }
+    async findTimedOut() {
+        return Array.from(this.tasks.values()).filter((t) => t.isTimedOut());
+    }
+    async getNextTask(agentCapabilities) {
+        const queued = await this.findQueued();
+        if (queued.length === 0)
+            return null;
+        queued.sort((a, b) => a.comparePriority(b));
+        return queued[0];
+    }
+    async getTaskQueue(limit = 10) {
+        const queued = await this.findQueued();
+        queued.sort((a, b) => a.comparePriority(b));
+        return queued.slice(0, limit);
+    }
+    async getStatistics() {
+        const tasks = Array.from(this.tasks.values());
+        const byStatus = {
+            pending: 0,
+            queued: 0,
+            assigned: 0,
+            running: 0,
+            completed: 0,
+            failed: 0,
+            cancelled: 0,
+        };
+        const byPriority = {
+            critical: 0,
+            high: 0,
+            normal: 0,
+            low: 0,
+        };
+        const byType = {};
+        let totalDuration = 0;
+        let completedCount = 0;
+        let failedCount = 0;
+        let retryTotal = 0;
+        for (const task of tasks) {
+            byStatus[task.status]++;
+            byPriority[task.priority]++;
+            byType[task.type] = (byType[task.type] ?? 0) + 1;
+            if (task.status === 'completed') {
+                completedCount++;
+                const duration = task.getExecutionDuration();
+                if (duration)
+                    totalDuration += duration;
+            }
+            if (task.status === 'failed')
+                failedCount++;
+            retryTotal += task.retryCount;
+        }
+        return {
+            total: tasks.length,
+            byStatus,
+            byPriority,
+            byType,
+            averageExecutionTime: completedCount > 0 ? totalDuration / completedCount : 0,
+            successRate: tasks.length > 0 ? completedCount / tasks.length : 0,
+            retryRate: tasks.length > 0 ? retryTotal / tasks.length : 0,
+        };
+    }
+    async count(options) {
+        return (await this.findAll(options)).length;
+    }
+}
+//# sourceMappingURL=in-memory-repositories.js.map

package/packages/@monomind/cli/dist/src/init/statusline-generator.js

@@ -1149,10 +1149,10 @@ function generateDashboard() {
 
   const hil = getHILPending();
   const hilStr = hil.pending > 0
-    ? \`   \${DIV}   \${x.coral}✨ \${x.bold}\${hil.pending}\${x.reset}\${x.coral} HIL pending\${x.reset}\`
-    : \`\`;
+    ? \`\${x.coral}✨ \${x.bold}\${hil.pending}\${x.reset}\${x.coral} HIL pending\${x.reset}\`
+    : \`\${x.slate}✨ no pending HIL\${x.reset}\`;
 
-  lines.push(\`\${x.teal}🧠  CONTEXT\${x.reset}  \${graphStr}\${hilStr}\`);
+  lines.push(\`\${x.teal}🧠  CONTEXT\${x.reset}  \${graphStr}   \${DIV}   \${hilStr}\`);
 
   return lines.join('\\n');
 }

package/packages/@monomind/cli/dist/src/interactive/interrupt.d.ts

@@ -0,0 +1,22 @@
+export type InterruptDecision = 'approved' | 'rejected' | 'edited';
+export interface InterruptPromptResult {
+    decision: InterruptDecision;
+    editedTask?: string;
+}
+export interface InterruptConfig {
+    interruptBefore: string[];
+    confidenceThreshold?: number;
+    autoApprove?: boolean;
+}
+export declare class InterruptRegistry {
+    private config;
+    load(config: InterruptConfig): void;
+    shouldInterrupt(agentSlug: string, confidence?: number): boolean;
+    getConfig(): InterruptConfig;
+}
+export declare const interruptRegistry: InterruptRegistry;
+export declare class InterruptController {
+    prompt(agentSlug: string, taskDescription: string, checkpointId: string): Promise<InterruptPromptResult>;
+}
+export declare const interruptController: InterruptController;
+//# sourceMappingURL=interrupt.d.ts.map

package/packages/@monomind/cli/dist/src/interactive/interrupt.js

@@ -0,0 +1,71 @@
+import * as readline from 'node:readline';
+export class InterruptRegistry {
+    config = { interruptBefore: [] };
+    load(config) {
+        this.config = config;
+    }
+    shouldInterrupt(agentSlug, confidence) {
+        if (this.config.autoApprove)
+            return false;
+        if (this.config.interruptBefore.includes(agentSlug))
+            return true;
+        if (confidence !== undefined &&
+            this.config.confidenceThreshold !== undefined &&
+            confidence < this.config.confidenceThreshold) {
+            return true;
+        }
+        return false;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}
+export const interruptRegistry = new InterruptRegistry();
+export class InterruptController {
+    async prompt(agentSlug, taskDescription, checkpointId) {
+        // Non-TTY / CI mode
+        if (!process.stdin.isTTY || process.env.CI_AUTO_APPROVE === '1') {
+            return { decision: 'approved' };
+        }
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        // Strip control characters from interpolated fields. ANSI escape sequences
+        // in any of these fields would let a malicious agent or LLM-generated task
+        // description redraw the screen and trick the user into approving an
+        // entirely different action than the one shown — defeating this very gate.
+        const safe = (s) => String(s ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, '?').slice(0, 500);
+        console.log('\n' + '='.repeat(60));
+        console.log('[MONOMIND] Interrupt — Human approval required');
+        console.log(`  Agent:      ${safe(agentSlug)}`);
+        console.log(`  Task:       ${safe(taskDescription)}`);
+        console.log(`  Checkpoint: ${safe(checkpointId)}`);
+        console.log('='.repeat(60));
+        console.log('  Options: [y] approve  [n] reject  [e] edit task');
+        return new Promise((resolve) => {
+            rl.question('  Choice (y/n/e): ', (answer) => {
+                rl.close();
+                const trimmed = answer.trim().toLowerCase();
+                if (trimmed === 'y' || trimmed === 'yes') {
+                    resolve({ decision: 'approved' });
+                }
+                else if (trimmed === 'e' || trimmed === 'edit') {
+                    const rl2 = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout,
+                    });
+                    rl2.question('  New task description: ', (newTask) => {
+                        rl2.close();
+                        resolve({ decision: 'edited', editedTask: newTask });
+                    });
+                }
+                else {
+                    resolve({ decision: 'rejected' });
+                }
+            });
+        });
+    }
+}
+export const interruptController = new InterruptController();
+//# sourceMappingURL=interrupt.js.map

package/packages/@monomind/cli/dist/src/mcp/deprecation-injector.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Deprecation Injector (Task 31)
+ *
+ * Injects deprecation warnings into MCP tool responses when the
+ * invoked tool has been marked as deprecated in the ToolRegistry.
+ */
+import type { ToolRegistry } from './tool-registry.js';
+/**
+ * Injects deprecation metadata into MCP responses.
+ */
+export declare class DeprecationInjector {
+    private readonly registry;
+    constructor(registry: ToolRegistry);
+    /**
+     * If `toolName` is deprecated, augment the response with a warning.
+     *
+     * Returns the original response unmodified when the tool is not
+     * deprecated. When deprecated, adds `_deprecation` metadata.
+     *
+     * Warning format:
+     *   [DEPRECATED] Tool "<name>" is deprecated. <message>. Use "<successor>" instead.
+     */
+    inject(response: Record<string, unknown>, toolName: string): Record<string, unknown>;
+}
+//# sourceMappingURL=deprecation-injector.d.ts.map