@robotixai/calculator-engine 0.1.0

package/dist/monte-carlo.js

@@ -0,0 +1,178 @@
+/**
+ * Monte Carlo Simulation Engine
+ *
+ * Deterministic, seeded PRNG-based Monte Carlo runner for retirement projections.
+ * Generates randomized annual returns and delegates year-by-year calculation to
+ * a caller-provided projection function, keeping MC fully decoupled from the
+ * projection engine.
+ */
+// ---------------------------------------------------------------------------
+// SeededRNG — Deterministic PRNG (mulberry32)
+// ---------------------------------------------------------------------------
+export class SeededRNG {
+    constructor(seed = 42) {
+        this.state = seed;
+    }
+    /** Returns a uniform random number in [0, 1). Mulberry32 algorithm. */
+    next() {
+        this.state |= 0;
+        this.state = (this.state + 0x6d2b79f5) | 0;
+        let t = Math.imul(this.state ^ (this.state >>> 15), 1 | this.state);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    /** Returns a standard normal random variate via Box-Muller transform. */
+    gaussian() {
+        let u1 = this.next();
+        const u2 = this.next();
+        // CRITICAL GUARD: clamp u1 to [1e-10, 1) to prevent ln(0) = -Infinity
+        u1 = Math.max(u1, 1e-10);
+        const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+        return z0;
+    }
+}
+// ---------------------------------------------------------------------------
+// generateReturn — Single random annual return
+// ---------------------------------------------------------------------------
+export function generateReturn(rng, mean, stdev, distribution) {
+    const z = rng.gaussian();
+    if (distribution === 'log-normal') {
+        // Log-normal return generation per spec:
+        //   σ_ln = sqrt(ln(1 + (stdev / (1 + mean))²))
+        //   μ_ln = ln(1 + mean) - σ_ln² / 2
+        //   return exp(μ_ln + σ_ln * z) - 1
+        const ratio = stdev / (1 + mean);
+        const sigmaLn = Math.sqrt(Math.log(1 + ratio * ratio));
+        const muLn = Math.log(1 + mean) - (sigmaLn * sigmaLn) / 2;
+        return Math.exp(muLn + sigmaLn * z) - 1;
+    }
+    // Normal distribution
+    let result = mean + stdev * z;
+    // CRITICAL GUARD: clamp return to >= -1.0 (can't lose more than 100%)
+    if (result < -1.0) {
+        result = -1.0;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// extractPercentile — Safe percentile extraction
+// ---------------------------------------------------------------------------
+export function extractPercentile(sortedArray, p) {
+    if (sortedArray.length === 0)
+        return 0;
+    const index = Math.floor(p * sortedArray.length);
+    // Clamp index to valid range
+    return sortedArray[Math.min(index, sortedArray.length - 1)];
+}
+// ---------------------------------------------------------------------------
+// runMonteCarloSimulation — Main MC runner
+// ---------------------------------------------------------------------------
+export function runMonteCarloSimulation(scenario, projectionFn, options = {}) {
+    var _a, _b, _c;
+    const runs = (_a = options.runs) !== null && _a !== void 0 ? _a : 1000;
+    const seed = (_b = options.seed) !== null && _b !== void 0 ? _b : 42;
+    const budgetMs = (_c = options.budgetMs) !== null && _c !== void 0 ? _c : 50000;
+    // Validation: mc_runs must be 0 (disabled) or >= 100. Reject 1-99.
+    if (runs === 0) {
+        return {
+            probability_no_shortfall: 0,
+            median_terminal: 0,
+            p10_terminal: 0,
+            p90_terminal: 0,
+            fan_chart: [],
+            terminal_distribution: [],
+            runs_completed: 0,
+            truncated: false,
+        };
+    }
+    if (runs < 100 || runs > 10000) {
+        throw new Error(`mc_runs must be 0 (disabled) or between 100 and 10000. Got: ${runs}`);
+    }
+    const rng = new SeededRNG(seed);
+    const startTime = Date.now();
+    const numYears = scenario.end_age - scenario.current_age;
+    const mean = scenario.nominal_return_pct / 100;
+    const stdev = scenario.return_stdev_pct / 100;
+    const distribution = scenario.return_distribution;
+    // Storage for all runs
+    const terminalRealValues = [];
+    let noShortfallCount = 0;
+    let truncated = false;
+    let runsCompleted = 0;
+    // Balance paths: balancePaths[runIndex][yearIndex] = end_balance_real
+    // We store these to compute fan chart percentiles across runs per age.
+    const balancePaths = [];
+    for (let run = 0; run < runs; run++) {
+        // Budget guard: check wall clock after each batch of 100 runs
+        if (run > 0 && run % 100 === 0) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed > budgetMs) {
+                truncated = true;
+                break;
+            }
+        }
+        // Generate array of random annual returns (one per year)
+        const annualReturns = [];
+        for (let y = 0; y < numYears; y++) {
+            annualReturns.push(generateReturn(rng, mean, stdev, distribution));
+        }
+        // Run projectionFn with randomized returns
+        const { timeline, metrics } = projectionFn(scenario, annualReturns);
+        // Record terminal real value
+        terminalRealValues.push(metrics.terminal_real);
+        // Record shortfall status
+        if (metrics.first_shortfall_age === null) {
+            noShortfallCount++;
+        }
+        // Store full balance path (end_balance_real per year) for fan chart
+        const path = timeline.map((row) => row.end_balance_real);
+        balancePaths.push(path);
+        runsCompleted = run + 1;
+    }
+    // -----------------------------------------------------------------------
+    // Extract percentiles from terminal values
+    // -----------------------------------------------------------------------
+    const sortedTerminals = [...terminalRealValues].sort((a, b) => a - b);
+    const p10Terminal = extractPercentile(sortedTerminals, 0.10);
+    const p50Terminal = extractPercentile(sortedTerminals, 0.50);
+    const p90Terminal = extractPercentile(sortedTerminals, 0.90);
+    // -----------------------------------------------------------------------
+    // Build fan chart: for each age, extract percentiles across all runs
+    // -----------------------------------------------------------------------
+    const fanChart = [];
+    if (balancePaths.length > 0 && balancePaths[0].length > 0) {
+        const pathLength = balancePaths[0].length;
+        for (let yearIdx = 0; yearIdx < pathLength; yearIdx++) {
+            // Collect balances at this year across all completed runs
+            const balancesAtYear = [];
+            for (let r = 0; r < runsCompleted; r++) {
+                if (yearIdx < balancePaths[r].length) {
+                    balancesAtYear.push(balancePaths[r][yearIdx]);
+                }
+            }
+            balancesAtYear.sort((a, b) => a - b);
+            fanChart.push({
+                age: scenario.current_age + yearIdx + 1,
+                p10: extractPercentile(balancesAtYear, 0.10),
+                p25: extractPercentile(balancesAtYear, 0.25),
+                p50: extractPercentile(balancesAtYear, 0.50),
+                p75: extractPercentile(balancesAtYear, 0.75),
+                p90: extractPercentile(balancesAtYear, 0.90),
+            });
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Compute probability of no shortfall
+    // -----------------------------------------------------------------------
+    const probabilityNoShortfall = runsCompleted > 0 ? (noShortfallCount / runsCompleted) * 100 : 0;
+    return {
+        probability_no_shortfall: probabilityNoShortfall,
+        median_terminal: p50Terminal,
+        p10_terminal: p10Terminal,
+        p90_terminal: p90Terminal,
+        fan_chart: fanChart,
+        terminal_distribution: terminalRealValues,
+        runs_completed: runsCompleted,
+        truncated,
+    };
+}

package/dist/optimizer.d.ts

@@ -0,0 +1,40 @@
+import type { Scenario, Metrics } from './types';
+export interface OptimizerResult {
+    retirementAge: number;
+    terminalReal: number;
+    survived: boolean;
+    mcSuccessPct: number | null;
+}
+export interface OptimizerOutput {
+    results: OptimizerResult[];
+    earliestViableAge: number | null;
+    minContribution: number | null;
+}
+export interface OptimizerOptions {
+    /** MC success threshold percentage (default 90). */
+    mcThreshold?: number;
+}
+/**
+ * Finds the earliest viable retirement age by testing each candidate from
+ * current_age + 1 to end_age - 1.
+ *
+ * For each candidate:
+ *   - Runs a deterministic projection
+ *   - Checks terminal_real >= desired_estate AND no shortfall
+ *   - If mcFn provided: runs MC (capped at 300 runs externally) and checks
+ *     success >= mcThreshold
+ *
+ * Also binary-searches for the minimum contribution amount at the earliest
+ * viable age (within $1 tolerance).
+ *
+ * @param scenario     Base scenario
+ * @param projectionFn Deterministic projection function
+ * @param mcFn         Optional Monte Carlo function (should use 300 capped runs)
+ * @param options      Optional { mcThreshold } (default 90)
+ */
+export declare function findEarliestRetirementAge(scenario: Scenario, projectionFn: (s: Scenario) => {
+    metrics: Metrics;
+}, mcFn?: (s: Scenario) => {
+    probability_no_shortfall: number;
+}, options?: OptimizerOptions): OptimizerOutput;
+//# sourceMappingURL=optimizer.d.ts.map

package/dist/optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer.d.ts","sourceRoot":"","sources":["../src/optimizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAMjD,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA4GD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EACnD,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK;IAAE,wBAAwB,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,CAAC,EAAE,gBAAgB,GACzB,eAAe,CAkDjB"}

package/dist/optimizer.js

@@ -0,0 +1,134 @@
+/**
+ * Deep-clone a scenario.
+ */
+function cloneScenario(s) {
+    return JSON.parse(JSON.stringify(s));
+}
+/**
+ * Checks whether a given retirement age is viable for the scenario.
+ *
+ * Viable means:
+ *   1. Deterministic projection survives (no shortfall)
+ *   2. terminal_real >= desired_estate
+ *   3. If MC function provided: MC success >= threshold
+ */
+function isViable(scenario, retirementAge, projectionFn, mcFn, mcThreshold = 90) {
+    var _a;
+    const s = cloneScenario(scenario);
+    s.retirement_age = retirementAge;
+    const proj = projectionFn(s);
+    const terminalReal = proj.metrics.terminal_real;
+    const survived = proj.metrics.first_shortfall_age === null;
+    const meetsEstate = terminalReal >= ((_a = scenario.desired_estate) !== null && _a !== void 0 ? _a : 0);
+    let mcSuccessPct = null;
+    let mcPasses = true;
+    if (mcFn) {
+        const mcResult = mcFn(s);
+        mcSuccessPct = mcResult.probability_no_shortfall;
+        mcPasses = mcSuccessPct >= mcThreshold;
+    }
+    const viable = survived && meetsEstate && mcPasses;
+    return {
+        result: {
+            retirementAge,
+            terminalReal,
+            survived,
+            mcSuccessPct,
+        },
+        viable,
+    };
+}
+/**
+ * Binary search for the minimum contribution amount (within $1 tolerance)
+ * that makes a given retirement age viable.
+ *
+ * Returns the minimum contribution, or null if even the maximum doesn't work.
+ */
+function findMinContribution(scenario, retirementAge, projectionFn, mcFn, mcThreshold = 90) {
+    // Search between 0 and a reasonable upper bound.
+    // Use 10x the current contribution or $100,000/month as the ceiling.
+    const maxContrib = Math.max(scenario.contrib_amount * 10, 100000);
+    let lo = 0;
+    let hi = maxContrib;
+    // First check if even the max contribution works
+    const sMax = cloneScenario(scenario);
+    sMax.retirement_age = retirementAge;
+    sMax.contrib_amount = hi;
+    const maxCheck = isViable(sMax, retirementAge, projectionFn, mcFn, mcThreshold);
+    if (!maxCheck.viable) {
+        return null; // Even maximum contribution doesn't make it viable
+    }
+    // Check if zero contribution already works
+    const sMin = cloneScenario(scenario);
+    sMin.retirement_age = retirementAge;
+    sMin.contrib_amount = 0;
+    const minCheck = isViable(sMin, retirementAge, projectionFn, mcFn, mcThreshold);
+    if (minCheck.viable) {
+        return 0;
+    }
+    // Binary search within $1 tolerance
+    while (hi - lo > 1) {
+        const mid = Math.floor((lo + hi) / 2);
+        const s = cloneScenario(scenario);
+        s.retirement_age = retirementAge;
+        s.contrib_amount = mid;
+        const check = isViable(s, retirementAge, projectionFn, mcFn, mcThreshold);
+        if (check.viable) {
+            hi = mid;
+        }
+        else {
+            lo = mid;
+        }
+    }
+    return hi;
+}
+/**
+ * Finds the earliest viable retirement age by testing each candidate from
+ * current_age + 1 to end_age - 1.
+ *
+ * For each candidate:
+ *   - Runs a deterministic projection
+ *   - Checks terminal_real >= desired_estate AND no shortfall
+ *   - If mcFn provided: runs MC (capped at 300 runs externally) and checks
+ *     success >= mcThreshold
+ *
+ * Also binary-searches for the minimum contribution amount at the earliest
+ * viable age (within $1 tolerance).
+ *
+ * @param scenario     Base scenario
+ * @param projectionFn Deterministic projection function
+ * @param mcFn         Optional Monte Carlo function (should use 300 capped runs)
+ * @param options      Optional { mcThreshold } (default 90)
+ */
+export function findEarliestRetirementAge(scenario, projectionFn, mcFn, options) {
+    var _a;
+    const mcThreshold = (_a = options === null || options === void 0 ? void 0 : options.mcThreshold) !== null && _a !== void 0 ? _a : 90;
+    const results = [];
+    let earliestViableAge = null;
+    const startAge = scenario.current_age + 1;
+    const endAge = scenario.end_age - 1;
+    // Budget guard: track wall-clock time (50s limit per CONTRACT-005)
+    const startTime = Date.now();
+    const BUDGET_MS = 50000;
+    for (let age = startAge; age <= endAge; age++) {
+        // Budget guard: abort if we've exceeded 50 seconds
+        if (Date.now() - startTime > BUDGET_MS) {
+            break;
+        }
+        const { result, viable } = isViable(scenario, age, projectionFn, mcFn, mcThreshold);
+        results.push(result);
+        if (viable && earliestViableAge === null) {
+            earliestViableAge = age;
+        }
+    }
+    // Find minimum contribution for earliest viable age
+    let minContribution = null;
+    if (earliestViableAge !== null) {
+        minContribution = findMinContribution(scenario, earliestViableAge, projectionFn, mcFn, mcThreshold);
+    }
+    return {
+        results,
+        earliestViableAge,
+        minContribution,
+    };
+}

package/dist/portfolio.d.ts

@@ -0,0 +1,43 @@
+import type { Asset, FinancialItem } from './types';
+export interface BlendedPortfolio {
+    totalValue: number;
+    blendedReturn: number;
+    blendedFee: number;
+    blendedPerfFee: number;
+    liquidPct: number;
+}
+/**
+ * Computes weighted-average return, fee, perf-fee, and liquid percentage
+ * across a set of basic-mode assets.
+ *
+ * Only enabled assets are included.  If total value is 0 (or no enabled
+ * assets), returns zeroed-out values.
+ *
+ * Formulas (from spec section 14):
+ *   total         = sum of enabled asset values
+ *   blended_return = sum(asset.current_value * asset.rate_pct) / total
+ *   blended_fee    = sum(asset.current_value * asset.fee_pct) / total   (if fee exists)
+ *   blended_perf_fee = sum(asset.current_value * asset.perf_fee_pct) / total (if exists)
+ *   liquid_pct     = sum(liquid asset values) / total * 100
+ *
+ * Note: Asset schema may not carry fee_pct / perf_fee_pct — those fields are
+ * optional on the Asset type.  When absent they default to 0.
+ */
+export declare function blendPortfolio(assets: Asset[]): BlendedPortfolio;
+/**
+ * Computes the estate value at the end of a projection.
+ *
+ * From spec section 14:
+ *   estate = endBalanceNominal - endDebtNominal
+ *          + sum( item.current_value * (1 + rate)^years * estate_pct/100 )
+ *
+ * Only enabled financial items with estate_pct > 0 contribute additional
+ * estate value beyond the main portfolio balance.
+ *
+ * @param endBalanceNominal  Nominal portfolio balance at projection end
+ * @param endDebtNominal     Total outstanding loan/debt balances at projection end
+ * @param financialItems     Advanced-mode financial items (for estate earmarks)
+ * @param yearsHeld          Number of years from start to end of projection
+ */
+export declare function calculateEstateValue(endBalanceNominal: number, endDebtNominal: number, financialItems: FinancialItem[], yearsHeld: number): number;
+//# sourceMappingURL=portfolio.d.ts.map

package/dist/portfolio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portfolio.d.ts","sourceRoot":"","sources":["../src/portfolio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAMpD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,gBAAgB,CAsDhE;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,aAAa,EAAE,EAC/B,SAAS,EAAE,MAAM,GAChB,MAAM,CAcR"}

package/dist/portfolio.js

@@ -0,0 +1,86 @@
+/**
+ * Computes weighted-average return, fee, perf-fee, and liquid percentage
+ * across a set of basic-mode assets.
+ *
+ * Only enabled assets are included.  If total value is 0 (or no enabled
+ * assets), returns zeroed-out values.
+ *
+ * Formulas (from spec section 14):
+ *   total         = sum of enabled asset values
+ *   blended_return = sum(asset.current_value * asset.rate_pct) / total
+ *   blended_fee    = sum(asset.current_value * asset.fee_pct) / total   (if fee exists)
+ *   blended_perf_fee = sum(asset.current_value * asset.perf_fee_pct) / total (if exists)
+ *   liquid_pct     = sum(liquid asset values) / total * 100
+ *
+ * Note: Asset schema may not carry fee_pct / perf_fee_pct — those fields are
+ * optional on the Asset type.  When absent they default to 0.
+ */
+export function blendPortfolio(assets) {
+    const enabled = assets.filter((a) => a.enabled !== false);
+    if (enabled.length === 0) {
+        return {
+            totalValue: 0,
+            blendedReturn: 0,
+            blendedFee: 0,
+            blendedPerfFee: 0,
+            liquidPct: 0,
+        };
+    }
+    const totalValue = enabled.reduce((sum, a) => sum + a.current_value, 0);
+    if (totalValue === 0) {
+        return {
+            totalValue: 0,
+            blendedReturn: 0,
+            blendedFee: 0,
+            blendedPerfFee: 0,
+            liquidPct: 0,
+        };
+    }
+    const blendedReturn = enabled.reduce((sum, a) => sum + a.current_value * a.rate_pct, 0) / totalValue;
+    // Asset schema doesn't always include fee fields; coalesce to 0
+    const blendedFee = enabled.reduce((sum, a) => { var _a; return sum + a.current_value * ((_a = a.fee_pct) !== null && _a !== void 0 ? _a : 0); }, 0) / totalValue;
+    const blendedPerfFee = enabled.reduce((sum, a) => { var _a; return sum + a.current_value * ((_a = a.perf_fee_pct) !== null && _a !== void 0 ? _a : 0); }, 0) / totalValue;
+    const liquidTotal = enabled
+        .filter((a) => a.is_liquid)
+        .reduce((sum, a) => sum + a.current_value, 0);
+    const liquidPct = (liquidTotal / totalValue) * 100;
+    return {
+        totalValue,
+        blendedReturn,
+        blendedFee,
+        blendedPerfFee,
+        liquidPct,
+    };
+}
+// ---------------------------------------------------------------------------
+// Estate Value Calculation
+// ---------------------------------------------------------------------------
+/**
+ * Computes the estate value at the end of a projection.
+ *
+ * From spec section 14:
+ *   estate = endBalanceNominal - endDebtNominal
+ *          + sum( item.current_value * (1 + rate)^years * estate_pct/100 )
+ *
+ * Only enabled financial items with estate_pct > 0 contribute additional
+ * estate value beyond the main portfolio balance.
+ *
+ * @param endBalanceNominal  Nominal portfolio balance at projection end
+ * @param endDebtNominal     Total outstanding loan/debt balances at projection end
+ * @param financialItems     Advanced-mode financial items (for estate earmarks)
+ * @param yearsHeld          Number of years from start to end of projection
+ */
+export function calculateEstateValue(endBalanceNominal, endDebtNominal, financialItems, yearsHeld) {
+    let estate = endBalanceNominal - endDebtNominal;
+    for (const item of financialItems) {
+        // Skip disabled items and those with no estate earmark
+        if (!item.enabled)
+            continue;
+        if (item.estate_pct <= 0)
+            continue;
+        const rate = item.rate_pct / 100;
+        const projectedValue = item.current_value * Math.pow(1 + rate, yearsHeld);
+        estate += projectedValue * (item.estate_pct / 100);
+    }
+    return estate;
+}

package/dist/projection.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deterministic Year-by-Year Projection Engine (Basic Mode)
+ *
+ * Computes a full retirement projection from current_age to end_age,
+ * producing a TimelineRow per year and aggregate Metrics.
+ *
+ * The `overrideReturns` parameter allows Monte Carlo to inject randomized
+ * annual returns — when provided, overrideReturns[yearIndex] is used
+ * instead of nominal_return_pct / 100.
+ */
+import type { Scenario, TimelineRow, Metrics } from './types';
+export declare function runProjection(scenario: Scenario, overrideReturns?: number[]): {
+    timeline: TimelineRow[];
+    metrics: Metrics;
+};
+//# sourceMappingURL=projection.d.ts.map

package/dist/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAgB,MAAM,SAAS,CAAC;AAoE5E,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,QAAQ,EAClB,eAAe,CAAC,EAAE,MAAM,EAAE,GACzB;IAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA2a/C"}