labre-mcp 0.1.0

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/phase-classifier.mjs

@@ -0,0 +1,453 @@
+// Per-property phase classification logic for Wardley evolution evaluation.
+//
+// Evaluates input text (solution description, evidence, context) against
+// the 12-property phase reference to assign a phase (1–4) for each property.
+//
+// Classification approach:
+//   1. Extract discriminative terms from each phase description
+//   2. Build per-property signal banks with TF-IDF-like weighting
+//   3. Augment with general cross-property phase indicators
+//   4. Score input text against each phase's signals (unigrams + bigrams)
+//   5. Select the phase with the highest normalized score
+//   6. Compute confidence from score distribution (margin between top two)
+//
+// This module provides a fast, non-LLM classification path that can be used:
+//   - As a standalone heuristic evaluator
+//   - As a validation layer to cross-check LLM classifications
+//   - As a fallback when LLM is unavailable
+//
+// Usage:
+//   import { PhaseClassifier } from './phase-classifier.mjs';
+//   const classifier = await PhaseClassifier.fromReference();
+//   const result = classifier.classifyAll('Kubernetes is a widely adopted...');
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ─── Stop Words ───────────────────────────────────────────────────────────────
+// Common English words filtered out during term extraction.
+// Kept minimal — only high-frequency function words that carry no phase signal.
+const STOP_WORDS = new Set([
+    'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+    'of', 'with', 'by', 'from', 'as', 'is', 'it', 'its', 'are', 'was',
+    'were', 'be', 'been', 'being', 'has', 'have', 'had', 'do', 'does',
+    'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall',
+    'can', 'that', 'which', 'who', 'whom', 'this', 'these', 'those',
+    'not', 'no', 'nor', 'so', 'yet', 'both', 'each', 'few', 'more',
+    'most', 'other', 'some', 'such', 'than', 'too', 'very', 'just',
+    'also', 'into', 'about', 'over', 'after', 'before', 'between',
+    'through', 'during', 'above', 'below', 'up', 'out', 'off', 'down',
+    'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how',
+    'all', 'any', 'if', 'even', 'only', 'own', 'same', 'via',
+]);
+// ─── General Phase Indicators ─────────────────────────────────────────────────
+// Cross-property keywords that strongly signal a specific phase regardless
+// of which property is being evaluated.  These augment the per-property
+// signals extracted from phase descriptions.
+const GENERAL_PHASE_SIGNALS = {
+    1: [
+        'genesis', 'novel', 'experimental', 'unproven', 'prototype',
+        'proof of concept', 'research', 'invention', 'pioneering',
+        'unexplored', 'undefined', 'nascent', 'embryonic', 'frontier',
+        'bleeding edge', 'unknown territory', 'first of its kind',
+        'early stage', 'pre-market', 'lab', 'academic',
+        'concept', 'speculative', 'visionary', 'untested',
+    ],
+    2: [
+        'custom', 'bespoke', 'tailored', 'early adopter', 'emerging',
+        'niche', 'differentiation', 'custom-built', 'hand-crafted',
+        'specialist', 'artisanal', 'first mover', 'competitive advantage',
+        'growing adoption', 'early traction', 'fragmented',
+        'consultancy', 'consulting', 'professional services',
+        'learning curve', 'tribal knowledge',
+    ],
+    3: [
+        'product', 'standardized', 'vendor', 'platform', 'ecosystem',
+        'best practice', 'certification', 'certified', 'mainstream',
+        'established', 'proven', 'reliable', 'feature-rich',
+        'competitive market', 'analyst', 'industry standard',
+        'sla', 'service level', 'benchmark', 'reference architecture',
+        'total cost of ownership', 'tco', 'enterprise',
+        'widespread adoption', 'production-ready', 'mature product',
+    ],
+    4: [
+        'commodity', 'utility', 'ubiquitous', 'commoditized',
+        'standardised', 'price-driven', 'automated', 'just works',
+        'infrastructure', 'scale', 'economies of scale', 'self-service',
+        'api-driven', 'on-demand', 'pay-per-use', 'volume-based',
+        'taken for granted', 'invisible', 'baseline', 'essential',
+        'compliance', 'operational excellence', 'marginal cost',
+        'utility pricing', 'interchangeable', 'fungible',
+    ],
+};
+// ─── Text Processing Utilities ────────────────────────────────────────────────
+/**
+ * Normalize text for comparison: lowercase, remove punctuation, collapse whitespace.
+ * @param {string} text
+ * @returns {string}
+ */
+function normalizeText(text) {
+    return (text || '')
+        .toLowerCase()
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        .replace(/[^\w\s'-]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Extract meaningful unigram tokens from text (words, excluding stop words).
+ * @param {string} text - Normalized text
+ * @returns {string[]}
+ */
+function extractTokens(text) {
+    return normalizeText(text)
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+}
+/**
+ * Extract bigram phrases from text (consecutive word pairs).
+ * @param {string} text - Normalized text
+ * @returns {string[]}
+ */
+function extractBigrams(text) {
+    const words = normalizeText(text).split(/\s+/).filter((w) => w.length > 1);
+    const bigrams = [];
+    for (let i = 0; i < words.length - 1; i++) {
+        bigrams.push(`${words[i]} ${words[i + 1]}`);
+    }
+    return bigrams;
+}
+function buildPropertySignals(property) {
+    const phases = property.phases || {};
+    // Step 1: Extract all unigram tokens per phase
+    const phaseTokens = {};
+    for (const phaseNum of [1, 2, 3, 4]) {
+        const desc = phases[String(phaseNum)] || '';
+        phaseTokens[phaseNum] = new Set(extractTokens(desc));
+    }
+    // Step 2: Count how many phases each token appears in (for discrimination)
+    const tokenPhaseCount = {};
+    for (const phaseNum of [1, 2, 3, 4]) {
+        for (const token of phaseTokens[phaseNum]) {
+            tokenPhaseCount[token] = (tokenPhaseCount[token] || 0) + 1;
+        }
+    }
+    // Step 3: Build signal entries with discrimination-based weights
+    const phaseSignals = new Map();
+    for (const phaseNum of [1, 2, 3, 4]) {
+        const signals = [];
+        // Signals from description tokens (unigrams)
+        for (const token of phaseTokens[phaseNum]) {
+            const phaseCount = tokenPhaseCount[token] || 1;
+            const discriminativeWeight = 1.0 / phaseCount;
+            signals.push({
+                term: token,
+                weight: discriminativeWeight,
+                source: 'description',
+            });
+        }
+        // Signals from description bigrams (phrases)
+        const desc = phases[String(phaseNum)] || '';
+        const bigrams = extractBigrams(desc);
+        for (const bigram of bigrams) {
+            // Check if this bigram is unique to this phase
+            const bigramInOthers = [1, 2, 3, 4]
+                .filter(p => p !== phaseNum)
+                .some(p => normalizeText(phases[String(p)] || '').includes(bigram));
+            signals.push({
+                term: bigram,
+                weight: bigramInOthers ? 0.3 : 0.8,
+                source: 'description-bigram',
+            });
+        }
+        // Signals from general phase indicators
+        const generalTerms = GENERAL_PHASE_SIGNALS[phaseNum] || [];
+        for (const term of generalTerms) {
+            signals.push({
+                term: normalizeText(term),
+                weight: 0.6,
+                source: 'general',
+            });
+        }
+        phaseSignals.set(phaseNum, signals);
+    }
+    return {
+        propertyName: property.name,
+        propertyId: property.id || property.name.toLowerCase().replace(/\s+/g, '_'),
+        phases: phaseSignals,
+    };
+}
+// ─── PhaseClassifier ──────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} PropertyClassification
+ * @property {string}  property    - Property name (e.g. "Market")
+ * @property {number}  phase       - Assigned phase (1–4)
+ * @property {string}  label       - Phase label (Genesis, Custom, Product, Commodity)
+ * @property {number}  confidence  - Classification confidence (0–1)
+ * @property {Object}  scores      - Raw scores per phase { 1: n, 2: n, 3: n, 4: n }
+ * @property {string}  reason      - Brief explanation of classification
+ */
+const PHASE_LABELS = { 1: 'Genesis', 2: 'Custom', 3: 'Product', 4: 'Commodity' };
+/**
+ * Per-property phase classifier for Wardley evolution evaluation.
+ *
+ * Evaluates input text against the 12-property phase reference using
+ * keyword-based scoring with TF-IDF-like discrimination weighting.
+ *
+ * @example
+ *   const classifier = await PhaseClassifier.fromReference();
+ *   const results = classifier.classifyAll('Kubernetes is a mature container orchestration platform...');
+ *   // → [{ property: 'Market', phase: 3, confidence: 0.72, ... }, ...]
+ *
+ * @example
+ *   const result = classifier.classifyProperty('Market', 'Highly commoditized market...');
+ *   // → { property: 'Market', phase: 4, confidence: 0.85, ... }
+ */
+export class PhaseClassifier {
+    _properties;
+    _signalBank;
+    constructor(propertiesRef) {
+        if (!Array.isArray(propertiesRef) || propertiesRef.length === 0) {
+            throw new Error('PhaseClassifier requires a non-empty properties reference array');
+        }
+        this._properties = propertiesRef;
+        this._signalBank = propertiesRef.map(buildPropertySignals);
+    }
+    /**
+     * Create a PhaseClassifier from the evolution-properties.json reference file.
+     * Factory method that handles async file loading.
+     *
+     * @returns {Promise<PhaseClassifier>}
+     */
+    static async fromReference() {
+        const refPath = join(__dirname, 'evolution-properties.json');
+        const raw = await readFile(refPath, 'utf-8');
+        const data = JSON.parse(raw);
+        const properties = data.properties || data;
+        return new PhaseClassifier(properties);
+    }
+    /**
+     * Get the number of properties in the reference.
+     * @returns {number}
+     */
+    get propertyCount() {
+        return this._properties.length;
+    }
+    /**
+     * Get the list of property names.
+     * @returns {string[]}
+     */
+    get propertyNames() {
+        return this._properties.map((p) => p.name);
+    }
+    /**
+     * Classify input text for a single property, returning the best-matching phase.
+     *
+     * Scoring algorithm:
+     *   1. Normalize and tokenize the input text
+     *   2. For each phase (1–4), scan the signal bank for term matches
+     *   3. Sum matched signal weights → raw phase score
+     *   4. Select the phase with highest score
+     *   5. Compute confidence from score margin between top two phases
+     *
+     * @param {string} propertyName - Name of the property to classify (e.g. "Market")
+     * @param {string} inputText    - Text to evaluate (solution description, evidence, etc.)
+     * @returns {PropertyClassification}
+     * @throws {Error} If propertyName is not found in the reference
+     */
+    classifyProperty(propertyName, inputText) {
+        const signals = this._findPropertySignals(propertyName);
+        return this._scoreAndClassify(signals, inputText);
+    }
+    /**
+     * Classify input text against all 12 properties, returning per-property phases.
+     *
+     * @param {string} inputText - Text to evaluate against all properties
+     * @returns {PropertyClassification[]} Array of 12 classifications (one per property)
+     */
+    classifyAll(inputText) {
+        return this._signalBank.map((signals) => this._scoreAndClassify(signals, inputText));
+    }
+    /**
+     * Classify input text against a subset of properties.
+     *
+     * @param {string} inputText      - Text to evaluate
+     * @param {string[]} propertyNames - Names of properties to evaluate
+     * @returns {PropertyClassification[]}
+     */
+    classifySubset(inputText, propertyNames) {
+        const nameSet = new Set(propertyNames.map((n) => n.toLowerCase()));
+        return this._signalBank
+            .filter((s) => nameSet.has(s.propertyName.toLowerCase()))
+            .map((signals) => this._scoreAndClassify(signals, inputText));
+    }
+    /**
+     * Validate an existing phase classification against the classifier's judgment.
+     * Returns the degree of agreement (0 = complete disagreement, 1 = exact match).
+     *
+     * @param {string} propertyName  - Property name
+     * @param {number} assignedPhase - Phase assigned by another method (e.g. LLM)
+     * @param {string} inputText     - The text that was classified
+     * @returns {{ agreement: number, classifierPhase: number, assignedPhase: number, delta: number }}
+     */
+    validateClassification(propertyName, assignedPhase, inputText) {
+        const classification = this.classifyProperty(propertyName, inputText);
+        const delta = Math.abs(classification.phase - assignedPhase);
+        // Agreement: 1.0 for exact match, 0.67 for ±1, 0.33 for ±2, 0.0 for ±3
+        const agreement = Math.max(0, 1 - (delta / 3));
+        return {
+            agreement,
+            classifierPhase: classification.phase,
+            assignedPhase,
+            delta,
+            classifierConfidence: classification.confidence,
+        };
+    }
+    // ─── Internal Methods ─────────────────────────────────────────────────────
+    /**
+     * Find the signal bank entry for a given property name.
+     * Uses fuzzy matching (case-insensitive, substring).
+     *
+     * @param {string} propertyName
+     * @returns {PropertySignals}
+     * @private
+     */
+    _findPropertySignals(propertyName) {
+        const lower = propertyName.toLowerCase().trim();
+        // Exact match
+        let match = this._signalBank.find((s) => s.propertyName.toLowerCase() === lower);
+        if (match)
+            return match;
+        // Substring match
+        match = this._signalBank.find((s) => s.propertyName.toLowerCase().includes(lower) ||
+            lower.includes(s.propertyName.toLowerCase()));
+        if (match)
+            return match;
+        const available = this._signalBank.map((s) => s.propertyName).join(', ');
+        throw new Error(`Unknown property "${propertyName}". Available: ${available}`);
+    }
+    /**
+     * Score input text against a property's signal bank and select the best phase.
+     *
+     * @param {PropertySignals} signals - Property signal bank
+     * @param {string} inputText        - Text to score
+     * @returns {PropertyClassification}
+     * @private
+     */
+    _scoreAndClassify(signals, inputText) {
+        const normalizedInput = normalizeText(inputText);
+        const inputTokens = new Set(extractTokens(inputText));
+        const inputBigrams = new Set(extractBigrams(inputText));
+        // Score each phase
+        const scores = { 1: 0, 2: 0, 3: 0, 4: 0 };
+        for (const phaseNum of [1, 2, 3, 4]) {
+            const phaseSignals = signals.phases.get(phaseNum) || [];
+            let phaseScore = 0;
+            for (const signal of phaseSignals) {
+                const term = signal.term;
+                let matched = false;
+                // Check for multi-word phrase match in normalized text
+                if (term.includes(' ')) {
+                    if (normalizedInput.includes(term)) {
+                        matched = true;
+                    }
+                }
+                else {
+                    // Single-word token match
+                    if (inputTokens.has(term)) {
+                        matched = true;
+                    }
+                }
+                if (matched) {
+                    phaseScore += signal.weight;
+                }
+            }
+            scores[phaseNum] = Math.round(phaseScore * 1000) / 1000;
+        }
+        // Select the phase with highest score
+        const { phase, confidence, reason } = this._selectPhase(scores, signals.propertyName);
+        return {
+            property: signals.propertyName,
+            phase,
+            label: PHASE_LABELS[phase],
+            confidence,
+            scores,
+            reason,
+        };
+    }
+    /**
+     * Select the winning phase from scores and compute confidence.
+     *
+     * Confidence is based on:
+     *   - Score margin: how much the top phase exceeds the runner-up
+     *   - Total score: whether there's enough signal to be meaningful
+     *
+     * When all scores are zero (no signal found), defaults to phase 2
+     * with very low confidence.
+     *
+     * @param {Object} scores   - Phase scores { 1: n, 2: n, 3: n, 4: n }
+     * @param {string} propName - Property name for reason text
+     * @returns {{ phase: number, confidence: number, reason: string }}
+     * @private
+     */
+    _selectPhase(scores, propName) {
+        const entries = Object.entries(scores)
+            .map(([p, s]) => ({ phase: parseInt(p, 10), score: s }))
+            .sort((a, b) => b.score - a.score);
+        const topScore = entries[0].score;
+        const totalScore = entries.reduce((sum, e) => sum + e.score, 0);
+        // No signal: default to phase 2 (Custom) with minimal confidence
+        if (totalScore === 0) {
+            return {
+                phase: 2,
+                confidence: 0.1,
+                reason: `No text signals matched for ${propName}; defaulted to Custom (phase 2)`,
+            };
+        }
+        const winningPhase = entries[0].phase;
+        const runnerUpScore = entries[1].score;
+        // Margin-based confidence
+        const margin = topScore - runnerUpScore;
+        const marginRatio = margin / topScore;
+        // Score adequacy: penalize if total score is low
+        // Sigmoid-like scaling: at totalScore=5 → ~0.92, at totalScore=1 → ~0.5
+        const adequacy = 1 - Math.exp(-totalScore / 3);
+        // Combined confidence: margin dominance × score adequacy, capped at 0.95
+        const rawConfidence = marginRatio * adequacy;
+        const confidence = Math.round(Math.min(0.95, Math.max(0.05, rawConfidence)) * 1000) / 1000;
+        // Build reason text
+        const label = PHASE_LABELS[winningPhase];
+        const reason = entries[0].score === entries[1].score
+            ? `${propName}: tied between phases, selected ${label} (phase ${winningPhase})`
+            : `${propName}: strongest signal for ${label} (phase ${winningPhase}), ` +
+                `score ${topScore.toFixed(2)} vs runner-up ${runnerUpScore.toFixed(2)}`;
+        return { phase: winningPhase, confidence, reason };
+    }
+}
+// ─── Convenience Functions ────────────────────────────────────────────────────
+/**
+ * Classify all 12 properties for a given input text in one call.
+ * Creates a classifier from the default reference file.
+ *
+ * @param {string} inputText - Solution description or evidence text
+ * @returns {Promise<PropertyClassification[]>}
+ */
+export async function classifyAllProperties(inputText) {
+    const classifier = await PhaseClassifier.fromReference();
+    return classifier.classifyAll(inputText);
+}
+/**
+ * Classify a single property for a given input text.
+ *
+ * @param {string} propertyName - Property name (e.g. "Market")
+ * @param {string} inputText    - Text to evaluate
+ * @returns {Promise<PropertyClassification>}
+ */
+export async function classifySingleProperty(propertyName, inputText) {
+    const classifier = await PhaseClassifier.fromReference();
+    return classifier.classifyProperty(propertyName, inputText);
+}
+// ─── Exports for Testing ──────────────────────────────────────────────────────
+export { normalizeText, extractTokens, extractBigrams, buildPropertySignals, GENERAL_PHASE_SIGNALS, PHASE_LABELS, };
+//# sourceMappingURL=phase-classifier.mjs.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/phase-classifier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-classifier.mjs","sourceRoot":"","sources":["../../../../../../../../src/frameworks/wardley/evolution/_legacy/write/strategies/solution/phase-classifier.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/properties-strategy.d.mts

@@ -0,0 +1,113 @@
+import { SolutionBaseStrategy } from './solution-base-strategy.mjs';
+import type { SolutionInput, SolutionEvolutionResult } from '#types/solution.mjs';
+import type { ParsedAutoResponse, ParsedPropertyEvaluation } from '#schemas/parsed-llm.schema.mjs';
+/** @type {object[]|null} Cached property reference from evolution-properties.json */
+interface PropertyDef {
+    name: string;
+    id?: string;
+    phases?: Record<string, string>;
+}
+/**
+ * Clear properties reference cache. Useful for testing.
+ */
+export declare function clearPropertiesCache(): void;
+/**
+ * Parse the LLM response from auto mode (all 12 properties evaluated at once).
+ *
+ * Expected format per line: PropertyName=PHASE|reason
+ *
+ * @param {string} text        - Raw LLM response
+ * @param {object[]} properties - Property reference for name matching
+ * @returns {Array<{property: string, phase: number, reason: string}>}
+ */
+export declare function parseAutoResponse(text: string, properties: PropertyDef[]): ParsedAutoResponse;
+/**
+ * Parse a single-property evaluation response.
+ *
+ * @param {string} text     - Raw LLM response
+ * @param {object} property - Property definition for name matching
+ * @returns {{ property: string, phase: number, reason: string }|null}
+ */
+export declare function parseSinglePropertyResponse(text: string, property: PropertyDef): ParsedPropertyEvaluation | null;
+/**
+ * Evaluates a named solution against the 12-property Wardley evolution
+ * phase reference, producing a weighted aggregation of per-property
+ * phase evaluations.
+ *
+ * @example
+ *   const strategy = new PropertiesStrategy({ llmCall: myLlmFn });
+ *   const result = await strategy.evaluate({ name: 'Kubernetes' });
+ *   // → { evolution: 0.62, confidence: 0.85, method: 'write:solution:properties', properties: [...] }
+ */
+export declare class PropertiesStrategy extends SolutionBaseStrategy {
+    _llmCall: any;
+    _mode: string;
+    constructor({ llmCall, mode }?: {
+        llmCall?: any;
+        mode?: string;
+    });
+    static get method(): string;
+    /**
+     * Evaluate a solution component against all 12 properties.
+     *
+     * In auto mode: single LLM call evaluating all properties at once.
+     * In conversational mode: one LLM call per property (slower but interactive).
+     *
+     * @param {import('./solution-base-strategy.mjs').SolutionInput} component
+     * @returns {Promise<import('./solution-base-strategy.mjs').SolutionEvolutionResult>}
+     */
+    evaluate(component: SolutionInput): Promise<SolutionEvolutionResult>;
+    /**
+     * Evaluate all 12 properties in a single LLM call (auto/oneshot mode).
+     *
+     * @param {string} solutionName
+     * @param {string} context
+     * @param {object[]} properties
+     * @returns {Promise<Array<{property: string, phase: number, reason: string}>>}
+     * @private
+     */
+    _evaluateAuto(solutionName: string, context: string, properties: PropertyDef[]): Promise<any>;
+    /**
+     * Evaluate properties one at a time (conversational mode).
+     *
+     * @param {string} solutionName
+     * @param {string} context
+     * @param {object[]} properties
+     * @returns {Promise<Array<{property: string, phase: number, reason: string}>>}
+     * @private
+     */
+    _evaluateConversational(solutionName: string, context: string, properties: PropertyDef[]): Promise<any>;
+    /**
+     * Evaluate a single property (for external conversational orchestration).
+     * This allows an orchestrator to call property-by-property evaluation
+     * from outside the strategy.
+     *
+     * @param {string} solutionName   - Solution name
+     * @param {string} context        - Business context
+     * @param {string} propertyName   - Name of the property to evaluate
+     * @returns {Promise<import('./solution-base-strategy.mjs').PropertyEvaluation|null>}
+     */
+    evaluateSingleProperty(solutionName: string, context: string, propertyName: string): Promise<any>;
+    /**
+     * Get the list of property names from the reference.
+     * Useful for conversational orchestration to know which properties to ask about.
+     *
+     * @returns {Promise<string[]>}
+     */
+    getPropertyNames(): Promise<string[]>;
+}
+import { BaseStrategy as CoreBaseStrategy, type StrategyResult } from '#core/ast/base-strategy.mjs';
+import type { RequestContext } from '#core/context/request-context.mjs';
+import type { LLMCall } from '#types/llm.mjs';
+export declare class PropertiesStrategyCore extends CoreBaseStrategy<SolutionInput, SolutionEvolutionResult> {
+    private readonly _llmCall;
+    private readonly _mode;
+    constructor(options?: {
+        llmCall?: LLMCall;
+        mode?: string;
+    });
+    static get method(): string;
+    evaluate(component: SolutionInput, _context: RequestContext): Promise<StrategyResult<SolutionEvolutionResult>>;
+}
+export {};
+//# sourceMappingURL=properties-strategy.d.mts.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/properties-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties-strategy.d.mts","sourceRoot":"","sources":["../../../../../../../../src/frameworks/wardley/evolution/_legacy/write/strategies/solution/properties-strategy.mts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AASnG,qFAAqF;AACrF,UAAU,WAAW;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;AAkCpF;;GAEG;AACH,wBAAgB,oBAAoB,SAEnC;AA0KD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,kBAAkB,CA+B7F;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,GAAG,wBAAwB,GAAG,IAAI,CAmChH;AA4CD;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,SAAQ,oBAAoB;IAE1D,QAAQ,EAAE,GAAG,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;gBAEF,EAAE,OAAO,EAAE,IAAa,EAAE,GAAE;QAAE,OAAO,CAAC,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO;IAS7E,MAAM,KAAK,MAAM,WAEhB;IAED;;;;;;;;OAQG;IACG,QAAQ,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAyE1E;;;;;;;;OAQG;IACG,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;IAMnG;;;;;;;;OAQG;IACG,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC;IAgB7G;;;;;;;;;OASG;IACG,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IA0BvG;;;;;OAKG;IACG,gBAAgB;CAIvB;AAUD,OAAO,EACL,YAAY,IAAI,gBAAgB,EAChC,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAK9C,qBAAa,sBAAuB,SAAQ,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,CAAC;IAClG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO;IAM9D,MAAM,KAAK,MAAM,IAAI,MAAM,CAE1B;IAEK,QAAQ,CACZ,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,cAAc,CAAC,uBAAuB,CAAC,CAAC;CAkCpD"}