labre-mcp 0.1.0

package/dist/work-on-value-chain/write/component/infer-capability-from-solution.mjs

@@ -0,0 +1,206 @@
+// Pipeline capability inference — deduces the underlying capability from a solution name.
+//
+// When the pipeline enrichment mode (pipeline: true) receives a solution input
+// (e.g. "Kubernetes", "Scrum", "ISO 27001"), this module uses the Tier 2 LLM
+// (via the existing identifyCapability function) to determine the generic
+// capability that the solution addresses.
+//
+// The result is a structured intermediate object used by the pipeline orchestrator
+// to run the 3-evaluation sequence:
+//   1. Capability pivot (the inferred capability)
+//   2. Solution SotA (state-of-the-art solution in the same capability space)
+//   3. Solution legacy (an older/less-evolved solution)
+//
+// This module does NOT add latency to the default routing path — it is only
+// invoked when pipeline: true is explicitly requested.
+//
+// Usage:
+//   import { inferCapabilityFromSolution } from './pipeline-capability-inference.mjs';
+//
+//   const result = await inferCapabilityFromSolution('Kubernetes', {
+//     description: 'Container orchestration platform',
+//     llmCall,
+//   });
+//   // → {
+//   //   solutionName: 'Kubernetes',
+//   //   capability: 'Orchestrate containers',
+//   //   capabilityLabel: 'Container Orchestration',
+//   //   nature: 'activity',
+//   //   wardleyType: 'component',
+//   //   confidence: 0.92,
+//   //   justification: '...',
+//   // }
+import { identifyCapability } from './identify-capability.mjs';
+import { logDebug } from '../../../lib/mcp-notifications.mjs';
+// ─── Constants ────────────────────────────────────────────────────────────────
+const TOOL = 'pipelineCapabilityInference';
+// ─── Result Type ──────────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} PipelineCapabilityInferenceResult
+ * @property {string}  solutionName    - Original solution name input
+ * @property {string}  capability      - Inferred capability (nature-formatted, e.g. "Orchestrate containers")
+ * @property {string}  capabilityLabel - Clean label for OWM display (e.g. "Container Orchestration")
+ * @property {string}  nature          - Wardley component nature: activity | practice | knowledge | data
+ * @property {string}  wardleyType     - Component type: component | pipeline | anchor | market | ecosystem
+ * @property {number}  confidence      - Confidence in the inference (0–1)
+ * @property {string}  justification   - LLM reasoning for the inference
+ * @property {boolean} inferred        - Always true — marks this as an LLM inference result
+ */
+// ─── Capability Label Normalization ──────────────────────────────────────────
+/**
+ * Convert a nature-formatted capability string into a clean display label
+ * suitable for OWM component names.
+ *
+ * Transformations by nature:
+ *   - activity: "Orchestrate containers" → "Container Orchestration"
+ *     (removes leading verb, nominalizes)
+ *   - practice: "how to manage IT services" → "IT Service Management"
+ *     (removes "how to", nominalizes)
+ *   - knowledge: "technical expertise in welding" → "Welding Expertise"
+ *   - data: kept as-is with title case
+ *
+ * Falls back to title-casing the raw capability if transformation fails.
+ *
+ * @param {string} capability - Nature-formatted capability string
+ * @param {string} nature     - Component nature (activity/practice/knowledge/data)
+ * @returns {string} Clean label for OWM display
+ */
+export function capabilityToLabel(capability, nature) {
+    if (!capability)
+        return 'Capability';
+    const trimmed = capability.trim();
+    try {
+        switch (nature) {
+            case 'activity': {
+                // "Orchestrate containers" → "Container Orchestration"
+                // "Manage customer relationships" → "Customer Relationship Management"
+                // Remove leading infinitive verb, nominalize the rest
+                const verbMatch = trimmed.match(/^(manage|orchestrate|automate|process|handle|deliver|provide|build|create|monitor|analyze|store|compute|deploy|serve|route|transform|integrate|authenticate|authorize|brew|develop|test|maintain|secure|encrypt|optimize|schedule|balance|discover|log|cache|message|stream|search|index|render)\s+(.+)$/i);
+                if (verbMatch) {
+                    const verb = verbMatch[1].toLowerCase();
+                    const object = verbMatch[2].trim();
+                    // Nominalize: verb → noun form
+                    const nominalizations = {
+                        manage: 'Management', orchestrate: 'Orchestration',
+                        automate: 'Automation', process: 'Processing',
+                        handle: 'Handling', deliver: 'Delivery',
+                        provide: 'Provisioning', build: 'Building',
+                        create: 'Creation', monitor: 'Monitoring',
+                        analyze: 'Analytics', store: 'Storage',
+                        compute: 'Computing', deploy: 'Deployment',
+                        serve: 'Serving', route: 'Routing',
+                        transform: 'Transformation', integrate: 'Integration',
+                        authenticate: 'Authentication', authorize: 'Authorization',
+                        brew: 'Brewing', develop: 'Development',
+                        test: 'Testing', maintain: 'Maintenance',
+                        secure: 'Security', encrypt: 'Encryption',
+                        optimize: 'Optimization', schedule: 'Scheduling',
+                        balance: 'Balancing', discover: 'Discovery',
+                        log: 'Logging', cache: 'Caching',
+                        message: 'Messaging', stream: 'Streaming',
+                        search: 'Search', index: 'Indexing',
+                        render: 'Rendering',
+                    };
+                    const nounForm = nominalizations[verb] || (verb.charAt(0).toUpperCase() + verb.slice(1) + 'ing');
+                    // Title-case the object and append nominalization
+                    const objectTitled = titleCase(object);
+                    return `${objectTitled} ${nounForm}`;
+                }
+                // No verb detected — title case
+                return titleCase(trimmed);
+            }
+            case 'practice': {
+                // "how to manage IT services" → "IT Service Management"
+                const howToMatch = trimmed.match(/^how\s+to\s+(.+)$/i);
+                if (howToMatch) {
+                    // Recursively process as activity
+                    return capabilityToLabel(howToMatch[1], 'activity');
+                }
+                return titleCase(trimmed);
+            }
+            case 'knowledge': {
+                // "technical expertise in welding" → "Welding Expertise"
+                // "interpersonal skills for coaching" → "Coaching Skills"
+                const expertiseMatch = trimmed.match(/(?:technical\s+)?expertise\s+(?:in|for|on)\s+(.+)/i);
+                if (expertiseMatch) {
+                    return `${titleCase(expertiseMatch[1])} Expertise`;
+                }
+                const skillsMatch = trimmed.match(/(?:interpersonal\s+)?skills\s+(?:in|for|on)\s+(.+)/i);
+                if (skillsMatch) {
+                    return `${titleCase(skillsMatch[1])} Skills`;
+                }
+                return titleCase(trimmed);
+            }
+            case 'data':
+            default:
+                return titleCase(trimmed);
+        }
+    }
+    catch {
+        return titleCase(trimmed);
+    }
+}
+/**
+ * Title-case a string: capitalize first letter of each word.
+ * @param {string} str
+ * @returns {string}
+ */
+function titleCase(str) {
+    // Preserve existing capitalization for abbreviations (IT, CRM, API, etc.)
+    return str.replace(/\b\w+/g, (word) => {
+        // If already all-caps and length >= 2, keep it (likely an abbreviation)
+        if (word.length >= 2 && word === word.toUpperCase())
+            return word;
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    });
+}
+// ─── Main Inference Function ─────────────────────────────────────────────────
+/**
+ * Infer the underlying capability from a solution name using the Tier 2 LLM.
+ *
+ * This is the core function for pipeline mode's first step: given a named
+ * solution (product, framework, methodology, standard), determine the generic
+ * capability it addresses.
+ *
+ * @param {string} solutionName - The solution name (e.g. "Kubernetes", "Scrum", "ISO 27001")
+ * @param {Object} options
+ * @param {string}   [options.description] - Additional context about the solution
+ * @param {function} options.llmCall       - LLM call function (from llm-call.mjs)
+ * @returns {Promise<PipelineCapabilityInferenceResult>}
+ */
+// any: options bag (description, llmCall, ...) — result is { capability, nature, confidence, reasoning }
+export async function inferCapabilityFromSolution(solutionName, options = {}) {
+    const { description = '', llmCall } = options;
+    if (!solutionName || typeof solutionName !== 'string') {
+        throw new Error('inferCapabilityFromSolution: solutionName must be a non-empty string');
+    }
+    if (typeof llmCall !== 'function') {
+        throw new Error('inferCapabilityFromSolution: llmCall function is required');
+    }
+    const trimmedName = solutionName.trim();
+    logDebug(TOOL, `Inferring capability for solution "${trimmedName}"...`);
+    // Delegate to the existing identifyCapability module
+    // It already has the full LLM prompt and parsing logic
+    const component = {
+        name: trimmedName,
+        description: description || '',
+        context: description || '',
+    };
+    const capResult = await identifyCapability(component, llmCall);
+    logDebug(TOOL, `Inferred capability for "${trimmedName}": ` +
+        `"${capResult.capability}" (nature=${capResult.nature}, confidence=${capResult.confidence})`);
+    // Build the clean label for OWM display
+    const capabilityLabel = capabilityToLabel(capResult.capability, capResult.nature);
+    logDebug(TOOL, `Capability label for "${trimmedName}": "${capabilityLabel}"`);
+    return {
+        solutionName: trimmedName,
+        capability: capResult.capability,
+        capabilityLabel,
+        nature: capResult.nature || 'activity',
+        wardleyType: capResult.type || 'component',
+        confidence: capResult.confidence,
+        justification: capResult.justification || '',
+        inferred: true,
+    };
+}
+//# sourceMappingURL=infer-capability-from-solution.mjs.map

package/dist/work-on-value-chain/write/component/infer-capability-from-solution.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-capability-from-solution.mjs","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/infer-capability-from-solution.mts"],"names":[],"mappings":"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"}

package/dist/work-on-value-chain/write/component/registry.d.mts

@@ -0,0 +1,17 @@
+import { BaseComponentWriteStrategy } from './base-strategy.mjs';
+export type StrategyCtor = (new (...args: any[]) => BaseComponentWriteStrategy) & {
+    method: string;
+    disabled?: boolean | {
+        reason: string;
+    };
+};
+export declare function loadStrategies(): Promise<Map<string, StrategyCtor>>;
+export declare function listDisabled(): Promise<Array<{
+    method: string;
+    reason: string;
+}>>;
+export declare function isDisabled(method: string): Promise<boolean>;
+export declare function getStrategy(method: string): Promise<StrategyCtor>;
+export declare function listStrategies(): Promise<string[]>;
+export declare function clearCache(): void;
+//# sourceMappingURL=registry.d.mts.map

package/dist/work-on-value-chain/write/component/registry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.mts","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/registry.mts"],"names":[],"mappings":"AASA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAKjE,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,0BAA0B,CAAC,GAAG;IAChF,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACzC,CAAC;AAKF,wBAAsB,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAoDzE;AAED,wBAAsB,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAGvF;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGjE;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAYvE;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAGxD;AAED,wBAAgB,UAAU,IAAI,IAAI,CAGjC"}

package/dist/work-on-value-chain/write/component/registry.mjs

@@ -0,0 +1,83 @@
+// Strategy registry for write:component:* strategies.
+//
+// Auto-discovers all *-strategy.{mjs,mts} files in this directory that export
+// a class extending BaseComponentWriteStrategy. Pattern mirrors
+// src/work-on-evolution/write/strategies/capacity/registry.mts.
+import { readdir } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join } from 'node:path';
+import { BaseComponentWriteStrategy } from './base-strategy.mjs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let _cache = null;
+let _disabledCache = null;
+export async function loadStrategies() {
+    if (_cache)
+        return _cache;
+    const entries = await readdir(__dirname);
+    const strategyFiles = entries.filter(f => (f.endsWith('-strategy.mjs') || f.endsWith('-strategy.mts')) &&
+        f !== 'base-strategy.mjs' &&
+        f !== 'base-strategy.mts');
+    const strategies = new Map();
+    for (const file of strategyFiles) {
+        const fullPath = join(__dirname, file);
+        const mod = await import(pathToFileURL(fullPath).href);
+        for (const exportName of Object.keys(mod)) {
+            const candidate = mod[exportName];
+            if (typeof candidate === 'function' &&
+                candidate.prototype instanceof BaseComponentWriteStrategy &&
+                candidate !== BaseComponentWriteStrategy) {
+                const Cls = candidate;
+                const method = Cls.method;
+                if (strategies.has(method)) {
+                    throw new Error(`Duplicate strategy method "${method}" in ${file} — already registered`);
+                }
+                strategies.set(method, Cls);
+            }
+        }
+    }
+    const disabled = new Map();
+    for (const [method, Cls] of [...strategies]) {
+        const flag = Cls.disabled;
+        if (flag) {
+            const reason = flag && typeof flag === 'object' && typeof flag.reason === 'string'
+                ? flag.reason
+                : 'disabled';
+            disabled.set(method, { reason });
+            strategies.delete(method);
+        }
+    }
+    _cache = strategies;
+    _disabledCache = disabled;
+    return strategies;
+}
+export async function listDisabled() {
+    await loadStrategies();
+    return [..._disabledCache.entries()].map(([method, { reason }]) => ({ method, reason }));
+}
+export async function isDisabled(method) {
+    await loadStrategies();
+    return _disabledCache.has(method);
+}
+export async function getStrategy(method) {
+    const strategies = await loadStrategies();
+    const Cls = strategies.get(method);
+    if (!Cls) {
+        if (_disabledCache && _disabledCache.has(method)) {
+            const { reason } = _disabledCache.get(method);
+            throw new Error(`Strategy "${method}" is disabled: ${reason}`);
+        }
+        const available = [...strategies.keys()].join(', ') || '(none registered)';
+        throw new Error(`Unknown strategy "${method}". Available: ${available}`);
+    }
+    return Cls;
+}
+export async function listStrategies() {
+    const strategies = await loadStrategies();
+    return [...strategies.keys()];
+}
+export function clearCache() {
+    _cache = null;
+    _disabledCache = null;
+}
+//# sourceMappingURL=registry.mjs.map

package/dist/work-on-value-chain/write/component/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.mjs","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/registry.mts"],"names":[],"mappings":"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"}

package/dist/work-on-value-chain/write/component/signal-combiner.d.mts

@@ -0,0 +1,131 @@
+import type { VerificationSignal, CombinedSignalResult } from '../../../types/pipeline.mjs';
+/** Component type constants (mirroring solution-capability-router) */
+export declare const COMPONENT_TYPE: {
+    SOLUTION: string;
+    CAPABILITY: string;
+};
+/**
+ * Confidence adjustment parameters.
+ *
+ * These are tuned to match the existing reconciliation logic in
+ * dual-verification-orchestrator.mjs and web-search-verification.mjs,
+ * ensuring consistent behavior across the codebase.
+ */
+export declare const COMBINATION_PARAMS: {
+    /** Bonus added when both signals agree (on top of their average) */
+    AGREEMENT_BONUS: number;
+    /** Maximum confidence after combination (prevents over-confidence) */
+    MAX_CONFIDENCE: number;
+    /** Penalty applied when signals disagree (subtracted from winner) */
+    DISAGREEMENT_PENALTY: number;
+    /** Minimum confidence floor after disagreement penalty */
+    DISAGREEMENT_FLOOR: number;
+    /** Weight given to LLM signal when both are present (web search gets 1 - this) */
+    LLM_WEIGHT: number;
+    /** Weight given to web search signal when both are present */
+    WEB_SEARCH_WEIGHT: number;
+    /** Minimum confidence for a signal to be considered "usable" */
+    MIN_SIGNAL_CONFIDENCE: number;
+    /** Confidence degradation factor when a signal is missing/failed */
+    MISSING_SIGNAL_DEGRADATION: number;
+};
+/**
+ * Signal status values.
+ * Matches the VerificationSignal status enum from dual-verification-orchestrator.
+ */
+export declare const SIGNAL_STATUS: {
+    SUCCESS: string;
+    TIMEOUT: string;
+    ERROR: string;
+    SKIPPED: string;
+};
+/**
+ * @typedef {Object} ClassificationSignal
+ * @property {'solution'|'capability'|null} classification - Classified component type (null if failed)
+ * @property {number}    confidence  - Confidence score (0-1), 0 if failed/unavailable
+ * @property {string}    method      - Signal source identifier: 'llm', 'web-search', 'naming', etc.
+ * @property {string}    [reasoning] - Human-readable explanation
+ * @property {'success'|'timeout'|'error'|'skipped'} [status] - Signal outcome
+ * @property {number}    [durationMs] - Wall-clock time for this signal
+ * @property {Object}    [raw]       - Raw result from the verification backend
+ * @property {string}    [error]     - Error message (when status is 'error' or 'timeout')
+ */
+/**
+ * @typedef {Object} CombinedClassificationResult
+ * @property {'solution'|'capability'} classification - Final combined classification
+ * @property {number}    confidence   - Combined confidence score (0-1)
+ * @property {string}    method       - Method chain describing which signals contributed
+ * @property {string}    reasoning    - Combined human-readable reasoning
+ * @property {'agreement'|'disagreement'|'single-signal'|'no-signal'} mergeCase
+ *   Which of the three merge cases was applied
+ * @property {boolean}   verified     - true if confidence >= MIN_VERIFIED threshold
+ * @property {boolean}   isSolution   - Convenience flag: classification === 'solution'
+ * @property {Object}    [signals]    - Both input signals preserved for traceability
+ * @property {ClassificationSignal} [signals.llm]       - LLM signal as received
+ * @property {ClassificationSignal} [signals.webSearch]  - Web search signal as received
+ */
+/**
+ * Check if a signal is usable (successful with a valid classification).
+ *
+ * A signal is usable when:
+ *   - status is 'success' (or status field is absent, for backward compat)
+ *   - classification is a non-null string ('solution' or 'capability')
+ *   - confidence is a positive number above the minimum threshold
+ *
+ * @param {ClassificationSignal} signal - Signal to check
+ * @returns {boolean} true if the signal provides a usable classification
+ */
+export declare function isSignalUsable(signal: VerificationSignal | null | undefined): boolean;
+/**
+ * Combine LLM classification signal and web search signal into a single
+ * solution-or-capability determination.
+ *
+ * Merge cases (handled in order):
+ *
+ *   **Case 1: Agreement** (both usable, same classification)
+ *     Confidence = avg(llm, webSearch) + AGREEMENT_BONUS (capped at MAX_CONFIDENCE)
+ *     → High confidence because independent signals corroborate each other
+ *
+ *   **Case 2: Disagreement** (both usable, different classification)
+ *     Winner = signal with higher confidence
+ *     Confidence = max(weightedLlm, weightedWeb) - DISAGREEMENT_PENALTY (floor at DISAGREEMENT_FLOOR)
+ *     → Lower confidence because the signals contradict; fallback to the stronger signal
+ *     → When confidences are close (within 0.10), additional penalty applied
+ *
+ *   **Case 3: Partial/missing** (one or both signals not usable)
+ *     - One signal usable → use it, apply MISSING_SIGNAL_DEGRADATION factor
+ *     - Neither usable → default to capability with confidence 0
+ *
+ * @param {ClassificationSignal} llmSignal - LLM classification signal
+ * @param {ClassificationSignal} webSearchSignal - Web search classification signal
+ * @param {Object} [options={}]
+ * @param {number} [options.agreementBonus=0.10]       - Override agreement bonus
+ * @param {number} [options.disagreementPenalty=0.10]   - Override disagreement penalty
+ * @param {number} [options.maxConfidence=0.98]         - Override max confidence cap
+ * @param {number} [options.disagreementFloor=0.45]     - Override minimum after disagreement
+ * @param {number} [options.llmWeight=0.45]             - Override LLM weight in disagreement
+ * @param {number} [options.webSearchWeight=0.55]       - Override web search weight in disagreement
+ * @param {number} [options.minVerified=0.70]           - Min confidence for verified flag
+ * @returns {CombinedClassificationResult} Combined classification with confidence
+ */
+export declare function combineSignals(llmSignal: VerificationSignal | null, webSearchSignal: VerificationSignal | null, options?: any): CombinedSignalResult;
+/**
+ * Combine three signals: naming convention + LLM + web search.
+ *
+ * This is the full integration point for estimate-evolution.mjs when all
+ * three detection tiers have run. The naming signal carries the Tier 1
+ * result from solution-capability-router.mjs.
+ *
+ * Algorithm:
+ *   1. First combine LLM + web search using combineSignals()
+ *   2. Then reconcile the combined result with the naming signal
+ *      using a two-stage combination that preserves agreement/disagreement logic
+ *
+ * @param {ClassificationSignal} namingSignal     - Naming convention signal (Tier 1)
+ * @param {ClassificationSignal} llmSignal        - LLM classification signal (Tier 2)
+ * @param {ClassificationSignal} webSearchSignal  - Web search signal (Tier 3)
+ * @param {Object} [options={}]                   - Same options as combineSignals
+ * @returns {CombinedClassificationResult} Combined classification from all three signals
+ */
+export declare function combineAllSignals(namingSignal: VerificationSignal | null, llmSignal: VerificationSignal | null, webSearchSignal: VerificationSignal | null, options?: any): CombinedSignalResult;
+//# sourceMappingURL=signal-combiner.d.mts.map

package/dist/work-on-value-chain/write/component/signal-combiner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-combiner.d.mts","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/signal-combiner.mts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAM5F,sEAAsE;AACtE,eAAO,MAAM,cAAc;;;CAG1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oEAAoE;;IAEpE,sEAAsE;;IAEtE,qEAAqE;;IAErE,0DAA0D;;IAE1D,kFAAkF;;IAElF,8DAA8D;;IAE9D,gEAAgE;;IAEhE,oEAAoE;;CAErE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;CAKzB,CAAC;AAIF;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;GAaG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAgBrF;AAoCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,cAAc,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,EAAE,eAAe,EAAE,kBAAkB,GAAG,IAAI,EAAE,OAAO,GAAE,GAAQ,GAAG,oBAAoB,CAuIxJ;AAID;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI,EAAE,SAAS,EAAE,kBAAkB,GAAG,IAAI,EAAE,eAAe,EAAE,kBAAkB,GAAG,IAAI,EAAE,OAAO,GAAE,GAAQ,GAAG,oBAAoB,CA2EpM"}