labre-mcp 0.1.0

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/registry.mjs

@@ -0,0 +1,73 @@
+// Solution strategy registry: auto-discovers all solution strategy files.
+//
+// Adding a new solution evaluation strategy requires ONLY creating a new
+// file in src/strategies/solution/ that exports a class extending
+// SolutionBaseStrategy. No modifications to this file or any other
+// existing code are needed.
+//
+// Discovery rules:
+//   - Scans *-strategy.{mjs,mts} at runtime (mts in dev via tsx, mjs in dist)
+//   - Skips solution-base-strategy.* (the abstract interface)
+//   - Each file must export a class extending SolutionBaseStrategy
+//   - Strategies are keyed by their static `method` property
+//
+// This mirrors the capability registry in ../capacity/registry.mts.
+import { readdir } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join } from 'node:path';
+import { SolutionBaseStrategy } from './solution-base-strategy.mjs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let _cache = null;
+/**
+ * Discover and load all solution strategy classes from this directory.
+ * Results are cached after first call. Use `clearSolutionCache()` for testing.
+ */
+export async function loadSolutionStrategies() {
+    if (_cache)
+        return _cache;
+    const entries = await readdir(__dirname);
+    const strategyFiles = entries.filter(f => (f.endsWith('-strategy.mjs') || f.endsWith('-strategy.mts')) &&
+        f !== 'solution-base-strategy.mjs' &&
+        f !== 'solution-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 SolutionBaseStrategy &&
+                candidate !== SolutionBaseStrategy) {
+                const Cls = candidate;
+                const method = Cls.method;
+                if (strategies.has(method)) {
+                    throw new Error(`Duplicate solution strategy method "${method}" in ${file} — already registered`);
+                }
+                strategies.set(method, Cls);
+            }
+        }
+    }
+    _cache = strategies;
+    return strategies;
+}
+/** Get a single solution strategy by method name. */
+export async function getSolutionStrategy(method) {
+    const strategies = await loadSolutionStrategies();
+    const Cls = strategies.get(method);
+    if (!Cls) {
+        const available = [...strategies.keys()].join(', ');
+        throw new Error(`Unknown solution strategy "${method}". Available: ${available || '(none)'}`);
+    }
+    return Cls;
+}
+/** List all available solution strategy method names. */
+export async function listSolutionStrategies() {
+    const strategies = await loadSolutionStrategies();
+    return [...strategies.keys()];
+}
+/** Clear the solution strategy cache. Useful for testing dynamic registration. */
+export function clearSolutionCache() {
+    _cache = null;
+}
+//# sourceMappingURL=registry.mjs.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/registry.mjs.map

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

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

@@ -0,0 +1,163 @@
+import { BaseStrategy } from '../capacity/base-strategy.mjs';
+import type { SolutionInput, SolutionEvolutionResult, PropertyEvaluation } from '#types/solution.mjs';
+export type { SolutionInput, SolutionEvolutionResult, PropertyEvaluation };
+/**
+ * @typedef {Object} SolutionInput
+ * @property {'solution'} kind        - Discriminant literal
+ * @property {string}  name          - Solution / product name (e.g. "Kubernetes")
+ * @property {string}  [description] - Enrichable label / semantic hint for the solution
+ * @property {string}  [context]     - Business environment where the solution is used (distinct from description — never a fallback for it)
+ * @property {string|Date} [date]    - Optional date for temporal context
+ * @property {string}  [capability]  - Underlying capability if already identified
+ * @property {string}  [nature]      - Capability nature (activity|practice|knowledge|data|none)
+ * @property {Object}  [routing]     - { confidence, method } from the router when classification was performed
+ * @property {Object}  [metadata]    - Additional strategy-specific data
+ */
+/**
+ * @typedef {Object} PropertyEvaluation
+ * @property {string}  property  - Property name (e.g. "Market")
+ * @property {number}  phase     - Evaluated phase (1–4)
+ * @property {string}  label     - Phase label (Genesis|Custom|Product|Commodity)
+ * @property {number}  weight    - Weight used (default: 1/12)
+ * @property {string}  [reason]  - Optional reasoning for this property evaluation
+ */
+/**
+ * @typedef {Object} SolutionEvolutionResult
+ * @property {number}  evolution   - Weighted aggregated evolution position (0–1)
+ * @property {number}  confidence  - Confidence score (0–1)
+ * @property {string}  method      - Strategy identifier string
+ * @property {Array}   [trace]     - Trace of reasoning steps (strategy-specific)
+ * @property {PropertyEvaluation[]} [properties] - Per-property breakdown (solution-specific extension)
+ */
+/**
+ * Map a discrete phase (1–4) to a continuous evolution midpoint.
+ *
+ * Phase 1 (Genesis)   → midpoint 0.09
+ * Phase 2 (Custom)    → midpoint 0.29
+ * Phase 3 (Product)   → midpoint 0.55
+ * Phase 4 (Commodity) → midpoint 0.85
+ *
+ * These midpoints match the Wardley axis ranges:
+ *   Genesis [0, 0.18] | Custom [0.18, 0.40] | Product [0.40, 0.70] | Commodity [0.70, 1.0]
+ */
+declare const PHASE_TO_EVOLUTION: {
+    1: number;
+    2: number;
+    3: number;
+    4: number;
+};
+declare const PHASE_LABELS: {
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+/**
+ * Abstract base class for solution evolution evaluation strategies.
+ *
+ * Subclasses MUST override:
+ *   - evaluate(component) → EvolutionResult (or SolutionEvolutionResult)
+ *   - static get method() → string
+ *
+ * The base class provides:
+ *   - validateResult()     — same validation as BaseStrategy (contract compatibility)
+ *   - phaseToEvolution()   — convert discrete phase (1–4) to continuous evolution
+ *   - phaseLabel()         — human-readable phase label
+ *   - aggregateProperties() — weighted aggregation of per-property phase evaluations
+ *
+ * The EvolutionResult contract is enforced at runtime via validateResult()
+ * from the parent BaseStrategy, ensuring full interoperability with the
+ * existing capability evaluation pipeline.
+ */
+export declare class SolutionBaseStrategy extends BaseStrategy {
+    /**
+     * Strategy identifier. Must be overridden by each subclass.
+     * @returns {string}
+     */
+    static get method(): string;
+    /**
+     * Evaluate a solution component and return its evolution position.
+     * Must be overridden by every solution strategy.
+     *
+     * @param {SolutionInput} component - The solution to evaluate
+     * @returns {Promise<SolutionEvolutionResult>} Result conforming to EvolutionResult contract
+     */
+    evaluate(component: SolutionInput): Promise<SolutionEvolutionResult>;
+    /**
+     * Convert a discrete phase (1–4) to a continuous evolution value (0–1).
+     *
+     * @param {number} phase - Phase number (1 = Genesis, 2 = Custom, 3 = Product, 4 = Commodity)
+     * @returns {number} Evolution midpoint for the phase
+     * @throws {Error} If phase is not in [1, 4]
+     */
+    static phaseToEvolution(phase: number): number;
+    /**
+     * Get the human-readable label for a phase.
+     *
+     * @param {number} phase - Phase number (1–4)
+     * @returns {string} Label: 'Genesis' | 'Custom' | 'Product' | 'Commodity'
+     */
+    static phaseLabel(phase: number): string;
+    /**
+     * Aggregate per-property phase evaluations into a single evolution value.
+     *
+     * Each property contributes equally (weight = 1/N where N = number of
+     * properties).  Subclasses may override this to apply custom weighting
+     * or non-linear aggregation.
+     *
+     * Delegates to aggregate-properties.mjs for the core computation, which
+     * supports the CPC indicator toggling pattern (disable properties,
+     * custom weights, weight renormalization).
+     *
+     * @param {PropertyEvaluation[]} properties - Array of per-property evaluations
+     * @param {Object} [options={}] - Advanced aggregation options
+     * @param {string[]}  [options.disabled=[]]        - Property names/IDs to exclude
+     * @param {Record<string, number>} [options.customWeights={}] - Custom weight overrides
+     * @param {number}  [options.totalExpected=12]      - Expected total properties
+     * @returns {{ evolution: number, confidence: number }}
+     *   - evolution: weighted average of phase midpoints, rounded to 3 decimals
+     *   - confidence: coverage-based confidence (proportion of properties evaluated)
+     */
+    static aggregateProperties(properties: PropertyEvaluation[], options?: {
+        mode?: string;
+        method?: string;
+    }): {
+        evolution: number;
+        confidence: number;
+    };
+    /**
+     * Extended aggregation returning full metadata, weight map, and phase statistics.
+     *
+     * This is the advanced entry point for strategies that need detailed
+     * aggregation information (e.g. for tracing, debugging, or UI display).
+     *
+     * @param {PropertyEvaluation[]} properties - Array of per-property evaluations
+     * @param {Object} [options={}] - Same options as aggregateProperties
+     * @returns {import('./aggregate-properties.mjs').AggregationResult}
+     */
+    static aggregatePropertiesFull(properties: PropertyEvaluation[], options?: {
+        mode?: string;
+        method?: string;
+    }): any;
+    /**
+     * Build a PropertyEvaluation entry for a single property.
+     * Convenience factory for subclasses.
+     *
+     * @param {string} property - Property name (e.g. "Market")
+     * @param {number} phase    - Phase (1–4)
+     * @param {string} [reason] - Optional reasoning
+     * @returns {PropertyEvaluation}
+     */
+    static buildPropertyEvaluation(property: string, phase: number, reason?: string): PropertyEvaluation;
+    /**
+     * Validate and return a result conforming to the EvolutionResult contract.
+     * Delegates to BaseStrategy.validateResult() for contract compatibility,
+     * then optionally validates solution-specific extensions.
+     *
+     * @param {SolutionEvolutionResult} result
+     * @returns {SolutionEvolutionResult} the validated result (pass-through)
+     */
+    static validateSolutionResult(result: SolutionEvolutionResult): SolutionEvolutionResult;
+}
+export { PHASE_TO_EVOLUTION, PHASE_LABELS };
+//# sourceMappingURL=solution-base-strategy.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solution-base-strategy.d.mts","sourceRoot":"","sources":["../../../../../../../../src/frameworks/wardley/evolution/_legacy/write/strategies/solution/solution-base-strategy.mts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,kBAAkB,EAA4B,MAAM,qBAAqB,CAAC;AAChI,YAAY,EAAE,aAAa,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,CAAC;AAI3E;;;;;;;;;;;GAWG;AAEH;;;;;;;GAOG;AAEH;;;;;;;GAOG;AAIH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,kBAAkB;;;;;CAKvB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;CAKjB,CAAC;AAIF;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IAEpD;;;OAGG;IACH,MAAM,KAAK,MAAM,IAAI,MAAM,CAE1B;IAED;;;;;;OAMG;IACG,QAAQ,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAM1E;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAQ9C;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAKxC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,EAAE,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAKrJ;;;;;;;;;OASG;IAEH,MAAM,CAAC,uBAAuB,CAAC,UAAU,EAAE,kBAAkB,EAAE,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,GAAG;IAInH;;;;;;;;OAQG;IACH,MAAM,CAAC,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,kBAAkB;IAWpG;;;;;;;OAOG;IACH,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,uBAAuB,GAAG,uBAAuB;CAuBxF;AAID,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,CAAC"}

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/solution-base-strategy.mjs

@@ -0,0 +1,228 @@
+// Base strategy interface for solution-level Wardley Map evolution evaluation
+//
+// Solutions (e.g. Kubernetes, Salesforce, SAP ERP) are concrete products or
+// platforms that implement one or more capabilities.  Unlike capability
+// strategies — which evaluate the underlying activity/practice/knowledge/data —
+// solution strategies evaluate a named solution against a 12-property
+// phase reference (Market, Knowledge, Perception, etc.).
+//
+// Every solution evaluation strategy must extend SolutionBaseStrategy and
+// implement evaluate().  Adding a new strategy requires only creating one
+// file matching *-strategy.mjs in src/strategies/solution/ — no existing
+// code changes are needed.
+//
+// The returned EvolutionResult follows the SAME contract as capability
+// strategies so that consumers (MCP tool, orchestrator, formatters)
+// can treat both uniformly.
+//
+// EvolutionResult shape (identical to capability strategies):
+//   {
+//     evolution:   number,   // Evolution value, 0–1 (competitive axis)
+//     confidence:  number,   // Confidence score 0–1
+//     method:      string,   // Strategy identifier (e.g. 'write:solution:properties')
+//     trace:       array     // Trace of reasoning steps (optional)
+//   }
+import { BaseStrategy } from '../capacity/base-strategy.mjs';
+import { aggregatePropertyScores as _aggregatePropertyScores } from './aggregate-properties.mjs';
+// ─── Type Definitions ──────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} SolutionInput
+ * @property {'solution'} kind        - Discriminant literal
+ * @property {string}  name          - Solution / product name (e.g. "Kubernetes")
+ * @property {string}  [description] - Enrichable label / semantic hint for the solution
+ * @property {string}  [context]     - Business environment where the solution is used (distinct from description — never a fallback for it)
+ * @property {string|Date} [date]    - Optional date for temporal context
+ * @property {string}  [capability]  - Underlying capability if already identified
+ * @property {string}  [nature]      - Capability nature (activity|practice|knowledge|data|none)
+ * @property {Object}  [routing]     - { confidence, method } from the router when classification was performed
+ * @property {Object}  [metadata]    - Additional strategy-specific data
+ */
+/**
+ * @typedef {Object} PropertyEvaluation
+ * @property {string}  property  - Property name (e.g. "Market")
+ * @property {number}  phase     - Evaluated phase (1–4)
+ * @property {string}  label     - Phase label (Genesis|Custom|Product|Commodity)
+ * @property {number}  weight    - Weight used (default: 1/12)
+ * @property {string}  [reason]  - Optional reasoning for this property evaluation
+ */
+/**
+ * @typedef {Object} SolutionEvolutionResult
+ * @property {number}  evolution   - Weighted aggregated evolution position (0–1)
+ * @property {number}  confidence  - Confidence score (0–1)
+ * @property {string}  method      - Strategy identifier string
+ * @property {Array}   [trace]     - Trace of reasoning steps (strategy-specific)
+ * @property {PropertyEvaluation[]} [properties] - Per-property breakdown (solution-specific extension)
+ */
+// ─── Phase ↔ Evolution Mapping ─────────────────────────────────────────────────
+/**
+ * Map a discrete phase (1–4) to a continuous evolution midpoint.
+ *
+ * Phase 1 (Genesis)   → midpoint 0.09
+ * Phase 2 (Custom)    → midpoint 0.29
+ * Phase 3 (Product)   → midpoint 0.55
+ * Phase 4 (Commodity) → midpoint 0.85
+ *
+ * These midpoints match the Wardley axis ranges:
+ *   Genesis [0, 0.18] | Custom [0.18, 0.40] | Product [0.40, 0.70] | Commodity [0.70, 1.0]
+ */
+const PHASE_TO_EVOLUTION = {
+    1: 0.09,
+    2: 0.29,
+    3: 0.55,
+    4: 0.85,
+};
+const PHASE_LABELS = {
+    1: 'Genesis',
+    2: 'Custom',
+    3: 'Product',
+    4: 'Commodity',
+};
+// ─── SolutionBaseStrategy ──────────────────────────────────────────────────────
+/**
+ * Abstract base class for solution evolution evaluation strategies.
+ *
+ * Subclasses MUST override:
+ *   - evaluate(component) → EvolutionResult (or SolutionEvolutionResult)
+ *   - static get method() → string
+ *
+ * The base class provides:
+ *   - validateResult()     — same validation as BaseStrategy (contract compatibility)
+ *   - phaseToEvolution()   — convert discrete phase (1–4) to continuous evolution
+ *   - phaseLabel()         — human-readable phase label
+ *   - aggregateProperties() — weighted aggregation of per-property phase evaluations
+ *
+ * The EvolutionResult contract is enforced at runtime via validateResult()
+ * from the parent BaseStrategy, ensuring full interoperability with the
+ * existing capability evaluation pipeline.
+ */
+export class SolutionBaseStrategy extends BaseStrategy {
+    /**
+     * Strategy identifier. Must be overridden by each subclass.
+     * @returns {string}
+     */
+    static get method() {
+        throw new Error('SolutionBaseStrategy.method must be overridden by subclass');
+    }
+    /**
+     * Evaluate a solution component and return its evolution position.
+     * Must be overridden by every solution strategy.
+     *
+     * @param {SolutionInput} component - The solution to evaluate
+     * @returns {Promise<SolutionEvolutionResult>} Result conforming to EvolutionResult contract
+     */
+    async evaluate(component) {
+        throw new Error(`${this.constructor.name}.evaluate() must be implemented`);
+    }
+    // ─── Utility Methods for Subclasses ──────────────────────────────────────
+    /**
+     * Convert a discrete phase (1–4) to a continuous evolution value (0–1).
+     *
+     * @param {number} phase - Phase number (1 = Genesis, 2 = Custom, 3 = Product, 4 = Commodity)
+     * @returns {number} Evolution midpoint for the phase
+     * @throws {Error} If phase is not in [1, 4]
+     */
+    static phaseToEvolution(phase) {
+        const rounded = Math.round(phase);
+        if (rounded < 1 || rounded > 4) {
+            throw new RangeError(`Phase must be between 1 and 4, got ${phase}`);
+        }
+        return PHASE_TO_EVOLUTION[rounded];
+    }
+    /**
+     * Get the human-readable label for a phase.
+     *
+     * @param {number} phase - Phase number (1–4)
+     * @returns {string} Label: 'Genesis' | 'Custom' | 'Product' | 'Commodity'
+     */
+    static phaseLabel(phase) {
+        const rounded = Math.round(phase);
+        return PHASE_LABELS[rounded] || 'Unknown';
+    }
+    /**
+     * Aggregate per-property phase evaluations into a single evolution value.
+     *
+     * Each property contributes equally (weight = 1/N where N = number of
+     * properties).  Subclasses may override this to apply custom weighting
+     * or non-linear aggregation.
+     *
+     * Delegates to aggregate-properties.mjs for the core computation, which
+     * supports the CPC indicator toggling pattern (disable properties,
+     * custom weights, weight renormalization).
+     *
+     * @param {PropertyEvaluation[]} properties - Array of per-property evaluations
+     * @param {Object} [options={}] - Advanced aggregation options
+     * @param {string[]}  [options.disabled=[]]        - Property names/IDs to exclude
+     * @param {Record<string, number>} [options.customWeights={}] - Custom weight overrides
+     * @param {number}  [options.totalExpected=12]      - Expected total properties
+     * @returns {{ evolution: number, confidence: number }}
+     *   - evolution: weighted average of phase midpoints, rounded to 3 decimals
+     *   - confidence: coverage-based confidence (proportion of properties evaluated)
+     */
+    static aggregateProperties(properties, options) {
+        const result = _aggregatePropertyScores(properties, options);
+        return { evolution: result.evolution, confidence: result.confidence };
+    }
+    /**
+     * Extended aggregation returning full metadata, weight map, and phase statistics.
+     *
+     * This is the advanced entry point for strategies that need detailed
+     * aggregation information (e.g. for tracing, debugging, or UI display).
+     *
+     * @param {PropertyEvaluation[]} properties - Array of per-property evaluations
+     * @param {Object} [options={}] - Same options as aggregateProperties
+     * @returns {import('./aggregate-properties.mjs').AggregationResult}
+     */
+    // any: returns the rich aggregation bag from aggregatePropertyScores (not a SolutionEvolutionResult instance)
+    static aggregatePropertiesFull(properties, options) {
+        return _aggregatePropertyScores(properties, options);
+    }
+    /**
+     * Build a PropertyEvaluation entry for a single property.
+     * Convenience factory for subclasses.
+     *
+     * @param {string} property - Property name (e.g. "Market")
+     * @param {number} phase    - Phase (1–4)
+     * @param {string} [reason] - Optional reasoning
+     * @returns {PropertyEvaluation}
+     */
+    static buildPropertyEvaluation(property, phase, reason) {
+        const rounded = Math.round(Math.max(1, Math.min(4, phase)));
+        return {
+            property,
+            phase: rounded,
+            label: SolutionBaseStrategy.phaseLabel(rounded),
+            weight: 1 / 12, // Default: 12 properties with equal weight
+            ...(reason != null && { reason }),
+        };
+    }
+    /**
+     * Validate and return a result conforming to the EvolutionResult contract.
+     * Delegates to BaseStrategy.validateResult() for contract compatibility,
+     * then optionally validates solution-specific extensions.
+     *
+     * @param {SolutionEvolutionResult} result
+     * @returns {SolutionEvolutionResult} the validated result (pass-through)
+     */
+    static validateSolutionResult(result) {
+        // First: enforce the core EvolutionResult contract
+        BaseStrategy.validateResult(result);
+        // Then: validate solution-specific extensions if present
+        if (result.properties != null) {
+            if (!Array.isArray(result.properties)) {
+                throw new TypeError('SolutionEvolutionResult.properties must be an array');
+            }
+            for (const prop of result.properties) {
+                if (typeof prop.property !== 'string' || prop.property.length === 0) {
+                    throw new TypeError('Each property evaluation must have a non-empty property name');
+                }
+                if (typeof prop.phase !== 'number' || prop.phase < 1 || prop.phase > 4) {
+                    throw new TypeError(`Property "${prop.property}" phase must be 1–4, got ${prop.phase}`);
+                }
+            }
+        }
+        return result;
+    }
+}
+// ─── Re-export constants for consumer convenience ──────────────────────────
+export { PHASE_TO_EVOLUTION, PHASE_LABELS };
+//# sourceMappingURL=solution-base-strategy.mjs.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/solution/solution-base-strategy.mjs.map

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