labre-mcp 0.1.0

package/dist/work-on-evolution/write/strategies/solution/aggregate-properties.mjs

@@ -0,0 +1,416 @@
+// Property aggregation logic for solution evolution evaluation.
+//
+// Takes individual per-property phase scores and computes an overall
+// evolution placement on the Wardley competitive axis (0–1).
+//
+// Features:
+//   - Equal-weight aggregation by default (1/N for each property)
+//   - Custom weight overrides per property
+//   - Property toggling: disable properties and renormalize remaining weights
+//     (follows the CPC indicator toggle pattern from patent-indicators)
+//   - Partial coverage handling: graceful degradation when not all 12 properties
+//     are evaluated
+//   - Confidence model based on coverage, phase agreement, and weight quality
+//
+// This module is the single source of truth for property → evolution aggregation
+// across all solution strategies. It is consumed by:
+//   - SolutionBaseStrategy.aggregateProperties() (delegates here)
+//   - SolutionEvolutionResult.fromPropertyScores()
+//   - PropertiesStrategy.evaluate()
+//   - Any future solution strategy that produces per-property evaluations
+//
+// The aggregation contract:
+//   Input:  Array of { property, phase (1–4), weight?, enabled? }
+//   Output: { evolution (0–1), confidence (0–1), weightMap, metadata }
+//
+// Usage:
+//   import { aggregatePropertyScores, renormalizeWeights } from './aggregate-properties.mjs';
+//
+//   const result = aggregatePropertyScores(scores);
+//   // → { evolution: 0.55, confidence: 0.85, weightMap: {...}, metadata: {...} }
+//
+//   // With toggling:
+//   const result = aggregatePropertyScores(scores, {
+//     disabled: ['efficiency', 'decision_driver'],
+//   });
+// ─── Phase ↔ Evolution Mapping ─────────────────────────────────────────────────
+// Defined locally to avoid circular dependency with solution-base-strategy.mjs,
+// which may delegate its aggregateProperties() to this module.
+// Values match solution-base-strategy.mjs and evolution-properties.json exactly.
+/**
+ * Map discrete phase (1–4) to continuous evolution midpoint on the Wardley axis.
+ * @type {Readonly<Record<number, number>>}
+ */
+const PHASE_TO_EVOLUTION = Object.freeze({
+    1: 0.09, // Genesis   [0.00, 0.18]
+    2: 0.29, // Custom    [0.18, 0.40]
+    3: 0.55, // Product   [0.40, 0.70]
+    4: 0.85, // Commodity [0.70, 1.00]
+});
+export { PHASE_TO_EVOLUTION };
+// ─── Constants ──────────────────────────────────────────────────────────────────
+/** Standard property count in the Wardley evolution reference model. */
+export const STANDARD_PROPERTY_COUNT = 12;
+/** Default weight per property (equal weighting). */
+export const DEFAULT_WEIGHT = 1 / STANDARD_PROPERTY_COUNT;
+/** Maximum confidence when all properties are evaluated with full coverage. */
+export const MAX_BASE_CONFIDENCE = 0.85;
+/** Minimum confidence floor (even with very poor coverage). */
+export const MIN_CONFIDENCE = 0.10;
+/** Maximum overall confidence cap (prevent over-confidence). */
+export const MAX_CONFIDENCE = 0.95;
+// ─── Weight Renormalization ─────────────────────────────────────────────────────
+// Follows the CPC indicator toggling pattern:
+// When some properties are disabled, remaining weights are renormalized to sum to 1.0.
+/**
+ * @typedef {Object} PropertyWeightConfig
+ * @property {number}  weight   - Base weight for this property
+ * @property {boolean} enabled  - Whether the property participates in aggregation
+ */
+/**
+ * Renormalize weights for enabled properties so they sum to 1.0.
+ * Disabled properties are excluded entirely from the aggregation.
+ *
+ * This is the solution-strategies equivalent of the patent indicator
+ * toggle pattern in cpc-evolution-strategy.mjs.
+ *
+ * @param {Record<string, PropertyWeightConfig>} weightConfig
+ *   Map of property identifier → { weight, enabled }.
+ *   Identifiers can be property names or IDs.
+ * @returns {Record<string, number>}
+ *   Map of enabled property identifier → renormalized weight.
+ *   Empty map if all properties are disabled.
+ *
+ * @example
+ *   const config = {
+ *     market:               { weight: 1/12, enabled: true },
+ *     knowledge_management: { weight: 1/12, enabled: true },
+ *     efficiency:           { weight: 1/12, enabled: false },
+ *     // ...
+ *   };
+ *   const weights = renormalizeWeights(config);
+ *   // efficiency excluded, others get proportionally higher weights summing to 1.0
+ */
+// any: weightConfig is a loose { key: { weight, enabled } } bag with dynamic key set
+export function renormalizeWeights(weightConfig) {
+    const enabled = Object.entries(weightConfig)
+        .filter(([, cfg]) => cfg.enabled !== false);
+    if (enabled.length === 0) {
+        return {};
+    }
+    const totalWeight = enabled.reduce((sum, [, cfg]) => sum + (cfg.weight || 0), 0);
+    const normalized = {};
+    for (const [name, cfg] of enabled) {
+        normalized[name] = totalWeight > 0
+            ? cfg.weight / totalWeight
+            : 1 / enabled.length;
+    }
+    return normalized;
+}
+/**
+ * Build a weight configuration map from an array of property evaluations,
+ * optionally applying a disabled list and custom weight overrides.
+ *
+ * @param {Array<{ property: string, phase: number, weight?: number }>} properties
+ *   Array of per-property evaluations.
+ * @param {Object} [options={}]
+ * @param {string[]}  [options.disabled=[]]      - Property names/IDs to disable
+ * @param {Record<string, number>} [options.customWeights={}] - Custom weight overrides by property name/ID
+ * @returns {Record<string, PropertyWeightConfig>}
+ */
+// any: builder output is a heterogeneous weight config map
+export function buildWeightConfig(properties, options = {}) {
+    const disabled = new Set((options.disabled || []).map((n) => n.toLowerCase().trim()));
+    const customWeights = options.customWeights || {};
+    const config = {};
+    for (const prop of properties) {
+        const key = (prop.id || prop.property || '').toLowerCase().replace(/[\s/]+/g, '_');
+        const displayKey = prop.id || prop.property || key;
+        // Check if this property is in the disabled set
+        const isDisabled = disabled.has(key)
+            || disabled.has((prop.property || '').toLowerCase())
+            || disabled.has(displayKey.toLowerCase());
+        // Apply custom weight if provided, otherwise use existing or default
+        const baseWeight = customWeights[key]
+            ?? customWeights[(prop.property || '').toLowerCase()]
+            ?? customWeights[displayKey]
+            ?? prop.weight
+            ?? DEFAULT_WEIGHT;
+        config[displayKey] = {
+            weight: baseWeight,
+            enabled: !isDisabled,
+        };
+    }
+    return config;
+}
+// ─── Core Aggregation ───────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} AggregationResult
+ * @property {number}  evolution   - Weighted average evolution position (0–1)
+ * @property {number}  confidence  - Aggregation confidence score (0–1)
+ * @property {Record<string, number>} weightMap
+ *   Final normalized weights used (after toggling/renormalization)
+ * @property {AggregationMetadata} metadata
+ *   Detailed metadata about the aggregation computation
+ */
+/**
+ * @typedef {Object} AggregationMetadata
+ * @property {number}  totalProperties     - Total input properties
+ * @property {number}  enabledProperties   - Properties participating in aggregation
+ * @property {number}  disabledProperties  - Properties excluded from aggregation
+ * @property {number}  validProperties     - Properties with valid phases (1–4)
+ * @property {number}  coverage            - Ratio of valid/enabled to total standard (0–1)
+ * @property {string}  aggregationMethod   - Method identifier: 'weighted_average'
+ * @property {number}  phaseAgreement      - Inter-property phase consistency (0–1)
+ * @property {{ 1: number, 2: number, 3: number, 4: number }} phaseDistribution
+ *   Count of properties at each phase
+ * @property {number}  meanPhase           - Mean phase across evaluated properties
+ * @property {number}  weightedPhase       - Weighted mean phase
+ * @property {boolean} renormalized        - Whether weight renormalization was applied
+ */
+/**
+ * Aggregate per-property phase evaluations into a single evolution placement.
+ *
+ * This is the primary aggregation function for solution evaluation. It takes
+ * an array of per-property phase scores and computes:
+ *   1. Weighted average of phase midpoints → overall evolution value
+ *   2. Coverage-based confidence score
+ *   3. Detailed aggregation metadata
+ *
+ * Default behavior: equal weights (1/N), all properties enabled.
+ *
+ * Advanced behavior (CPC indicator toggle pattern):
+ *   - Disable specific properties via `options.disabled`
+ *   - Override weights via `options.customWeights`
+ *   - Remaining weights are renormalized to sum to 1.0
+ *
+ * @param {Array<{ property: string, phase: number, weight?: number, id?: string }>} properties
+ *   Array of per-property evaluations. Each must have:
+ *     - property: Property name (e.g. "Market")
+ *     - phase: Evaluated phase (1–4)
+ *     - weight: Optional custom weight (default: 1/N)
+ *     - id: Optional canonical property ID
+ *
+ * @param {Object} [options={}]
+ * @param {string[]}  [options.disabled=[]]
+ *   Property names/IDs to exclude from aggregation. Weights are renormalized.
+ * @param {Record<string, number>} [options.customWeights={}]
+ *   Override weights by property name/ID. Applied before renormalization.
+ * @param {number}  [options.totalExpected=12]
+ *   Total expected properties (for coverage calculation). Default: 12.
+ *
+ * @returns {AggregationResult}
+ *   The aggregated evolution result with confidence and metadata.
+ *
+ * @throws {Error} If properties array is empty or all properties are disabled.
+ *
+ * @example
+ *   // Basic: all 12 properties with equal weights
+ *   const result = aggregatePropertyScores([
+ *     { property: 'Market', phase: 3 },
+ *     { property: 'Knowledge management', phase: 3 },
+ *     // ... 10 more
+ *   ]);
+ *   // → { evolution: 0.55, confidence: 0.85, ... }
+ *
+ * @example
+ *   // With toggling: disable two properties
+ *   const result = aggregatePropertyScores(allProperties, {
+ *     disabled: ['efficiency', 'decision_driver'],
+ *   });
+ *   // Remaining 10 properties have renormalized weights summing to 1.0
+ *
+ * @example
+ *   // With custom weights: emphasize market properties
+ *   const result = aggregatePropertyScores(allProperties, {
+ *     customWeights: { market: 0.2, market_perception: 0.15 },
+ *   });
+ */
+// any: returns a heterogeneous result bag (evolution, confidence, properties, dist, dominant, coverage, weightMap…) — typed by caller via assembleSolutionResult
+export function aggregatePropertyScores(properties, options = {}) {
+    if (!Array.isArray(properties) || properties.length === 0) {
+        throw new Error('aggregatePropertyScores requires a non-empty array of property evaluations');
+    }
+    const totalExpected = options.totalExpected ?? STANDARD_PROPERTY_COUNT;
+    const hasToggling = Boolean((options.disabled && options.disabled.length > 0)
+        || (options.customWeights && Object.keys(options.customWeights).length > 0));
+    // Step 1: Build weight configuration with toggling support
+    const weightConfig = buildWeightConfig(properties, options);
+    // Step 2: Renormalize weights for enabled properties
+    const weightMap = renormalizeWeights(weightConfig);
+    const enabledKeys = Object.keys(weightMap);
+    if (enabledKeys.length === 0) {
+        throw new Error('All properties are disabled — cannot aggregate');
+    }
+    // Step 3: Map properties to their weight keys for lookup
+    const propertyByKey = new Map();
+    for (const prop of properties) {
+        const key = prop.id || prop.property || '';
+        propertyByKey.set(key, prop);
+        // Also index by lowercased property name
+        if (prop.property) {
+            propertyByKey.set(prop.property.toLowerCase(), prop);
+        }
+    }
+    // Step 4: Compute weighted sum of evolution midpoints
+    let weightedEvolutionSum = 0;
+    let weightedPhaseSum = 0;
+    let validCount = 0;
+    let totalUsedWeight = 0;
+    const phaseDistribution = { 1: 0, 2: 0, 3: 0, 4: 0 };
+    let phaseSum = 0;
+    let enabledEvaluated = 0;
+    for (const [key, weight] of Object.entries(weightMap)) {
+        // Find the property data for this key
+        const prop = propertyByKey.get(key)
+            || propertyByKey.get(key.toLowerCase())
+            || propertyByKey.get(key.toLowerCase().replace(/[\s/]+/g, '_'));
+        if (!prop)
+            continue;
+        const phase = prop.phase;
+        if (typeof phase !== 'number' || phase < 1 || phase > 4)
+            continue;
+        const roundedPhase = Math.round(phase);
+        const evolution = PHASE_TO_EVOLUTION[roundedPhase];
+        if (evolution === undefined)
+            continue;
+        weightedEvolutionSum += evolution * weight;
+        weightedPhaseSum += roundedPhase * weight;
+        totalUsedWeight += weight;
+        validCount++;
+        enabledEvaluated++;
+        phaseDistribution[roundedPhase]++;
+        phaseSum += roundedPhase;
+    }
+    if (validCount === 0) {
+        throw new Error('No valid property evaluations (all phases must be 1–4)');
+    }
+    // Step 5: Scale evolution if not all enabled properties were valid
+    // (some might have had invalid phases)
+    const evolution = totalUsedWeight > 0
+        ? Math.round((weightedEvolutionSum / totalUsedWeight) * 1000) / 1000
+        : 0;
+    const meanPhase = validCount > 0
+        ? Math.round((phaseSum / validCount) * 100) / 100
+        : 0;
+    const weightedPhase = totalUsedWeight > 0
+        ? Math.round((weightedPhaseSum / totalUsedWeight) * 100) / 100
+        : 0;
+    // Step 6: Compute confidence
+    const disabledCount = properties.length - enabledKeys.length;
+    const coverage = validCount / totalExpected;
+    const confidence = computeAggregationConfidence(coverage, phaseDistribution, validCount);
+    // Step 7: Compute phase agreement (normalized entropy)
+    const phaseAgreement = computePhaseAgreement(phaseDistribution, validCount);
+    // Step 8: Build metadata
+    const metadata = {
+        totalProperties: properties.length,
+        enabledProperties: enabledKeys.length,
+        disabledProperties: disabledCount,
+        validProperties: validCount,
+        coverage: Math.round(coverage * 1000) / 1000,
+        aggregationMethod: 'weighted_average',
+        phaseAgreement,
+        phaseDistribution,
+        meanPhase,
+        weightedPhase,
+        renormalized: hasToggling,
+    };
+    return {
+        evolution,
+        confidence,
+        weightMap,
+        metadata,
+    };
+}
+// ─── Confidence Model ───────────────────────────────────────────────────────────
+/**
+ * Compute aggregation confidence based on:
+ *   - Coverage: ratio of evaluated properties to expected total
+ *
+ * The base confidence model follows the original SolutionBaseStrategy
+ * contract: full coverage → MAX_BASE_CONFIDENCE (0.85), partial →
+ * proportionally lower. Phase agreement data is available in metadata
+ * for higher-level consumers to optionally boost confidence.
+ *
+ * @param {number} coverage          - Evaluated / total expected (0–1)
+ * @param {{ 1: number, 2: number, 3: number, 4: number }} phaseDistribution
+ * @param {number} evaluatedCount    - Number of properties with valid evaluations
+ * @returns {number} Confidence score (0–1)
+ */
+function computeAggregationConfidence(coverage, phaseDistribution, evaluatedCount) {
+    // Base confidence from coverage
+    // Full coverage → MAX_BASE_CONFIDENCE (0.85)
+    // Partial → proportionally lower
+    const coverageConfidence = Math.min(MAX_BASE_CONFIDENCE, coverage * MAX_BASE_CONFIDENCE);
+    // Clamp to bounds
+    const capped = Math.min(MAX_CONFIDENCE, Math.max(MIN_CONFIDENCE, coverageConfidence));
+    return Math.round(capped * 1000) / 1000;
+}
+/**
+ * Compute phase agreement metric using normalized entropy.
+ *
+ * 0 = all properties at the same phase (maximum agreement)
+ * 1 = perfectly uniform distribution across all 4 phases (minimum agreement)
+ *
+ * RETURNS: inverted (1 = max agreement, 0 = uniform distribution)
+ *
+ * @param {{ 1: number, 2: number, 3: number, 4: number }} distribution
+ * @param {number} total - Total count of evaluated properties
+ * @returns {number} Phase agreement score (0–1), where 1 = perfect agreement
+ */
+export function computePhaseAgreement(distribution, total) {
+    if (total === 0)
+        return 0;
+    let entropy = 0;
+    for (const count of Object.values(distribution)) {
+        if (count > 0) {
+            const p = count / total;
+            entropy -= p * Math.log2(p);
+        }
+    }
+    const maxEntropy = Math.log2(4); // 2.0 for 4 phases
+    const normalizedEntropy = maxEntropy > 0 ? entropy / maxEntropy : 0;
+    return Math.round((1 - normalizedEntropy) * 1000) / 1000;
+}
+// ─── Convenience: Aggregate with PropertyScore instances ────────────────────────
+/**
+ * Aggregate an array of PropertyScore instances (from solution-evolution-result.mjs).
+ *
+ * This is a convenience wrapper around aggregatePropertyScores that accepts
+ * PropertyScore instances directly, using their toPropertyEvaluation() method
+ * for the aggregation input.
+ *
+ * @param {Array<import('./solution-evolution-result.mjs').PropertyScore>} scores
+ *   Array of PropertyScore instances.
+ * @param {Object} [options={}] - Same options as aggregatePropertyScores.
+ * @returns {AggregationResult}
+ */
+// any: scores can be PropertyScore[] or plain eval[] — duck-typed via toPropertyEvaluation()
+export function aggregatePropertyScoreInstances(scores, options = {}) {
+    const propEvals = scores.map((s) => {
+        if (typeof s.toPropertyEvaluation === 'function') {
+            const eval_ = s.toPropertyEvaluation();
+            eval_.id = s.id; // Preserve ID for key matching
+            return eval_;
+        }
+        return s;
+    });
+    return aggregatePropertyScores(propEvals, options);
+}
+// ─── Shortcut: Simple Equal-Weight Aggregation ──────────────────────────────────
+/**
+ * Simple equal-weight aggregation without toggling.
+ * Backward-compatible with the original SolutionBaseStrategy.aggregateProperties().
+ *
+ * @param {Array<{ property: string, phase: number, weight?: number }>} properties
+ * @returns {{ evolution: number, confidence: number }}
+ */
+export function simpleAggregate(properties) {
+    const result = aggregatePropertyScores(properties);
+    return {
+        evolution: result.evolution,
+        confidence: result.confidence,
+    };
+}
+//# sourceMappingURL=aggregate-properties.mjs.map

package/dist/work-on-evolution/write/strategies/solution/aggregate-properties.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-properties.mjs","sourceRoot":"","sources":["../../../../../src/work-on-evolution/write/strategies/solution/aggregate-properties.mts"],"names":[],"mappings":"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"}

package/dist/work-on-evolution/write/strategies/solution/assemble-result.d.mts

@@ -0,0 +1,91 @@
+import type { PropertyEvaluation } from '../../../../types/solution.mjs';
+/**
+ * Compute phase distribution from an array of property evaluations.
+ *
+ * @param {Array<{ phase: number }>} properties
+ * @returns {{ 1: number, 2: number, 3: number, 4: number }}
+ */
+declare function computePhaseDistribution(properties: PropertyEvaluation[]): Record<number, number>;
+/**
+ * Compute the dominant phase (mode) from a distribution.
+ *
+ * @param {{ 1: number, 2: number, 3: number, 4: number }} distribution
+ * @returns {{ phase: number, count: number, label: string }}
+ */
+declare function dominantPhase(distribution: Record<number, number>): {
+    phase: number;
+    count: number;
+    label: string;
+};
+/**
+ * Compute mean phase across evaluated properties.
+ *
+ * @param {Array<{ phase: number }>} properties
+ * @returns {number} Mean phase (1–4), rounded to 2 decimals
+ */
+declare function computeMeanPhase(properties: PropertyEvaluation[]): number;
+/**
+ * @typedef {Object} AssemblyOptions
+ * @property {string}  [mode='auto']    - Evaluation mode ('auto' | 'conversational')
+ * @property {boolean} [enrichMetadata=true] - Whether to add phase distribution and confidence metadata
+ */
+/**
+ * Assemble a solution strategy result into a rich, structured format.
+ *
+ * Takes a raw EvolutionResult (as returned by a solution strategy's evaluate())
+ * and enriches it with:
+ *   - `stage`: Wardley stage label (Genesis/Custom/Product/Commodity)
+ *   - `meanPhase`: average phase across properties
+ *   - `phaseDistribution`: count per phase { 1: n, 2: n, 3: n, 4: n }
+ *   - `dominantPhase`: the most common phase
+ *   - `confidenceMetadata`: structured metadata about confidence computation
+ *
+ * If the result already has rich metadata (e.g. it's a SolutionEvolutionResult),
+ * the assembler preserves existing metadata and only fills gaps.
+ *
+ * If the result has no properties array (e.g. a non-property-based strategy),
+ * it passes through with only the stage label added.
+ *
+ * @param {Object} rawResult - Raw strategy evaluation result
+ *   Must conform to EvolutionResult: { evolution, confidence, method, trace?, properties? }
+ * @param {AssemblyOptions} [options={}]
+ * @returns {Object} Enriched result with all original fields plus metadata
+ */
+export declare function assembleSolutionResult(rawResult: any, options?: any): any;
+/**
+ * Assemble multiple solution strategy results into a unified evaluations map.
+ *
+ * This is the batch version of assembleSolutionResult, designed to be called
+ * after all solution strategies have evaluated. It enriches each result
+ * individually and returns the enriched evaluations map.
+ *
+ * @param {Object<string, Object>} evaluations - Map of method → raw result
+ * @param {AssemblyOptions} [options={}]
+ * @returns {Object<string, Object>} Map of method → enriched result
+ */
+export declare function assembleSolutionEvaluations(evaluations: Record<string, any>, options?: any): Record<string, any>;
+/**
+ * Build a structured SolutionEvolutionResult instance from a raw result.
+ *
+ * This is the full-model version that creates a proper SolutionEvolutionResult
+ * with PropertyScore instances and ConfidenceMetadata. Use this when you need
+ * the full structured API (e.g. for validation, serialization, or rich display).
+ *
+ * For lighter-weight enrichment that keeps plain objects, use assembleSolutionResult.
+ *
+ * @param {Object} rawResult - Raw strategy evaluation result with properties
+ * @param {Object} [options={}]
+ * @param {string} [options.mode='auto'] - Evaluation mode
+ * @returns {SolutionEvolutionResult}
+ * @throws {Error} If rawResult doesn't have required fields or properties
+ */
+export declare function buildStructuredResult(rawResult: any, options?: any): any;
+/**
+ * Resolve the Wardley stage label from an evolution value.
+ *
+ * @param {number} evolution - Evolution value (0–1)
+ * @returns {string} Stage label: 'Genesis' | 'Custom' | 'Product' | 'Commodity'
+ */
+declare function resolveStage(evolution: number): string;
+export { resolveStage, computePhaseDistribution, computeMeanPhase, dominantPhase };
+//# sourceMappingURL=assemble-result.d.mts.map

package/dist/work-on-evolution/write/strategies/solution/assemble-result.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble-result.d.mts","sourceRoot":"","sources":["../../../../../src/work-on-evolution/write/strategies/solution/assemble-result.mts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;;;GAKG;AACH,iBAAS,wBAAwB,CAAC,UAAU,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAO1F;AAED;;;;;GAKG;AACH,iBAAS,aAAa,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAc5G;AAED;;;;;GAKG;AACH,iBAAS,gBAAgB,CAAC,UAAU,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAIlE;AAID;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CA4D7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAE,GAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAMpH;AAED;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CA2C5E;AAID;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAM/C;AAED,OAAO,EAAE,YAAY,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAC"}