labre-mcp 0.1.0

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-reconciliation.mjs

@@ -0,0 +1,182 @@
+// Reconciliation logic for dual-verification pipeline
+//
+// Extracted from dual-verification-orchestrator.mjs to enforce
+// single-responsibility: this module handles converting tier results
+// to intermediate format and reconciling multiple verification signals
+// into a single classification decision.
+import { COMPONENT_TYPE } from '#lib/component-detection.mjs';
+import { determineRoutingTargets } from '#work-on-evolution/write/routing/solution-dispatch.mjs';
+/**
+ * Convert a ComponentTypeDetection (from naming conventions or LLM) into an
+ * intermediate result object for reconciliation.
+ *
+ * @param {import('../../lib/component-detection.mjs').ComponentTypeDetection} detection
+ * @returns {{ classification: string, confidence: number, method: string, reasoning: string }}
+ */
+// any: returns a heterogeneous intermediate shape (legacy fields plus routing)
+export function toIntermediateResult(detection) {
+    return {
+        classification: detection.type,
+        confidence: detection.confidence,
+        method: detection.method,
+        reasoning: detection.reason || '',
+    };
+}
+/**
+ * Reconcile two tier results using agreement/disagreement logic.
+ *
+ * When both tiers agree on classification:
+ *   → Boost confidence: average of both + 0.10 agreement bonus (capped at 0.98)
+ *
+ * When tiers disagree:
+ *   → Trust the tier with higher confidence, but apply a 0.10 disagreement penalty
+ *   → Minimum confidence floor of 0.45
+ *
+ * This mirrors the combineWithPriorResult logic in web-search-verification.mjs
+ * and the naming+llm reconciliation in detect-solution.mjs.
+ *
+ * @param {{ classification: string, confidence: number, method: string, reasoning: string }} tierA
+ * @param {{ classification: string, confidence: number, method: string, reasoning: string }} tierB
+ * @returns {{ classification: string, confidence: number, method: string, reasoning: string }}
+ */
+// any: tierA/tierB shapes are heterogeneous detection-or-signal payloads
+export function reconcileTwoTiers(tierA, tierB) {
+    if (tierA.classification === tierB.classification) {
+        // Agreement: boost confidence
+        const boosted = Math.round(Math.min(0.98, (tierA.confidence + tierB.confidence) / 2 + 0.10) * 100) / 100;
+        return {
+            classification: tierA.classification,
+            confidence: boosted,
+            method: `${tierA.method}+${tierB.method}`,
+            reasoning: `${tierB.reasoning} (agrees with ${tierA.method}: ${tierA.reasoning})`,
+        };
+    }
+    // Disagreement: trust higher-confidence tier with penalty
+    const winner = tierA.confidence >= tierB.confidence ? tierA : tierB;
+    const loser = tierA.confidence >= tierB.confidence ? tierB : tierA;
+    const penalized = Math.round(Math.max(0.45, winner.confidence - 0.10) * 100) / 100;
+    return {
+        classification: winner.classification,
+        confidence: penalized,
+        method: `${tierA.method}+${tierB.method}`,
+        reasoning: `${winner.method} overrides ${loser.method}: ${winner.reasoning} (${loser.method} said: ${loser.classification})`,
+    };
+}
+/**
+ * Reconcile a pair of verification signals into a single classification.
+ *
+ * Resolution rules (ordered by priority):
+ *   1. Both successful and agree → boost confidence (average + 0.10 bonus, capped at 0.98)
+ *   2. Both successful but disagree → trust higher confidence, apply 0.10 penalty (floor 0.45)
+ *   3. Only one successful → use its result directly
+ *   4. Neither successful → default to capability with 0 confidence
+ *
+ * @param {import('./dual-verification-orchestrator.mjs').VerificationSignal} llmSignal
+ * @param {import('./dual-verification-orchestrator.mjs').VerificationSignal} webSearchSignal
+ * @returns {{ classification: string, confidence: number, method: string, reasoning: string }}
+ */
+// any: caller guarantees both signals are non-null after early-return guards above
+export function reconcileSignalPair(llmSignal, webSearchSignal) {
+    const llmOk = llmSignal.status === 'success' && llmSignal.classification != null;
+    const webOk = webSearchSignal.status === 'success' && webSearchSignal.classification != null;
+    // Case 4: Neither succeeded
+    if (!llmOk && !webOk) {
+        const reasons = [];
+        if (llmSignal.status !== 'skipped')
+            reasons.push(`LLM: ${llmSignal.reasoning}`);
+        if (webSearchSignal.status !== 'skipped')
+            reasons.push(`Web: ${webSearchSignal.reasoning}`);
+        return {
+            classification: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'none',
+            reasoning: reasons.length > 0
+                ? `Both verifications failed: ${reasons.join('; ')}`
+                : 'Both verifications were skipped',
+        };
+    }
+    // Case 3a: Only LLM succeeded
+    if (llmOk && !webOk) {
+        return {
+            classification: llmSignal.classification,
+            confidence: llmSignal.confidence,
+            method: 'llm',
+            reasoning: `${llmSignal.reasoning} (web search ${webSearchSignal.status})`,
+        };
+    }
+    // Case 3b: Only web search succeeded
+    if (!llmOk && webOk) {
+        return {
+            classification: webSearchSignal.classification,
+            confidence: webSearchSignal.confidence,
+            method: 'web-search',
+            reasoning: `${webSearchSignal.reasoning} (LLM ${llmSignal.status})`,
+        };
+    }
+    // Case 1 & 2: Both succeeded
+    if (llmSignal.classification === webSearchSignal.classification) {
+        // Case 1: Agreement — boost confidence
+        const boosted = Math.round(Math.min(0.98, (llmSignal.confidence + webSearchSignal.confidence) / 2 + 0.10) * 100) / 100;
+        return {
+            classification: llmSignal.classification,
+            confidence: boosted,
+            method: 'llm+web-search',
+            reasoning: `${webSearchSignal.reasoning} (LLM agrees: ${llmSignal.reasoning})`,
+        };
+    }
+    // Case 2: Disagreement — trust higher confidence with penalty
+    const winner = llmSignal.confidence >= webSearchSignal.confidence ? llmSignal : webSearchSignal;
+    const loser = llmSignal.confidence >= webSearchSignal.confidence ? webSearchSignal : llmSignal;
+    const penalized = Math.round(Math.max(0.45, winner.confidence - 0.10) * 100) / 100;
+    return {
+        classification: winner.classification,
+        confidence: penalized,
+        method: 'llm+web-search',
+        reasoning: `${winner.method} overrides ${loser.method}: ${winner.reasoning} (${loser.method} said: ${loser.classification})`,
+    };
+}
+// ─── Result Builder ─────────────────────────────────────────────────────────
+/**
+ * Build a VerifiedClassificationResult with routing targets pre-computed.
+ *
+ * @param {Object} params
+ * @param {string} params.classification - 'solution' or 'capability'
+ * @param {number} params.confidence - Confidence score (0–1)
+ * @param {string} params.method - Method chain
+ * @param {string} params.reasoning - Human-readable explanation
+ * @param {boolean} [params.verified] - Whether the result meets verification threshold
+ * @param {string[]} [params.tiersUsed] - Which tiers contributed
+ * @param {Object} params.routingDetection - Original detection for routing
+ * @param {Object} [params.namingResult] - Tier 1 naming result
+ * @param {Object} [params.llmResult] - Tier 2 LLM result
+ * @param {Object} [params.webSearchResult] - Tier 3 web search result
+ * @returns {import('./dual-verification-orchestrator.mjs').VerifiedClassificationResult}
+ */
+// any: result params bag varies (legacy fields, signal merges)
+export function buildResult(params) {
+    const { classification, confidence, method, reasoning, verified, tiersUsed, routingDetection, namingResult, llmResult, webSearchResult, } = params;
+    const isSolution = classification === COMPONENT_TYPE.SOLUTION;
+    // Pre-compute routing targets using the verified classification
+    // Override the naming detection type with the verified classification
+    const overriddenDetection = {
+        ...routingDetection,
+        type: classification,
+        confidence,
+    };
+    const routingTargets = determineRoutingTargets(overriddenDetection);
+    return {
+        classification,
+        confidence,
+        method,
+        reasoning,
+        isSolution,
+        verified: verified || false,
+        tiersUsed: tiersUsed || [],
+        routingDetection,
+        routingTargets,
+        ...(namingResult !== undefined && { namingResult }),
+        ...(llmResult !== undefined && { llmResult }),
+        ...(webSearchResult !== undefined && { webSearchResult }),
+    };
+}
+//# sourceMappingURL=verification-reconciliation.mjs.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-reconciliation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-reconciliation.mjs","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-reconciliation.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-signals.d.mts

@@ -0,0 +1,62 @@
+import type { VerificationSignal } from '#types/pipeline.mjs';
+/**
+ * Verification signal builders and timeout racing utility.
+ *
+ * These functions construct standardised VerificationSignal objects used by the
+ * dual-verification orchestrator to represent the outcome of each verification
+ * backend (LLM, web-search).
+ *
+ * @module pipeline/verification-signals
+ */
+/**
+ * Race a promise against a timeout.  Resolves (never rejects) with a descriptor
+ * indicating whether the promise settled or timed out.
+ *
+ * @param {Promise} promise    - The promise to race
+ * @param {number}  timeoutMs  - Timeout in milliseconds
+ * @param {string}  label      - Human-readable label (for debugging)
+ * @returns {Promise<{ value: any, timedOut: boolean, error?: Error }>}
+ */
+export declare function raceWithTimeout(promise: Promise<any>, timeoutMs: number, label: string): Promise<any>;
+/**
+ * Build a VerificationSignal from a successful verification result.
+ *
+ * @param {Object} result     - Raw result from the verification backend
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} durationMs - Duration in milliseconds
+ * @returns {VerificationSignal}
+ */
+export declare function buildSuccessSignal(result: {
+    classification?: string | null;
+    confidence?: number;
+    reasoning?: string;
+    isSolution?: boolean;
+    [key: string]: unknown;
+}, method: string, durationMs: number): VerificationSignal;
+/**
+ * Build a VerificationSignal for a timeout.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} timeoutMs  - The timeout that was exceeded
+ * @param {number} durationMs - Actual elapsed time
+ * @returns {VerificationSignal}
+ */
+export declare function buildTimeoutSignal(method: string, timeoutMs: number, durationMs: number): VerificationSignal;
+/**
+ * Build a VerificationSignal for an error.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {Error}  err        - The error that occurred
+ * @param {number} durationMs - Duration before failure
+ * @returns {VerificationSignal}
+ */
+export declare function buildErrorSignal(method: string, err: unknown, durationMs: number): VerificationSignal;
+/**
+ * Build a VerificationSignal for a skipped verification.
+ *
+ * @param {string} method - Signal method: 'llm' or 'web-search'
+ * @param {string} reason - Why the signal was skipped
+ * @returns {VerificationSignal}
+ */
+export declare function buildSkippedSignal(method: string, reason: string): VerificationSignal;
+//# sourceMappingURL=verification-signals.d.mts.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-signals.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-signals.d.mts","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-signals.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D;;;;;;;;GAQG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA2BrG;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAU5N;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAU5G;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAUrG;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,CASrF"}

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-signals.mjs

@@ -0,0 +1,123 @@
+import { toErrorMessage } from '#lib/errors.mjs';
+/**
+ * Verification signal builders and timeout racing utility.
+ *
+ * These functions construct standardised VerificationSignal objects used by the
+ * dual-verification orchestrator to represent the outcome of each verification
+ * backend (LLM, web-search).
+ *
+ * @module pipeline/verification-signals
+ */
+// ─── raceWithTimeout ───────────────────────────────────────────────────────────
+/**
+ * Race a promise against a timeout.  Resolves (never rejects) with a descriptor
+ * indicating whether the promise settled or timed out.
+ *
+ * @param {Promise} promise    - The promise to race
+ * @param {number}  timeoutMs  - Timeout in milliseconds
+ * @param {string}  label      - Human-readable label (for debugging)
+ * @returns {Promise<{ value: any, timedOut: boolean, error?: Error }>}
+ */
+export function raceWithTimeout(promise, timeoutMs, label) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                resolve({ value: null, timedOut: true });
+            }
+        }, timeoutMs);
+        promise
+            .then((value) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve({ value, timedOut: false });
+            }
+        })
+            .catch((err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                // Re-throw wrapped so Promise.allSettled captures it
+                resolve({ value: null, timedOut: false, error: err });
+            }
+        });
+    });
+}
+// ─── Signal builders ───────────────────────────────────────────────────────────
+/**
+ * Build a VerificationSignal from a successful verification result.
+ *
+ * @param {Object} result     - Raw result from the verification backend
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} durationMs - Duration in milliseconds
+ * @returns {VerificationSignal}
+ */
+export function buildSuccessSignal(result, method, durationMs) {
+    return {
+        classification: result.classification || null,
+        confidence: typeof result.confidence === 'number' ? result.confidence : 0,
+        method,
+        reasoning: result.reasoning || '',
+        status: 'success',
+        durationMs,
+        raw: result,
+    };
+}
+/**
+ * Build a VerificationSignal for a timeout.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} timeoutMs  - The timeout that was exceeded
+ * @param {number} durationMs - Actual elapsed time
+ * @returns {VerificationSignal}
+ */
+export function buildTimeoutSignal(method, timeoutMs, durationMs) {
+    return {
+        classification: null,
+        confidence: 0,
+        method,
+        reasoning: `${method} verification timed out after ${timeoutMs}ms`,
+        status: 'timeout',
+        durationMs,
+        error: `Timeout after ${timeoutMs}ms`,
+    };
+}
+/**
+ * Build a VerificationSignal for an error.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {Error}  err        - The error that occurred
+ * @param {number} durationMs - Duration before failure
+ * @returns {VerificationSignal}
+ */
+export function buildErrorSignal(method, err, durationMs) {
+    return {
+        classification: null,
+        confidence: 0,
+        method,
+        reasoning: `${method} verification failed: ${toErrorMessage(err)}`,
+        status: 'error',
+        durationMs,
+        error: toErrorMessage(err),
+    };
+}
+/**
+ * Build a VerificationSignal for a skipped verification.
+ *
+ * @param {string} method - Signal method: 'llm' or 'web-search'
+ * @param {string} reason - Why the signal was skipped
+ * @returns {VerificationSignal}
+ */
+export function buildSkippedSignal(method, reason) {
+    return {
+        classification: null,
+        confidence: 0,
+        method,
+        reasoning: reason,
+        status: 'skipped',
+        durationMs: 0,
+    };
+}
+//# sourceMappingURL=verification-signals.mjs.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-signals.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-signals.mjs","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/verification-signals.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/web-search-verification.d.mts

@@ -0,0 +1,93 @@
+import type { WebSearchVerificationResult } from '#types/routing.mjs';
+/**
+ * @typedef {Object} WebSearchEvidence
+ * @property {string} type         - Evidence type: 'product-page' | 'wikipedia' | 'vendor-association' | 'pricing' | 'repository' | 'concept-article' | 'multi-implementation' | 'generic'
+ * @property {string} description  - Human-readable description of the evidence
+ * @property {string} [source]     - Source URL or domain
+ * @property {'solution'|'capability'} supports - Which classification this evidence supports
+ */
+/**
+ * @typedef {Object} WebSearchReference
+ * @property {string} title  - Page/article title
+ * @property {string} [url]  - Source URL
+ * @property {string} [snippet] - Relevant snippet or excerpt
+ */
+/**
+ * @typedef {Object} WebSearchVerificationResult
+ * @property {'solution'|'capability'} classification - Component classification
+ * @property {number}  confidence   - Confidence score (0–1)
+ * @property {string}  method       - Always 'web-search'
+ * @property {string}  reasoning    - Human-readable explanation
+ * @property {boolean} isSolution   - Convenience flag
+ * @property {WebSearchEvidence[]}  evidence   - Structured evidence items
+ * @property {WebSearchReference[]} references - Source references found
+ */
+/**
+ * Prompt template for web search-based verification.
+ *
+ * The LLM is instructed to:
+ *   1. Search the web for information about the component
+ *   2. Analyze results for product/solution vs capability evidence
+ *   3. Return structured classification with references
+ */
+/**
+ * Parse the web search verification response from the LLM.
+ *
+ * Extracts classification, confidence, reasoning, evidence, and references
+ * from the structured response format. Falls back to keyword-based extraction
+ * if the response doesn't match the expected format.
+ *
+ * @param {string} text - Raw LLM response text
+ * @param {string} name - Component name (for fallback messages)
+ * @returns {WebSearchVerificationResult}
+ */
+export declare function parseWebSearchResponse(text: string, name: string): import("#types/routing.mjs").ComponentTypeDetection;
+/**
+ * Create a web search call function backed by the Claude Agent SDK.
+ *
+ * Uses `query()` with WebSearch and WebFetch tools enabled so the LLM can
+ * perform real web searches to gather evidence about a component.
+ *
+ * @param {Object} [config={}]
+ * @param {string} [config.model='claude-sonnet-4-6'] - Model to use
+ * @param {number} [config.maxTurns=3]                 - Max tool-use turns (search + analyze)
+ * @returns {function(string, Object?): Promise<string>}
+ */
+export declare function createWebSearchCall(config?: any): (prompt: string) => Promise<string>;
+/**
+ * Verify whether a component is a known product/solution or an abstract
+ * capability using web search evidence.
+ *
+ * This function is designed as the fallback tier in the detection pipeline:
+ *   Tier 1: Naming convention heuristics (fast, no cost)
+ *   Tier 2: LLM semantic classification (moderate cost)
+ *   Tier 3: Web search verification (higher cost, higher accuracy) ← this
+ *
+ * @param {string} name - Component name to verify
+ * @param {Object} [options={}]
+ * @param {function(string): Promise<string>} [options.webSearchCall]
+ *   Custom web search function. If not provided, creates one via
+ *   createWebSearchCall(). Accepts a prompt and returns raw text response.
+ * @param {string} [options.context] - Additional context about the component
+ * @returns {Promise<WebSearchVerificationResult>}
+ */
+export declare function verifyViaWebSearch(name: string, options?: {
+    description?: string;
+    context?: string;
+    webSearchCall?: any;
+    timeoutMs?: number;
+}): Promise<WebSearchVerificationResult>;
+/**
+ * Combine web search verification with a prior naming/LLM classification.
+ *
+ * Used by the detection pipeline to merge evidence from multiple tiers.
+ * When web search agrees with the prior result, confidence is boosted.
+ * When they disagree, the web search result takes priority (it has
+ * stronger evidence) but confidence is reduced.
+ *
+ * @param {Object} priorResult   - Result from naming or LLM tier
+ * @param {WebSearchVerificationResult} webResult - Web search result
+ * @returns {WebSearchVerificationResult} Combined result
+ */
+export declare function combineWithPriorResult(priorResult: any, webResult: WebSearchVerificationResult): any;
+//# sourceMappingURL=web-search-verification.d.mts.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/web-search-verification.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-search-verification.d.mts","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/web-search-verification.mts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,2BAA2B,EAAyC,MAAM,oBAAoB,CAAC;AA6B7G;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAIH;;;;;;;GAOG;AAKH;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uDAmChE;AAmLD;;;;;;;;;;GAUG;AAEH,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,GAAQ,IAMd,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAoDrE;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAyD9L;AAID;;;;;;;;;;;GAWG;AAEH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,2BAA2B,GAAG,GAAG,CAmCpG"}