@yasserkhanorg/impact-gate 2.0.0

package/dist/base_provider.js

@@ -0,0 +1,203 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = exports.BudgetExceededError = void 0;
+const retry_js_1 = require("./resilience/retry.js");
+const circuit_breaker_js_1 = require("./resilience/circuit_breaker.js");
+/**
+ * Abstract base class for all LLM providers
+ * Eliminates 240+ lines of duplicate stats management code
+ * Provides common functionality for token tracking, cost calculation, and stats management
+ */
+class BudgetExceededError extends Error {
+    constructor(currentCost, budgetUSD) {
+        super(`Budget exceeded: $${currentCost.toFixed(4)} >= $${budgetUSD} limit`);
+        this.currentCost = currentCost;
+        this.budgetUSD = budgetUSD;
+        this.name = 'BudgetExceededError';
+    }
+}
+exports.BudgetExceededError = BudgetExceededError;
+class BaseProvider {
+    constructor() {
+        /** Tracks the current in-flight budget reservation for this provider instance. */
+        this._activeReservation = 0;
+        this.initializeStats();
+    }
+    /** Lazily get-or-create a circuit breaker shared across all instances of this provider type. */
+    get circuitBreaker() {
+        let cb = BaseProvider._sharedBreakers.get(this.name);
+        if (!cb) {
+            cb = new circuit_breaker_js_1.CircuitBreaker({
+                shouldCount: (error) => {
+                    if (error instanceof BudgetExceededError)
+                        return false;
+                    if (!(error instanceof Error))
+                        return true;
+                    const msg = error.message.toLowerCase();
+                    return msg.includes('429') || msg.includes('rate limit') ||
+                        msg.includes('500') || msg.includes('502') || msg.includes('503') || msg.includes('504') ||
+                        msg.includes('econnreset') || msg.includes('econnrefused') || msg.includes('etimedout') ||
+                        msg.includes('overloaded') || msg.includes('socket hang up') || msg.includes('network error');
+                },
+            });
+            BaseProvider._sharedBreakers.set(this.name, cb);
+        }
+        return cb;
+    }
+    /**
+     * Set a hard budget limit. Once totalCost reaches this value,
+     * subsequent calls will throw BudgetExceededError.
+     */
+    setBudget(usd) {
+        this._budgetUSD = usd;
+    }
+    get budgetUSD() {
+        return this._budgetUSD;
+    }
+    /**
+     * Attach a shared budget ledger so aggregate cost across all providers
+     * in a crew run is checked before each LLM call.
+     */
+    setBudgetLedger(ledger) {
+        this._ledger = ledger;
+    }
+    /**
+     * Check budget and pre-reserve estimated cost for the upcoming LLM call.
+     *
+     * When a shared ledger exists, reserves an estimate derived from the provider's
+     * output token cost × maxTokens (default 4096). This blocks parallel agents from
+     * spending into the same headroom — like a credit card authorization hold.
+     *
+     * Self-healing: if a prior call failed without reaching updateStats(), the stale
+     * reservation is released here before placing the new one.
+     */
+    checkBudget() {
+        if (this._ledger) {
+            // Release stale reservation from a prior failed call that never hit updateStats
+            if (this._activeReservation > 0) {
+                this._ledger.release(this._activeReservation);
+                this._activeReservation = 0;
+            }
+            // Reserve estimated cost for the upcoming call
+            const estimate = this.estimateCallCost();
+            this._ledger.reserve(estimate);
+            this._activeReservation = estimate;
+            try {
+                this._ledger.check();
+            }
+            catch (err) {
+                // Budget exceeded — release reservation immediately so it doesn't leak
+                this._ledger.release(estimate);
+                this._activeReservation = 0;
+                throw err;
+            }
+            return;
+        }
+        if (this._budgetUSD !== undefined && this.stats.totalCost >= this._budgetUSD) {
+            throw new BudgetExceededError(this.stats.totalCost, this._budgetUSD);
+        }
+    }
+    /**
+     * Conservative cost estimate for the upcoming call.
+     * Uses maxTokens (or 4096 default) × output cost rate.
+     * Overestimating is safe — the reservation is replaced with actual cost in updateStats.
+     */
+    estimateCallCost() {
+        const outputTokenEstimate = 4096;
+        const costRate = this.capabilities?.costPer1MOutputTokens ?? 15; // default to ~Sonnet
+        return (outputTokenEstimate / 1000000) * costRate;
+    }
+    /**
+     * Initialize stats object with default values
+     */
+    initializeStats() {
+        this.stats = {
+            requestCount: 0,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            averageResponseTimeMs: 0,
+            failedRequests: 0,
+            startTime: new Date(),
+            lastUpdated: new Date(),
+        };
+    }
+    /**
+     * Update stats with new usage data
+     * Maintains rolling average for response time
+     */
+    updateStats(usage, responseTime, cost) {
+        this.stats.requestCount++;
+        this.stats.totalInputTokens += usage.inputTokens;
+        this.stats.totalOutputTokens += usage.outputTokens;
+        this.stats.totalTokens += usage.totalTokens;
+        this.stats.totalCost += cost;
+        if (this._ledger) {
+            // Settle: release the estimate, record actual
+            if (this._activeReservation > 0) {
+                this._ledger.release(this._activeReservation);
+                this._activeReservation = 0;
+            }
+            this._ledger.record(cost);
+        }
+        // Update rolling average response time
+        const totalRequests = this.stats.requestCount;
+        this.stats.averageResponseTimeMs =
+            (this.stats.averageResponseTimeMs * (totalRequests - 1) + responseTime) / totalRequests;
+        this.stats.lastUpdated = new Date();
+    }
+    /**
+     * Get a copy of current usage stats
+     */
+    getUsageStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset all usage stats to initial state
+     */
+    resetUsageStats() {
+        this.initializeStats();
+    }
+    /**
+     * Wrap an async call with circuit breaker + retry logic.
+     * Circuit breaker protects against cascading failures from a down provider;
+     * retry handles transient failures within a healthy circuit.
+     *
+     * Non-transient errors (budget, auth, validation) are thrown directly and
+     * bypass the circuit breaker so they don't incorrectly trip it.
+     */
+    retryCall(fn) {
+        return this.circuitBreaker.call(() => (0, retry_js_1.withRetry)(fn, { maxRetries: 2, baseDelayMs: 1000, maxDelayMs: 10000, jitter: true }), () => { throw new Error(`${this.name} provider circuit open — too many consecutive failures`); });
+    }
+    /**
+     * Calculate cost for token usage, accounting for prompt caching discounts
+     * Cached tokens cost 90% less than regular tokens
+     */
+    calculateCost(usage, costPer1MInputTokens, costPer1MOutputTokens) {
+        // Calculate input token cost
+        let inputCost = 0;
+        // Cached tokens cost 90% less
+        if (usage.cachedTokens) {
+            const cachedCost = (usage.cachedTokens / 1000000) * (costPer1MInputTokens * 0.1);
+            const uncachedInputTokens = usage.inputTokens - usage.cachedTokens;
+            const uncachedCost = (uncachedInputTokens / 1000000) * costPer1MInputTokens;
+            inputCost = cachedCost + uncachedCost;
+        }
+        else {
+            inputCost = (usage.inputTokens / 1000000) * costPer1MInputTokens;
+        }
+        // Calculate output token cost
+        const outputCost = (usage.outputTokens / 1000000) * costPer1MOutputTokens;
+        return inputCost + outputCost;
+    }
+}
+exports.BaseProvider = BaseProvider;
+/**
+ * Shared circuit breakers keyed by provider name (e.g., "anthropic", "openai").
+ * All instances of the same provider type share one breaker, so if Anthropic is
+ * down, ALL agents discover it after 3 total failures instead of 3 × N.
+ */
+BaseProvider._sharedBreakers = new Map();

package/dist/budget_ledger.d.ts

@@ -0,0 +1,28 @@
+export declare class BudgetLedger {
+    private _totalCost;
+    private _reserved;
+    private readonly _limitUSD;
+    constructor(limitUSD: number);
+    get totalCost(): number;
+    get limitUSD(): number;
+    /**
+     * Record actual cost from a completed LLM call.
+     */
+    record(cost: number): void;
+    /**
+     * Pre-reserve estimated cost before an LLM call begins.
+     * Blocks parallel agents from spending into the same headroom.
+     * Like a credit card authorization hold.
+     */
+    reserve(estimate: number): void;
+    /**
+     * Release a prior reservation (after API response or on error).
+     */
+    release(estimate: number): void;
+    /**
+     * Throws BudgetExceededError if committed cost + in-flight reservations
+     * have reached the limit.
+     */
+    check(): void;
+}
+//# sourceMappingURL=budget_ledger.d.ts.map

package/dist/budget_ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget_ledger.d.ts","sourceRoot":"","sources":["../src/budget_ledger.ts"],"names":[],"mappings":"AAcA,qBAAa,YAAY;IACrB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,QAAQ,EAAE,MAAM;IAI5B,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK1B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK/B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI/B;;;OAGG;IACH,KAAK,IAAI,IAAI;CAMhB"}

package/dist/budget_ledger.js

@@ -0,0 +1,62 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetLedger = void 0;
+/**
+ * Shared budget ledger — tracks aggregate cost across all provider instances
+ * in a single crew run. Prevents parallel agents from each seeing only 1/N
+ * of actual spend and overshooting the budget by N×limit.
+ *
+ * Usage: create one BudgetLedger per crew run, pass it to getCrewProvider(),
+ * which attaches it to each provider via setBudgetLedger().
+ */
+const base_provider_js_1 = require("./base_provider.js");
+class BudgetLedger {
+    constructor(limitUSD) {
+        this._totalCost = 0;
+        this._reserved = 0;
+        this._limitUSD = limitUSD;
+    }
+    get totalCost() {
+        return this._totalCost;
+    }
+    get limitUSD() {
+        return this._limitUSD;
+    }
+    /**
+     * Record actual cost from a completed LLM call.
+     */
+    record(cost) {
+        if (!Number.isFinite(cost) || cost < 0)
+            return;
+        this._totalCost += cost;
+    }
+    /**
+     * Pre-reserve estimated cost before an LLM call begins.
+     * Blocks parallel agents from spending into the same headroom.
+     * Like a credit card authorization hold.
+     */
+    reserve(estimate) {
+        if (!Number.isFinite(estimate) || estimate <= 0)
+            return;
+        this._reserved += estimate;
+    }
+    /**
+     * Release a prior reservation (after API response or on error).
+     */
+    release(estimate) {
+        this._reserved = Math.max(0, this._reserved - estimate);
+    }
+    /**
+     * Throws BudgetExceededError if committed cost + in-flight reservations
+     * have reached the limit.
+     */
+    check() {
+        const effective = this._totalCost + this._reserved;
+        if (effective >= this._limitUSD) {
+            throw new base_provider_js_1.BudgetExceededError(effective, this._limitUSD);
+        }
+    }
+}
+exports.BudgetLedger = BudgetLedger;

package/dist/cache/cached_provider.d.ts

@@ -0,0 +1,49 @@
+import type { LLMProvider, LLMResponse, GenerateOptions, ImageInput, ProviderCapabilities, ProviderUsageStats } from '../provider_interface.js';
+import { ResponseCache } from './response_cache.js';
+/**
+ * Context that ties a cached provider to a specific agent + family scope.
+ */
+export interface CacheContext {
+    /** The agent role performing the request (e.g. 'impact-analyst', 'generator') */
+    agent: string;
+    /** The route-family name being processed */
+    family: string;
+    /** Content hashes of the source files used in the prompt */
+    fileHashes: string[];
+}
+/**
+ * Decorator that adds transparent response caching to any LLMProvider.
+ *
+ * - `generateText()` checks the cache first and returns a cached response on hit.
+ *   On a miss it delegates to the inner provider, stores the result, and returns it.
+ * - All other methods (analyzeImage, streamText, capabilities, usage stats)
+ *   delegate directly to the wrapped provider.
+ *
+ * The TTL is selected based on the agent role: agents whose name contains
+ * "generat" use the shorter GENERATION TTL; all others use ANALYSIS.
+ */
+export declare class CachedProvider implements LLMProvider {
+    readonly name: string;
+    readonly capabilities: ProviderCapabilities;
+    private readonly inner;
+    private readonly cache;
+    private readonly ctx;
+    private readonly ttlMs;
+    analyzeImage?: (images: ImageInput[], prompt: string, options?: GenerateOptions) => Promise<LLMResponse>;
+    streamText?: (prompt: string, options?: GenerateOptions) => AsyncGenerator<string, void, unknown>;
+    constructor(inner: LLMProvider, cache: ResponseCache, cacheContext: CacheContext);
+    /**
+     * Generate text with cache-through semantics.
+     * On a cache hit the inner provider is never called, saving tokens and latency.
+     */
+    generateText(prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    getUsageStats(): ProviderUsageStats;
+    resetUsageStats(): void;
+    checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+}
+export { ResponseCache, TTL } from './response_cache.js';
+export type { CacheEntry } from './response_cache.js';
+//# sourceMappingURL=cached_provider.d.ts.map

package/dist/cache/cached_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cached_provider.d.ts","sourceRoot":"","sources":["../../src/cache/cached_provider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EACrB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAC,aAAa,EAAM,MAAM,qBAAqB,CAAC;AAGvD;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,UAAU,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,cAAe,YAAW,WAAW;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAE5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAG/B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACzG,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;gBAEtF,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY;IAqBhF;;;OAGG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAyCnF,aAAa,IAAI,kBAAkB;IAInC,eAAe,IAAI,IAAI;IAIjB,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;CAGpE;AAGD,OAAO,EAAC,aAAa,EAAE,GAAG,EAAC,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAC,UAAU,EAAC,MAAM,qBAAqB,CAAC"}

package/dist/cache/cached_provider.js

@@ -0,0 +1,91 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTL = exports.ResponseCache = exports.CachedProvider = void 0;
+const response_cache_js_1 = require("./response_cache.js");
+/**
+ * Decorator that adds transparent response caching to any LLMProvider.
+ *
+ * - `generateText()` checks the cache first and returns a cached response on hit.
+ *   On a miss it delegates to the inner provider, stores the result, and returns it.
+ * - All other methods (analyzeImage, streamText, capabilities, usage stats)
+ *   delegate directly to the wrapped provider.
+ *
+ * The TTL is selected based on the agent role: agents whose name contains
+ * "generat" use the shorter GENERATION TTL; all others use ANALYSIS.
+ */
+class CachedProvider {
+    constructor(inner, cache, cacheContext) {
+        this.inner = inner;
+        this.cache = cache;
+        this.ctx = cacheContext;
+        this.name = inner.name;
+        this.capabilities = inner.capabilities;
+        // Pick TTL based on agent role
+        this.ttlMs = cacheContext.agent.toLowerCase().includes('generat')
+            ? response_cache_js_1.TTL.GENERATION
+            : response_cache_js_1.TTL.ANALYSIS;
+        // Wire optional methods only when the inner provider supports them
+        if (inner.analyzeImage) {
+            this.analyzeImage = (images, prompt, options) => inner.analyzeImage(images, prompt, options);
+        }
+        if (inner.streamText) {
+            this.streamText = (prompt, options) => inner.streamText(prompt, options);
+        }
+    }
+    /**
+     * Generate text with cache-through semantics.
+     * On a cache hit the inner provider is never called, saving tokens and latency.
+     */
+    async generateText(prompt, options) {
+        const { agent, family, fileHashes } = this.ctx;
+        const model = this.inner.name;
+        // Check cache
+        const cached = this.cache.get(agent, family, fileHashes, model);
+        if (cached) {
+            return {
+                text: cached.response,
+                usage: {
+                    inputTokens: cached.usage.inputTokens,
+                    outputTokens: cached.usage.outputTokens,
+                    totalTokens: cached.usage.inputTokens + cached.usage.outputTokens,
+                    cachedTokens: cached.usage.inputTokens,
+                },
+                cost: 0, // No cost on cache hit
+            };
+        }
+        // Cache miss - call inner provider
+        const response = await this.inner.generateText(prompt, options);
+        // Store in cache
+        const key = response_cache_js_1.ResponseCache.buildKey({ agent, family, fileHashes, model });
+        const entry = {
+            key,
+            family,
+            response: response.text,
+            usage: {
+                inputTokens: response.usage.inputTokens,
+                outputTokens: response.usage.outputTokens,
+                cost: response.cost,
+            },
+            createdAt: new Date().toISOString(),
+            ttlMs: this.ttlMs,
+        };
+        this.cache.set(entry);
+        return response;
+    }
+    getUsageStats() {
+        return this.inner.getUsageStats();
+    }
+    resetUsageStats() {
+        this.inner.resetUsageStats();
+    }
+    async checkHealth() {
+        return this.inner.checkHealth();
+    }
+}
+exports.CachedProvider = CachedProvider;
+// Re-export for convenience
+var response_cache_js_2 = require("./response_cache.js");
+Object.defineProperty(exports, "ResponseCache", { enumerable: true, get: function () { return response_cache_js_2.ResponseCache; } });
+Object.defineProperty(exports, "TTL", { enumerable: true, get: function () { return response_cache_js_2.TTL; } });

package/dist/cache/response_cache.d.ts

@@ -0,0 +1,79 @@
+/**
+ * TTL presets for different cache entry types.
+ */
+export declare const TTL: {
+    /** 24 hours - for analysis results that change infrequently */
+    readonly ANALYSIS: number;
+    /** 1 hour - for generated content that may need fresher context */
+    readonly GENERATION: number;
+};
+/**
+ * A single cached LLM response entry stored on disk.
+ */
+export interface CacheEntry {
+    /** Content-addressed cache key (SHA-256 hex) */
+    key: string;
+    /** The LLM response text */
+    response: string;
+    /** Token usage and cost snapshot */
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+    };
+    /** ISO timestamp when the entry was created */
+    createdAt: string;
+    /** Time-to-live in milliseconds */
+    ttlMs: number;
+}
+/**
+ * Parameters used to compute a content-addressed cache key.
+ */
+export interface CacheKeyParams {
+    agent: string;
+    family: string;
+    fileHashes: string[];
+    model: string;
+}
+/**
+ * Cross-run LLM response cache backed by JSON files.
+ *
+ * Stores entries as `{cacheDir}/{sha256}.json` using a content-addressed key
+ * derived from (agentRole + familyName + sorted file hashes + model).
+ */
+export declare class ResponseCache {
+    private readonly cacheDir;
+    constructor(workspaceRoot: string);
+    /**
+     * Build a deterministic SHA-256 cache key from the provided parameters.
+     */
+    static buildKey(params: CacheKeyParams): string;
+    /**
+     * Retrieve a cached response if it exists and has not expired.
+     * Returns `null` on cache miss or expiry.
+     */
+    get(agent: string, family: string, fileHashes: string[], model: string): CacheEntry | null;
+    /**
+     * Write a cache entry to disk.
+     * Creates the cache directory if it does not yet exist.
+     */
+    set(entry: CacheEntry): void;
+    /**
+     * Remove all cache entries belonging to the given family.
+     *
+     * Because the cache key is a one-way SHA-256 hash, we scan each file and
+     * check its stored `family` field. The directory is scoped to a single
+     * workspace so the scan is bounded.
+     */
+    invalidateFamily(familyName: string): number;
+    /**
+     * Remove all expired entries from the cache directory.
+     * Returns the number of entries deleted.
+     */
+    prune(): number;
+    /**
+     * Ensure the cache directory exists on disk.
+     */
+    private ensureCacheDir;
+}
+//# sourceMappingURL=response_cache.d.ts.map

package/dist/cache/response_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response_cache.d.ts","sourceRoot":"","sources":["../../src/cache/response_cache.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,GAAG;IACZ,+DAA+D;;IAE/D,mEAAmE;;CAE7D,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,KAAK,EAAE;QACH,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,aAAa,EAAE,MAAM;IAIjC;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM;IAM/C;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IA0B1F;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAM5B;;;;;;OAMG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAyB5C;;;OAGG;IACH,KAAK,IAAI,MAAM;IAiCf;;OAEG;IACH,OAAO,CAAC,cAAc;CAKzB"}