@salimassili/ai-costguard 1.1.3

package/dist/aerl/index.d.ts

@@ -0,0 +1,170 @@
+/**
+ * AERL - AI Execution Reliability Layer
+ *
+ * Runtime reliability system for autonomous AI agents.
+ * Ensures agents succeed reliably, safely, and cost-predictably.
+ *
+ * CORE MODULES:
+ * - ExecutionInterceptor: <5ms decision engine
+ * - ReliabilityEngine: 0-1 reliability scoring
+ * - ExecutionGraph: Multi-step workflow tracking
+ * - FailurePrediction: Pre-execution failure prediction
+ * - RecoveryEngine: Alternative execution paths
+ * - ExecutionMemory: Hashed pattern storage
+ * - ReliabilityTelemetry: ROI + success tracking
+ *
+ * USAGE:
+ * ```typescript
+ * import { aerl } from 'ai-execution-reliability/aerl';
+ *
+ * // 1. Initialize workflow
+ * aerl.initWorkflow('wf-1', 'sess-1');
+ *
+ * // 2. Intercept each execution
+ * const result = aerl.intercept({
+ *   id: 'step-1',
+ *   provider: 'openai',
+ *   operation: 'chat.completions.create',
+ *   estimatedCost: 0.06,
+ *   context: { sessionId: 'sess-1', workflowId: 'wf-1', stepNumber: 1, ... },
+ *   inputHash: 'sha256-of-input',
+ * });
+ *
+ * // 3. Handle decision
+ * if (result.action === 'block') {
+ *   console.log('Blocked:', result.reason);
+ * } else if (result.action === 'modify') {
+ *   console.log('Using alternative:', result.suggestedModification);
+ * }
+ *
+ * // 4. Track execution in graph
+ * aerl.trackGraph('wf-1', {
+ *   id: 'step-1',
+ *   type: 'llm',
+ *   status: 'running',
+ *   operation: 'chat.completions.create',
+ *   inputHash: 'hash',
+ *   cost: 0.06,
+ *   tokens: 2000,
+ *   durationMs: 1500,
+ *   timestamp: Date.now(),
+ * });
+ *
+ * // 5. Get reliability metrics
+ * const metrics = aerl.getMetrics();
+ * console.log('Success rate:', metrics.successRate);
+ * console.log('Cost saved:', metrics.costSaved);
+ * ```
+ */
+export { ExecutionInterceptor, interceptor } from './ExecutionInterceptor';
+export { ReliabilityEngine, reliabilityEngine } from './ReliabilityEngine';
+export { ExecutionGraphTracker, graphTracker } from './ExecutionGraph';
+export { FailurePredictionSystem, failurePredictor } from './FailurePrediction';
+export { RecoveryEngine, recoveryEngine } from './RecoveryEngine';
+export { ExecutionMemory, executionMemory } from './ExecutionMemory';
+export { ReliabilityTelemetry, reliabilityTelemetry } from './ReliabilityTelemetry';
+import { ExecutionRequest, DecisionResult } from './ExecutionInterceptor';
+import { ExecutionNode } from './ExecutionGraph';
+export interface AERLConfig {
+    failOpen?: boolean;
+    maxLatencyMs?: number;
+    maxCostPerWorkflow?: number;
+    maxStepsPerWorkflow?: number;
+}
+export declare class AERL {
+    private interceptor;
+    private reliabilityEngine;
+    private graphTracker;
+    private failurePredictor;
+    private recoveryEngine;
+    private memory;
+    private telemetry;
+    constructor(config?: AERLConfig);
+    /**
+     * Initialize workflow graph
+     */
+    initWorkflow(workflowId: string, sessionId: string): void;
+    /**
+     * Main interception - allow/block/modify
+     */
+    intercept(request: ExecutionRequest): DecisionResult;
+    /**
+     * Score execution reliability
+     */
+    scoreExecution(context: {
+        sessionId: string;
+        workflowId: string;
+        stepNumber: number;
+        recentResults: ('success' | 'failure' | 'partial')[];
+        totalCost: number;
+        tokenVelocity: number;
+        costVelocity: number;
+    }): import("./ReliabilityEngine").ReliabilityAssessment;
+    /**
+     * Predict failure before execution
+     */
+    predictFailure(workflowId: string, nextOperation: string): import("./FailurePrediction").FailurePrediction;
+    /**
+     * Generate recovery plan
+     */
+    recoverExecution(primaryTool: string, recommendedAction: string, alternativeTool?: string): import("./RecoveryEngine").RecoveryPlan;
+    /**
+     * Track execution in graph
+     */
+    trackGraph(workflowId: string, node: ExecutionNode, dependencies?: string[]): void;
+    /**
+     * Analyze workflow graph
+     */
+    analyzeGraph(workflowId: string): import("./ExecutionGraph").GraphAnalysis;
+    /**
+     * Record execution result
+     */
+    recordResult(requestId: string, actualCost: number, success: boolean): void;
+    /**
+     * Get reliability metrics
+     */
+    getMetrics(): import("./ReliabilityTelemetry").ReliabilityMetrics;
+    /**
+     * Get 7-day report
+     */
+    get7DayReport(): {
+        metrics: import("./ReliabilityTelemetry").ReliabilityMetrics;
+        daily: Array<{
+            date: string;
+            executions: number;
+            successRate: number;
+            costSaved: number;
+            reliabilityScore: number;
+        }>;
+    };
+    /**
+     * Get dashboard summary
+     */
+    getDashboard(): {
+        executionsToday: number;
+        successRateToday: number;
+        costSavedToday: number;
+        totalCostSaved: number;
+        reliability7Day: number;
+        predictionAccuracy: number;
+    };
+    /**
+     * Export CSV
+     */
+    exportCSV(): string;
+    /**
+     * Get interceptor metrics (latency, cache hit rate)
+     */
+    getInterceptorMetrics(): {
+        cacheHitRate: number;
+        blockRate: number;
+        p95LatencyMs: number;
+        totalRequests: number;
+        cacheHits: number;
+        blockedRequests: number;
+        modifiedRequests: number;
+        latencySamples: number[];
+    };
+}
+export declare const aerl: AERL;
+//# sourceMappingURL=index.d.ts.map

package/dist/aerl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aerl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGpF,OAAO,EAAwB,gBAAgB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEhG,OAAO,EAAyB,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMxE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,qBAAa,IAAI;IACf,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,SAAS,CAAuB;gBAE5B,MAAM,GAAE,UAAe;IAoBnC;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAIzD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,cAAc;IAmBpD;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,CAAC,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC,EAAE,CAAC;QACrD,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,CAAC;QACtB,YAAY,EAAE,MAAM,CAAC;KACtB;IAYD;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IAexD;;OAEG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM;IAQzF;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE;IAI3E;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM;IAI/B;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAI3E;;OAEG;IACH,UAAU;IAIV;;OAEG;IACH,aAAa;;;;;;;;;;IAIb;;OAEG;IACH,YAAY;;;;;;;;IAIZ;;OAEG;IACH,SAAS;IAIT;;OAEG;IACH,qBAAqB;;;;;;;;;;CAGtB;AAGD,eAAO,MAAM,IAAI,MAAa,CAAC"}

package/dist/aerl/index.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * AERL - AI Execution Reliability Layer
+ *
+ * Runtime reliability system for autonomous AI agents.
+ * Ensures agents succeed reliably, safely, and cost-predictably.
+ *
+ * CORE MODULES:
+ * - ExecutionInterceptor: <5ms decision engine
+ * - ReliabilityEngine: 0-1 reliability scoring
+ * - ExecutionGraph: Multi-step workflow tracking
+ * - FailurePrediction: Pre-execution failure prediction
+ * - RecoveryEngine: Alternative execution paths
+ * - ExecutionMemory: Hashed pattern storage
+ * - ReliabilityTelemetry: ROI + success tracking
+ *
+ * USAGE:
+ * ```typescript
+ * import { aerl } from 'ai-execution-reliability/aerl';
+ *
+ * // 1. Initialize workflow
+ * aerl.initWorkflow('wf-1', 'sess-1');
+ *
+ * // 2. Intercept each execution
+ * const result = aerl.intercept({
+ *   id: 'step-1',
+ *   provider: 'openai',
+ *   operation: 'chat.completions.create',
+ *   estimatedCost: 0.06,
+ *   context: { sessionId: 'sess-1', workflowId: 'wf-1', stepNumber: 1, ... },
+ *   inputHash: 'sha256-of-input',
+ * });
+ *
+ * // 3. Handle decision
+ * if (result.action === 'block') {
+ *   console.log('Blocked:', result.reason);
+ * } else if (result.action === 'modify') {
+ *   console.log('Using alternative:', result.suggestedModification);
+ * }
+ *
+ * // 4. Track execution in graph
+ * aerl.trackGraph('wf-1', {
+ *   id: 'step-1',
+ *   type: 'llm',
+ *   status: 'running',
+ *   operation: 'chat.completions.create',
+ *   inputHash: 'hash',
+ *   cost: 0.06,
+ *   tokens: 2000,
+ *   durationMs: 1500,
+ *   timestamp: Date.now(),
+ * });
+ *
+ * // 5. Get reliability metrics
+ * const metrics = aerl.getMetrics();
+ * console.log('Success rate:', metrics.successRate);
+ * console.log('Cost saved:', metrics.costSaved);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aerl = exports.AERL = exports.reliabilityTelemetry = exports.ReliabilityTelemetry = exports.executionMemory = exports.ExecutionMemory = exports.recoveryEngine = exports.RecoveryEngine = exports.failurePredictor = exports.FailurePredictionSystem = exports.graphTracker = exports.ExecutionGraphTracker = exports.reliabilityEngine = exports.ReliabilityEngine = exports.interceptor = exports.ExecutionInterceptor = void 0;
+var ExecutionInterceptor_1 = require("./ExecutionInterceptor");
+Object.defineProperty(exports, "ExecutionInterceptor", { enumerable: true, get: function () { return ExecutionInterceptor_1.ExecutionInterceptor; } });
+Object.defineProperty(exports, "interceptor", { enumerable: true, get: function () { return ExecutionInterceptor_1.interceptor; } });
+var ReliabilityEngine_1 = require("./ReliabilityEngine");
+Object.defineProperty(exports, "ReliabilityEngine", { enumerable: true, get: function () { return ReliabilityEngine_1.ReliabilityEngine; } });
+Object.defineProperty(exports, "reliabilityEngine", { enumerable: true, get: function () { return ReliabilityEngine_1.reliabilityEngine; } });
+var ExecutionGraph_1 = require("./ExecutionGraph");
+Object.defineProperty(exports, "ExecutionGraphTracker", { enumerable: true, get: function () { return ExecutionGraph_1.ExecutionGraphTracker; } });
+Object.defineProperty(exports, "graphTracker", { enumerable: true, get: function () { return ExecutionGraph_1.graphTracker; } });
+var FailurePrediction_1 = require("./FailurePrediction");
+Object.defineProperty(exports, "FailurePredictionSystem", { enumerable: true, get: function () { return FailurePrediction_1.FailurePredictionSystem; } });
+Object.defineProperty(exports, "failurePredictor", { enumerable: true, get: function () { return FailurePrediction_1.failurePredictor; } });
+var RecoveryEngine_1 = require("./RecoveryEngine");
+Object.defineProperty(exports, "RecoveryEngine", { enumerable: true, get: function () { return RecoveryEngine_1.RecoveryEngine; } });
+Object.defineProperty(exports, "recoveryEngine", { enumerable: true, get: function () { return RecoveryEngine_1.recoveryEngine; } });
+var ExecutionMemory_1 = require("./ExecutionMemory");
+Object.defineProperty(exports, "ExecutionMemory", { enumerable: true, get: function () { return ExecutionMemory_1.ExecutionMemory; } });
+Object.defineProperty(exports, "executionMemory", { enumerable: true, get: function () { return ExecutionMemory_1.executionMemory; } });
+var ReliabilityTelemetry_1 = require("./ReliabilityTelemetry");
+Object.defineProperty(exports, "ReliabilityTelemetry", { enumerable: true, get: function () { return ReliabilityTelemetry_1.ReliabilityTelemetry; } });
+Object.defineProperty(exports, "reliabilityTelemetry", { enumerable: true, get: function () { return ReliabilityTelemetry_1.reliabilityTelemetry; } });
+// Unified API
+const ExecutionInterceptor_2 = require("./ExecutionInterceptor");
+const ReliabilityEngine_2 = require("./ReliabilityEngine");
+const ExecutionGraph_2 = require("./ExecutionGraph");
+const FailurePrediction_2 = require("./FailurePrediction");
+const RecoveryEngine_2 = require("./RecoveryEngine");
+const ExecutionMemory_2 = require("./ExecutionMemory");
+const ReliabilityTelemetry_2 = require("./ReliabilityTelemetry");
+class AERL {
+    constructor(config = {}) {
+        this.interceptor = new ExecutionInterceptor_2.ExecutionInterceptor({
+            failOpen: config.failOpen ?? true,
+            maxLatencyMs: config.maxLatencyMs ?? 5,
+            defaultPolicy: {
+                maxCostPerWorkflow: config.maxCostPerWorkflow ?? 50,
+                maxStepsPerWorkflow: config.maxStepsPerWorkflow ?? 100,
+                maxCostPerStep: 10,
+                minReliabilityScore: 0.3,
+            },
+        });
+        this.reliabilityEngine = new ReliabilityEngine_2.ReliabilityEngine();
+        this.graphTracker = new ExecutionGraph_2.ExecutionGraphTracker();
+        this.failurePredictor = new FailurePrediction_2.FailurePredictionSystem();
+        this.recoveryEngine = new RecoveryEngine_2.RecoveryEngine();
+        this.memory = new ExecutionMemory_2.ExecutionMemory();
+        this.telemetry = new ReliabilityTelemetry_2.ReliabilityTelemetry();
+    }
+    /**
+     * Initialize workflow graph
+     */
+    initWorkflow(workflowId, sessionId) {
+        this.graphTracker.initGraph(workflowId, sessionId);
+    }
+    /**
+     * Main interception - allow/block/modify
+     */
+    intercept(request) {
+        const result = this.interceptor.intercept(request);
+        // Log telemetry
+        this.telemetry.log({
+            timestamp: Date.now(),
+            sessionId: request.context.sessionId,
+            workflowId: request.context.workflowId,
+            requestId: request.id,
+            decision: result.action,
+            riskScore: 1 - result.reliabilityScore,
+            reliabilityScore: result.reliabilityScore,
+            estimatedCost: request.estimatedCost,
+            latencyMs: result.latencyMs,
+        });
+        return result;
+    }
+    /**
+     * Score execution reliability
+     */
+    scoreExecution(context) {
+        return this.reliabilityEngine.assess({
+            sessionId: context.sessionId,
+            workflowId: context.workflowId,
+            stepNumber: context.stepNumber,
+            recentResults: context.recentResults,
+            tokenVelocity: context.tokenVelocity,
+            costVelocity: context.costVelocity,
+            toolSwitches: 0,
+        });
+    }
+    /**
+     * Predict failure before execution
+     */
+    predictFailure(workflowId, nextOperation) {
+        const graph = this.graphTracker.analyze(workflowId);
+        const reliability = this.scoreExecution({
+            sessionId: workflowId,
+            workflowId,
+            stepNumber: graph.depth,
+            recentResults: [],
+            totalCost: 0,
+            tokenVelocity: 0,
+            costVelocity: 0,
+        });
+        return this.failurePredictor.predict(workflowId, graph, reliability, nextOperation);
+    }
+    /**
+     * Generate recovery plan
+     */
+    recoverExecution(primaryTool, recommendedAction, alternativeTool) {
+        return this.recoveryEngine.generateRecovery(primaryTool, recommendedAction, alternativeTool);
+    }
+    /**
+     * Track execution in graph
+     */
+    trackGraph(workflowId, node, dependencies) {
+        this.graphTracker.addNode(workflowId, node, dependencies);
+    }
+    /**
+     * Analyze workflow graph
+     */
+    analyzeGraph(workflowId) {
+        return this.graphTracker.analyze(workflowId);
+    }
+    /**
+     * Record execution result
+     */
+    recordResult(requestId, actualCost, success) {
+        this.telemetry.recordResult(requestId, actualCost, success);
+    }
+    /**
+     * Get reliability metrics
+     */
+    getMetrics() {
+        return this.telemetry.getMetrics();
+    }
+    /**
+     * Get 7-day report
+     */
+    get7DayReport() {
+        return this.telemetry.get7DayReport();
+    }
+    /**
+     * Get dashboard summary
+     */
+    getDashboard() {
+        return this.telemetry.getDashboardSummary();
+    }
+    /**
+     * Export CSV
+     */
+    exportCSV() {
+        return this.telemetry.exportCSV();
+    }
+    /**
+     * Get interceptor metrics (latency, cache hit rate)
+     */
+    getInterceptorMetrics() {
+        return this.interceptor.getMetrics();
+    }
+}
+exports.AERL = AERL;
+// Default instance
+exports.aerl = new AERL();
+//# sourceMappingURL=index.js.map

package/dist/aerl/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/aerl/index.ts"],"names":[],"mappings":"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"}

package/dist/ambient/AmbientProtection.d.ts

@@ -0,0 +1,79 @@
+/**
+ * AmbientProtection.ts - Runtime Execution Constraint
+ *
+ * Protection activates automatically on module import.
+ * No function call required. No configuration required.
+ *
+ * import 'ai-costguard'  // → Protection is now active
+ *
+ * This is a runtime enforcement layer, not a tool.
+ * Like TLS for AI calls - always there, automatic, unsafe to remove.
+ */
+/**
+ * AmbientProtection - Runtime constraint that auto-activates
+ *
+ * This module patches the runtime globally when imported.
+ * No developer action required beyond: import 'ai-costguard'
+ */
+export declare class AmbientProtection {
+    private apiKey;
+    private mode;
+    private interceptCount;
+    private blockCount;
+    constructor();
+    /**
+     * Activate ambient protection globally
+     * This patches the runtime without any explicit developer call
+     */
+    private activate;
+    /**
+     * Patch global fetch to intercept AI calls
+     */
+    private patchGlobalFetch;
+    /**
+     * Patch Node.js http/https modules
+     */
+    private patchNodeHTTP;
+    /**
+     * Monitor module imports to detect AI SDK usage
+     */
+    private monitorModuleImports;
+    /**
+     * Check if URL is an AI endpoint
+     */
+    private isAIEndpoint;
+    /**
+     * Evaluate an AI call for blocking
+     */
+    private evaluateCall;
+    /**
+     * Log interception for audit trail
+     */
+    private logInterception;
+    /**
+     * Get current protection status
+     */
+    getStatus(): {
+        active: boolean;
+        mode: string;
+        interceptCount: number;
+        blockCount: number;
+        aiUsageDetected: boolean;
+    };
+    /**
+     * Disable protection (requires explicit call)
+     */
+    disable(): void;
+}
+declare const AMBIENT: AmbientProtection;
+export declare const ambientProtection: AmbientProtection;
+export declare function getAmbientStatus(): {
+    active: boolean;
+    mode: string;
+    interceptCount: number;
+    blockCount: number;
+    aiUsageDetected: boolean;
+};
+export declare function disableAmbientProtection(): void;
+export default AMBIENT;
+//# sourceMappingURL=AmbientProtection.d.ts.map

package/dist/ambient/AmbientProtection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmbientProtection.d.ts","sourceRoot":"","sources":["../../src/ambient/AmbientProtection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAyBH;;;;;GAKG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAuC;IACnD,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,UAAU,CAAK;;IAoBvB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAyBhB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA2DxB;;OAEG;IACH,OAAO,CAAC,aAAa;IAsCrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAO5B;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAmCpB;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,SAAS,IAAI;QACX,MAAM,EAAE,OAAO,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,eAAe,EAAE,OAAO,CAAC;KAC1B;IAUD;;OAEG;IACH,OAAO,IAAI,IAAI;CAIhB;AAID,QAAA,MAAM,OAAO,mBAA0B,CAAC;AAGxC,eAAO,MAAM,iBAAiB,mBAAU,CAAC;AAGzC,wBAAgB,gBAAgB;YAhCpB,OAAO;UACT,MAAM;oBACI,MAAM;gBACV,MAAM;qBACD,OAAO;EA8B3B;AAGD,wBAAgB,wBAAwB,SAEvC;AAGD,eAAe,OAAO,CAAC"}