@calculator53295/backtest-engine 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 finance-kit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+# @calculator53295/backtest-engine
+
+A **pure-TypeScript, zero-runtime-dependency** engine for portfolio backtesting and
+retirement simulation. Everything ships as plain functions over plain data — no
+network, no filesystem, no globals — so the same inputs produce the same numbers
+in a browser, a worker, or Node.
+
+Three surfaces in one package:
+
+- **Daily backtest engine** — `runBacktest` walks a portfolio over the
+  intersection of its tickers' trading days, handling dividends (reinvested or
+  accrued as cash), splits, monthly contributions, and rebalancing. It reports a
+  time-weighted-return index (flows stripped out), a money-weighted **IRR**, plus
+  drawdown, volatility, annual/monthly/rolling returns, and per-holding
+  breakdowns. A two-asset efficient-frontier helper (`twoAssetFrontier`,
+  `minVarianceIndex`, `maxSharpeIndex`) rounds it out.
+- **Monte Carlo retirement simulator** — `runHistoricalSequence`,
+  `runBootstrap`, and `maxSafeWithdrawal` run withdrawal plans over historical
+  or block-bootstrapped real-return sequences and summarize success rate, balance
+  and income percentiles, and pay-cut risk. Everything is in **real
+  (inflation-adjusted)** dollars.
+- **Historical cohort retirement engine** (`retirement.*`) — a bucketed
+  stocks/bonds/cash simulator with glide paths, income and extra-withdrawal
+  streams, fees, and a **registry of nine withdrawal strategies** (constant
+  dollar, percent-of-portfolio, 1/N, VPW, Guyton-Klinger, CAPE-based, 95%-rule,
+  endowment, Vanguard dynamic — plus legacy adapters). `runAllCohorts` sweeps
+  every historical start date; `solveSwr` back-solves the safe withdrawal rate.
+
+A namespaced **canonical** module (`canonical.*`) provides a forward-compatible
+type vocabulary and pure adapters that reconcile the two engine dialects lifted
+into this repo, so consumers can share one vocabulary as the surfaces converge.
+
+## How this engine is tested
+
+This package exists to be trusted by three production apps, so its behavior is
+pinned by tests at three levels — hand-computed synthetic fixtures for exact
+correctness, real-market regression bands for realism, and a golden parity
+fixture that locks results to the app the code was extracted from. The engine
+itself carries **no personal financial data**: only synthetic tuples and public
+market/Shiller data are used as fixtures.
+
+| Fixture class | What it pins | Concrete examples (from the test suite) |
+| --- | --- | --- |
+| **Hand-computed synthetic fixtures** | Exact arithmetic of the daily engine — every value is derived by hand in the test, no tolerance beyond float epsilon. | A flat/linear price path `100 → 110 → 99` on a single asset must yield portfolio values `10 000 → 11 000 → 9 900` and `totalReturn = −0.01` (`engine/__tests__/backtest.test.ts`). A `$2` dividend where unadjusted close drops `100 → 99` yields `10 100` reinvested and `10 100` with `$200` accrued cash when not. A 2:1 split (`100 → 51`, real `+2%`) must neutralize to `10 200`. Two-asset 60/40 monthly rebalancing lands on `11 024`; TWR strips a `$1 000` monthly contribution so the index matches the no-contribution run exactly. |
+| **Real-data regression bands** | The engine reproduces known market history within approximate ranges (vendor adjustment methods differ slightly). Runs against gitignored Tiingo data; auto-skips when absent. | SPY 1994–2023 CAGR ∈ (9%, 11%); GFC max drawdown ∈ (−58%, −50%) troughing in **2009-03** with a non-null recovery; 2008 annual return ∈ (−40%, −34%) (`≈ −37%`); AAPL 2020 **4:1 split** continuity — no daily move outside (0.85×, 1.15×); a 60/40 SPY/BND mix shows lower volatility and shallower drawdown than pure SPY and clamps its range to BND's 2007 inception (`engine/__tests__/realdata.test.ts`). |
+| **Golden Shiller cohort parity** | The retirement cohort engine matches the app it was ported from, bit-for-bit. | The first 48 rows of retirement-sim's public `shiller.csv` (1871-01…1874-12) run through `runAllCohorts` must reproduce captured summary quantiles (real and nominal end balances) to 10 decimal places, with `count = 3`, `successRate = 1`, start dates `1871/1872/1873-01`, worst cohort `1872-01`, best `1871-01`, and every year-1 real withdrawal `≈ $4 000` (`retirement/__tests__/golden-cohort.test.ts`). |
+
+## Consumers
+
+One engine, three production apps by the same author — extracting the shared math
+here means simulation results are identical everywhere the same inputs appear,
+with no per-app drift:
+
+- **retirement-sim** — the cohort retirement engine and withdrawal-strategy
+  registry were ported from it.
+- **Fathom** stock-analysis suite — the daily backtest and Monte Carlo engines
+  were lifted verbatim from its fixture-guarded `src/engine` + `src/montecarlo`.
+- **finance-master** — shares the same engine.
+
+## Quickstart
+
+### Daily backtest — `runBacktest`
+
+```ts
+import { runBacktest } from "@calculator53295/backtest-engine";
+
+const spy /* : TickerSeries */ = {
+  ticker: "SPY",
+  records: [
+    { date: "2020-01-02", close: 100, adjClose: 100, divCash: 0, splitFactor: 1 },
+    { date: "2020-01-03", close: 110, adjClose: 110, divCash: 0, splitFactor: 1 },
+    { date: "2020-01-06", close: 99, adjClose: 99, divCash: 0, splitFactor: 1 },
+  ],
+};
+
+const result = runBacktest(
+  [spy],
+  { name: "All SPY", allocations: [{ ticker: "SPY", weight: 100 }] },
+  { initialAmount: 10_000, monthlyContribution: 0, rebalance: "none", reinvestDividends: true },
+);
+
+result.values;         // portfolio value per trading day
+result.metrics.cagr;   // + totalReturn, irr, volatility, drawdown, annualReturns…
+result.twrIndex;       // flow-stripped time-weighted-return index
+```
+
+### Retirement Monte Carlo — `runHistoricalSequence` / `maxSafeWithdrawal`
+
+```ts
+import {
+  runHistoricalSequence,
+  maxSafeWithdrawal,
+  type RealReturnSeries,
+  type SimParams,
+} from "@calculator53295/backtest-engine";
+
+// Real (inflation-adjusted) monthly total returns, oldest first.
+const series: RealReturnSeries = { dates: ["1994-01", /* … */], returns: [0.003, /* … */] };
+
+const params: Omit<SimParams, "withdrawalRate"> = {
+  initialBalance: 1_000_000,
+  strategy: "fixedReal",   // or "fixedPercent" | "vpw" | "guardrails"
+  horizonYears: 30,
+  feeRate: 0.001,
+};
+
+const sim = runHistoricalSequence(series, { ...params, withdrawalRate: 0.04 });
+sim.successRate;              // fraction of historical cohorts that survived
+sim.percentiles.p50;          // median balance path, today's dollars
+
+// Or back-solve the highest rate meeting a 95% success target:
+const swr = maxSafeWithdrawal(series, params, 0.95);
+```
+
+### Historical cohort engine — `retirement.simulate`
+
+```ts
+import { retirement } from "@calculator53295/backtest-engine";
+// or: import { simulate, runAllCohorts } from "@calculator53295/backtest-engine/retirement";
+
+// [date, spReturn, bondReturn, cashReturn, cpi] → HistoricalRow[]
+const rows: retirement.HistoricalRow[] = [
+  { date: "1871-01", spReturn: 0.0184, bondReturn: 0.0042, cashReturn: 0.0011, cpi: 12.4641 },
+  // …monthly public Shiller / asset-class rows…
+];
+
+const trial = retirement.simulate(
+  {
+    startDate: "1871-01",
+    horizonYears: 30,
+    stepFreq: "monthly",
+    initialBalance: 100_000,
+    initialAllocation: { stocks: 0.6, bonds: 0.3, cash: 0.1 },
+    strategy: { kind: "constant-dollar", annualAmount: 40_000, inflationAdjusted: true, sourcing: "proportional" },
+    rebalance: "yearly",
+  },
+  rows,
+);
+
+trial.endBalanceReal;           // ending balance, today's dollars
+trial.ranOutAtPeriod;           // null if the plan survived
+
+// Sweep every start date in the dataset:
+const { summary } = retirement.runAllCohorts({ /* config without startDate */ }, rows);
+summary.successRate;
+```
+
+The cohort engine takes an injectable random source (`RandomSource`) for its
+sampling helpers (e.g. `pickRandomStart`), so simulations stay deterministic and
+testable — pass a seeded RNG like the exported `mulberry32`.
+
+## API stability
+
+This package is **0.x**: minor releases may include breaking changes to the two
+flat engine dialects while the surfaces converge. The **`canonical`** module is
+the forward-compatible vocabulary — prefer it for long-lived integrations. The
+exported `VERSION` constant tracks the package version.
+
+## License
+
+MIT

package/dist/canonical/allocation.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Canonical allocation vocabulary.
+ *
+ * The two engine dialects disagree on how a portfolio mix is spelled:
+ *  - Fathom  (`src/engine/types.ts`): `Allocation[]` of `{ ticker, weight }`
+ *    where `weight` is a PERCENT and the weights sum to 100.
+ *  - retirement-sim (`staging/retirement-sim/types.ts`): `Buckets` of
+ *    `{ stocks, bonds, cash }` FRACTIONS that sum to 1.0.
+ *
+ * Canonical decision: allocations are a list of named sleeves whose
+ * `fraction` values are in 0..1 and sum to 1.0. Fractions are the honest
+ * unit — they compose (a 60/40 of a 50/50 is just multiplication) and never
+ * leave you guessing whether "40" meant 40% or 0.40. `assertAllocationSum`
+ * enforces the invariant at the boundary; the adapters below translate to and
+ * from each dialect without ever assuming the invariant silently.
+ */
+import type { PortfolioSpec } from '../engine/types.js';
+/** One named sleeve of a portfolio, as a fraction of the whole (0..1). */
+export interface AllocationSleeve {
+    /** Sleeve identifier — a ticker ('SPY') or asset-class key ('stocks'). */
+    id: string;
+    /** Target weight as a fraction in 0..1. */
+    fraction: number;
+}
+/** Canonical allocation: sleeves whose fractions sum to 1.0. */
+export type CanonicalAllocation = AllocationSleeve[];
+/** retirement-sim's three-bucket allocation (fractions summing to 1.0). */
+export interface Buckets {
+    stocks: number;
+    bonds: number;
+    cash: number;
+}
+/** The three canonical bucket ids, in a stable order. */
+export declare const BUCKET_IDS: readonly ["stocks", "bonds", "cash"];
+export type BucketId = (typeof BUCKET_IDS)[number];
+/** Default tolerance for the sum-to-one check (accommodates float drift). */
+export declare const ALLOCATION_SUM_TOLERANCE = 0.000001;
+/**
+ * Throw unless `alloc` is a valid canonical allocation: every fraction is a
+ * finite number in [0, 1] and the fractions sum to 1.0 within `tolerance`.
+ */
+export declare function assertAllocationSum(alloc: CanonicalAllocation, tolerance?: number): void;
+/**
+ * Fathom spec → canonical. Percent weights become fractions (÷100). Does NOT
+ * assert the sum — callers validate with `assertAllocationSum` if they need
+ * the invariant (a spec might legitimately be under construction).
+ */
+export declare function fromFathomSpec(spec: PortfolioSpec): CanonicalAllocation;
+/**
+ * Canonical → Fathom spec. Fractions become percent weights (×100). `name`
+ * is required because a `PortfolioSpec` carries one and the canonical form
+ * does not.
+ */
+export declare function toFathomSpec(alloc: CanonicalAllocation, name: string): PortfolioSpec;
+/** retirement-sim buckets → canonical (always emits all three sleeves). */
+export declare function fromBuckets(buckets: Buckets): CanonicalAllocation;
+/**
+ * Canonical → retirement-sim buckets. Every sleeve id must be one of
+ * 'stocks' | 'bonds' | 'cash'; an unrecognized id throws rather than being
+ * silently dropped (a lossy mapping must never guess). Missing buckets
+ * default to 0. Repeated ids accumulate.
+ */
+export declare function toBuckets(alloc: CanonicalAllocation): Buckets;
+//# sourceMappingURL=allocation.d.ts.map

package/dist/canonical/allocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocation.d.ts","sourceRoot":"","sources":["../../src/canonical/allocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAkC,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvF,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,EAAE,EAAE,MAAM,CAAA;IACV,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,gEAAgE;AAChE,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,EAAE,CAAA;AAEpD,2EAA2E;AAC3E,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAED,yDAAyD;AACzD,eAAO,MAAM,UAAU,sCAAuC,CAAA;AAC9D,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAElD,6EAA6E;AAC7E,eAAO,MAAM,wBAAwB,WAAO,CAAA;AAE5C;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,mBAAmB,EAC1B,SAAS,GAAE,MAAiC,GAC3C,IAAI,CAgBN;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,mBAAmB,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAMpF;AAID,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAMjE;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAe7D"}

package/dist/canonical/allocation.js

@@ -0,0 +1,91 @@
+/**
+ * Canonical allocation vocabulary.
+ *
+ * The two engine dialects disagree on how a portfolio mix is spelled:
+ *  - Fathom  (`src/engine/types.ts`): `Allocation[]` of `{ ticker, weight }`
+ *    where `weight` is a PERCENT and the weights sum to 100.
+ *  - retirement-sim (`staging/retirement-sim/types.ts`): `Buckets` of
+ *    `{ stocks, bonds, cash }` FRACTIONS that sum to 1.0.
+ *
+ * Canonical decision: allocations are a list of named sleeves whose
+ * `fraction` values are in 0..1 and sum to 1.0. Fractions are the honest
+ * unit — they compose (a 60/40 of a 50/50 is just multiplication) and never
+ * leave you guessing whether "40" meant 40% or 0.40. `assertAllocationSum`
+ * enforces the invariant at the boundary; the adapters below translate to and
+ * from each dialect without ever assuming the invariant silently.
+ */
+/** The three canonical bucket ids, in a stable order. */
+export const BUCKET_IDS = ['stocks', 'bonds', 'cash'];
+/** Default tolerance for the sum-to-one check (accommodates float drift). */
+export const ALLOCATION_SUM_TOLERANCE = 1e-6;
+/**
+ * Throw unless `alloc` is a valid canonical allocation: every fraction is a
+ * finite number in [0, 1] and the fractions sum to 1.0 within `tolerance`.
+ */
+export function assertAllocationSum(alloc, tolerance = ALLOCATION_SUM_TOLERANCE) {
+    let sum = 0;
+    for (const sleeve of alloc) {
+        if (!Number.isFinite(sleeve.fraction)) {
+            throw new Error(`Allocation sleeve '${sleeve.id}' has a non-finite fraction`);
+        }
+        if (sleeve.fraction < 0 || sleeve.fraction > 1) {
+            throw new Error(`Allocation sleeve '${sleeve.id}' fraction ${sleeve.fraction} is outside [0, 1]`);
+        }
+        sum += sleeve.fraction;
+    }
+    if (Math.abs(sum - 1) > tolerance) {
+        throw new Error(`Allocation fractions sum to ${sum}, expected 1.0 (±${tolerance})`);
+    }
+}
+// ---- Fathom PortfolioSpec <-> canonical -------------------------------------
+/**
+ * Fathom spec → canonical. Percent weights become fractions (÷100). Does NOT
+ * assert the sum — callers validate with `assertAllocationSum` if they need
+ * the invariant (a spec might legitimately be under construction).
+ */
+export function fromFathomSpec(spec) {
+    return spec.allocations.map((a) => ({ id: a.ticker, fraction: a.weight / 100 }));
+}
+/**
+ * Canonical → Fathom spec. Fractions become percent weights (×100). `name`
+ * is required because a `PortfolioSpec` carries one and the canonical form
+ * does not.
+ */
+export function toFathomSpec(alloc, name) {
+    const allocations = alloc.map((s) => ({
+        ticker: s.id,
+        weight: s.fraction * 100,
+    }));
+    return { name, allocations };
+}
+// ---- retirement-sim Buckets <-> canonical -----------------------------------
+/** retirement-sim buckets → canonical (always emits all three sleeves). */
+export function fromBuckets(buckets) {
+    return [
+        { id: 'stocks', fraction: buckets.stocks },
+        { id: 'bonds', fraction: buckets.bonds },
+        { id: 'cash', fraction: buckets.cash },
+    ];
+}
+/**
+ * Canonical → retirement-sim buckets. Every sleeve id must be one of
+ * 'stocks' | 'bonds' | 'cash'; an unrecognized id throws rather than being
+ * silently dropped (a lossy mapping must never guess). Missing buckets
+ * default to 0. Repeated ids accumulate.
+ */
+export function toBuckets(alloc) {
+    const out = { stocks: 0, bonds: 0, cash: 0 };
+    for (const sleeve of alloc) {
+        const id = sleeve.id;
+        // Positive narrowing (id === literal) refines `string` to the bucket union,
+        // which negative narrowing would not — so `out[id]` type-checks cleanly.
+        if (id === 'stocks' || id === 'bonds' || id === 'cash') {
+            out[id] += sleeve.fraction;
+        }
+        else {
+            throw new Error(`Cannot map sleeve '${id}' to a bucket; expected one of ${BUCKET_IDS.join(', ')}`);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=allocation.js.map

package/dist/canonical/allocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocation.js","sourceRoot":"","sources":["../../src/canonical/allocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAsBH,yDAAyD;AACzD,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAU,CAAA;AAG9D,6EAA6E;AAC7E,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAA;AAE5C;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAA0B,EAC1B,YAAoB,wBAAwB;IAE5C,IAAI,GAAG,GAAG,CAAC,CAAA;IACX,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,sBAAsB,MAAM,CAAC,EAAE,6BAA6B,CAAC,CAAA;QAC/E,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,GAAG,CAAC,IAAI,MAAM,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;YAC/C,MAAM,IAAI,KAAK,CACb,sBAAsB,MAAM,CAAC,EAAE,cAAc,MAAM,CAAC,QAAQ,oBAAoB,CACjF,CAAA;QACH,CAAC;QACD,GAAG,IAAI,MAAM,CAAC,QAAQ,CAAA;IACxB,CAAC;IACD,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,+BAA+B,GAAG,oBAAoB,SAAS,GAAG,CAAC,CAAA;IACrF,CAAC;AACH,CAAC;AAED,gFAAgF;AAEhF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAAmB;IAChD,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAA;AAClF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAA0B,EAAE,IAAY;IACnE,MAAM,WAAW,GAAuB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACxD,MAAM,EAAE,CAAC,CAAC,EAAE;QACZ,MAAM,EAAE,CAAC,CAAC,QAAQ,GAAG,GAAG;KACzB,CAAC,CAAC,CAAA;IACH,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAA;AAC9B,CAAC;AAED,gFAAgF;AAEhF,2EAA2E;AAC3E,MAAM,UAAU,WAAW,CAAC,OAAgB;IAC1C,OAAO;QACL,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,MAAM,EAAE;QAC1C,EAAE,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,KAAK,EAAE;QACxC,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE;KACvC,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,KAA0B;IAClD,MAAM,GAAG,GAAY,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAA;IACrD,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,CAAA;QACpB,4EAA4E;QAC5E,yEAAyE;QACzE,IAAI,EAAE,KAAK,QAAQ,IAAI,EAAE,KAAK,OAAO,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;YACvD,GAAG,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAA;QAC5B,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CACb,sBAAsB,EAAE,kCAAkC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAClF,CAAA;QACH,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/canonical/dates.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Canonical date-granularity helpers.
+ *
+ * Fathom works in daily 'yyyy-mm-dd' keys (`DailyRecord.date`); retirement-sim
+ * and the Monte Carlo `RealReturnSeries` work in monthly 'YYYY-MM' keys. The
+ * two are easy to confuse because both are dash-delimited strings. Branded
+ * types make the granularity part of the static type, so a `DayKey` can never
+ * be passed where a `MonthKey` is wanted (or vice-versa) without an explicit,
+ * validating conversion.
+ */
+/** A calendar month, 'YYYY-MM'. Construct via `parseMonthKey`/`formatMonthKey`. */
+export type MonthKey = string & {
+    readonly __brand: 'MonthKey';
+};
+/** A calendar day, 'YYYY-MM-DD'. Construct via `parseDayKey`/`formatDayKey`. */
+export type DayKey = string & {
+    readonly __brand: 'DayKey';
+};
+/** Type guard: is `s` a well-formed 'YYYY-MM' month key? */
+export declare function isMonthKey(s: string): s is MonthKey;
+/** Type guard: is `s` a well-formed 'YYYY-MM-DD' day key? */
+export declare function isDayKey(s: string): s is DayKey;
+/** Parse a 'YYYY-MM' string into a `MonthKey`, throwing on malformed input. */
+export declare function parseMonthKey(s: string): MonthKey;
+/** Parse a 'YYYY-MM-DD' string into a `DayKey`, throwing on malformed input. */
+export declare function parseDayKey(s: string): DayKey;
+/** Build a `MonthKey` from a numeric year and month (1..12). */
+export declare function formatMonthKey(year: number, month: number): MonthKey;
+/** Build a `DayKey` from numeric year, month and calendar-valid day. */
+export declare function formatDayKey(year: number, month: number, day: number): DayKey;
+/** The year component of a month key, as a number. */
+export declare function monthKeyYear(key: MonthKey): number;
+/** The month component (1..12) of a month key, as a number. */
+export declare function monthKeyMonth(key: MonthKey): number;
+/** Truncate a day key to its month ('2020-03-17' → '2020-03'). */
+export declare function dayToMonth(day: DayKey): MonthKey;
+/** The first day of a month ('2020-03' → '2020-03-01'). */
+export declare function monthStartDay(month: MonthKey): DayKey;
+/**
+ * Normalize any recognized date key to its month. Accepts either a 'YYYY-MM'
+ * or 'YYYY-MM-DD' string; throws on anything else. Handy when a series may
+ * carry either granularity.
+ */
+export declare function toMonthKey(date: string): MonthKey;
+//# sourceMappingURL=dates.d.ts.map

package/dist/canonical/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../src/canonical/dates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;CAAE,CAAA;AAEhE,gFAAgF;AAChF,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAA;AAK5D,4DAA4D;AAC5D,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,IAAI,QAAQ,CAEnD;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,IAAI,MAAM,CAW/C;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ,CAGjD;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED,gEAAgE;AAChE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,CAQpE;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAO7E;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,CAElD;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,CAEnD;AAED,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAEhD;AAED,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAGjD"}

package/dist/canonical/dates.js

@@ -0,0 +1,86 @@
+/**
+ * Canonical date-granularity helpers.
+ *
+ * Fathom works in daily 'yyyy-mm-dd' keys (`DailyRecord.date`); retirement-sim
+ * and the Monte Carlo `RealReturnSeries` work in monthly 'YYYY-MM' keys. The
+ * two are easy to confuse because both are dash-delimited strings. Branded
+ * types make the granularity part of the static type, so a `DayKey` can never
+ * be passed where a `MonthKey` is wanted (or vice-versa) without an explicit,
+ * validating conversion.
+ */
+const MONTH_RE = /^\d{4}-(0[1-9]|1[0-2])$/;
+const DAY_RE = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+/** Type guard: is `s` a well-formed 'YYYY-MM' month key? */
+export function isMonthKey(s) {
+    return MONTH_RE.test(s);
+}
+/** Type guard: is `s` a well-formed 'YYYY-MM-DD' day key? */
+export function isDayKey(s) {
+    if (!DAY_RE.test(s))
+        return false;
+    const year = Number(s.slice(0, 4));
+    const month = Number(s.slice(5, 7));
+    const day = Number(s.slice(8, 10));
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+/** Parse a 'YYYY-MM' string into a `MonthKey`, throwing on malformed input. */
+export function parseMonthKey(s) {
+    if (!isMonthKey(s))
+        throw new Error(`Invalid month key '${s}'; expected 'YYYY-MM'`);
+    return s;
+}
+/** Parse a 'YYYY-MM-DD' string into a `DayKey`, throwing on malformed input. */
+export function parseDayKey(s) {
+    if (!isDayKey(s))
+        throw new Error(`Invalid day key '${s}'; expected 'YYYY-MM-DD'`);
+    return s;
+}
+/** Build a `MonthKey` from a numeric year and month (1..12). */
+export function formatMonthKey(year, month) {
+    if (!Number.isInteger(month) || month < 1 || month > 12) {
+        throw new Error(`Month ${month} out of range 1..12`);
+    }
+    if (!Number.isInteger(year) || year < 0) {
+        throw new Error(`Year ${year} is not a non-negative integer`);
+    }
+    return `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}`;
+}
+/** Build a `DayKey` from numeric year, month and calendar-valid day. */
+export function formatDayKey(year, month, day) {
+    if (!Number.isInteger(day) || day < 1 || day > 31) {
+        throw new Error(`Day ${day} out of range 1..31`);
+    }
+    // Reuse the month validation, then validate the composed calendar date.
+    const ym = formatMonthKey(year, month);
+    return parseDayKey(`${ym}-${String(day).padStart(2, '0')}`);
+}
+/** The year component of a month key, as a number. */
+export function monthKeyYear(key) {
+    return Number(key.slice(0, 4));
+}
+/** The month component (1..12) of a month key, as a number. */
+export function monthKeyMonth(key) {
+    return Number(key.slice(5, 7));
+}
+/** Truncate a day key to its month ('2020-03-17' → '2020-03'). */
+export function dayToMonth(day) {
+    return day.slice(0, 7);
+}
+/** The first day of a month ('2020-03' → '2020-03-01'). */
+export function monthStartDay(month) {
+    return `${month}-01`;
+}
+/**
+ * Normalize any recognized date key to its month. Accepts either a 'YYYY-MM'
+ * or 'YYYY-MM-DD' string; throws on anything else. Handy when a series may
+ * carry either granularity.
+ */
+export function toMonthKey(date) {
+    if (isDayKey(date))
+        return dayToMonth(date);
+    return parseMonthKey(date);
+}
+//# sourceMappingURL=dates.js.map

package/dist/canonical/dates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.js","sourceRoot":"","sources":["../../src/canonical/dates.ts"],"names":[],"mappings":"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"}

package/dist/canonical/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Canonical type vocabulary + pure conversion adapters bridging the two engine
+ * dialects lifted into this repo (Fathom's `src/engine` and the retirement-sim
+ * sources under `staging/`). Additive only — nothing here modifies either
+ * engine; the adapters translate at the boundary.
+ */
+export * from './allocation.js';
+export * from './rebalance.js';
+export * from './dates.js';
+export * from './strategy.js';
+export * from './returns.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/canonical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/canonical/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA"}

package/dist/canonical/index.js

@@ -0,0 +1,12 @@
+/**
+ * Canonical type vocabulary + pure conversion adapters bridging the two engine
+ * dialects lifted into this repo (Fathom's `src/engine` and the retirement-sim
+ * sources under `staging/`). Additive only — nothing here modifies either
+ * engine; the adapters translate at the boundary.
+ */
+export * from './allocation.js';
+export * from './rebalance.js';
+export * from './dates.js';
+export * from './strategy.js';
+export * from './returns.js';
+//# sourceMappingURL=index.js.map

package/dist/canonical/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/canonical/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA"}

package/dist/canonical/rebalance.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Canonical rebalance-frequency vocabulary.
+ *
+ * The dialects overlap only partially:
+ *  - Fathom  (`RebalanceFrequency`): 'none' | 'annual' | 'quarterly' | 'monthly'
+ *    — calendar cadences.
+ *  - retirement-sim (`RebalancePolicy`): 'none' | 'yearly' | 'every-n-years' |
+ *    'on-withdrawal' | 'threshold' — policies, some event- or drift-driven.
+ *
+ * Canonical union is the superset, with the one genuine synonym collapsed:
+ * Fathom's 'annual' and retirement-sim's 'yearly' are the same cadence, spelled
+ * 'annual' canonically. Mappings that would lose information (a canonical
+ * cadence a target dialect can't express) THROW rather than guess a nearest
+ * neighbour.
+ */
+import type { RebalanceFrequency } from '../engine/types.js';
+/** retirement-sim's rebalance policy (mirrored structurally; staging is read-only). */
+export type RetirementRebalancePolicy = 'none' | 'yearly' | 'every-n-years' | 'on-withdrawal' | 'threshold';
+/** Superset covering both dialects; 'annual' subsumes retirement-sim 'yearly'. */
+export type CanonicalRebalance = 'none' | 'monthly' | 'quarterly' | 'annual' | 'every-n-years' | 'on-withdrawal' | 'threshold';
+/** Fathom → canonical. Total (every Fathom value is a valid canonical value). */
+export declare function fromFathomRebalance(freq: RebalanceFrequency): CanonicalRebalance;
+/**
+ * Canonical → Fathom. Fathom has no notion of the event/drift policies, so
+ * 'every-n-years' | 'on-withdrawal' | 'threshold' throw.
+ */
+export declare function toFathomRebalance(rebalance: CanonicalRebalance): RebalanceFrequency;
+/** retirement-sim → canonical. Only 'yearly' is renamed (→ 'annual'). */
+export declare function fromRetirementRebalance(policy: RetirementRebalancePolicy): CanonicalRebalance;
+/**
+ * Canonical → retirement-sim. retirement-sim has no sub-annual calendar
+ * cadence, so 'monthly' | 'quarterly' throw; 'annual' becomes 'yearly'.
+ */
+export declare function toRetirementRebalance(rebalance: CanonicalRebalance): RetirementRebalancePolicy;
+//# sourceMappingURL=rebalance.d.ts.map

package/dist/canonical/rebalance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalance.d.ts","sourceRoot":"","sources":["../../src/canonical/rebalance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAE5D,uFAAuF;AACvF,MAAM,MAAM,yBAAyB,GACjC,MAAM,GACN,QAAQ,GACR,eAAe,GACf,eAAe,GACf,WAAW,CAAA;AAEf,kFAAkF;AAClF,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,SAAS,GACT,WAAW,GACX,QAAQ,GACR,eAAe,GACf,eAAe,GACf,WAAW,CAAA;AAEf,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,GAAG,kBAAkB,CAEhF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,kBAAkB,GAAG,kBAAkB,CAYnF;AAED,yEAAyE;AACzE,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,yBAAyB,GAAG,kBAAkB,CAE7F;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,kBAAkB,GAC5B,yBAAyB,CAc3B"}

package/dist/canonical/rebalance.js

@@ -0,0 +1,56 @@
+/**
+ * Canonical rebalance-frequency vocabulary.
+ *
+ * The dialects overlap only partially:
+ *  - Fathom  (`RebalanceFrequency`): 'none' | 'annual' | 'quarterly' | 'monthly'
+ *    — calendar cadences.
+ *  - retirement-sim (`RebalancePolicy`): 'none' | 'yearly' | 'every-n-years' |
+ *    'on-withdrawal' | 'threshold' — policies, some event- or drift-driven.
+ *
+ * Canonical union is the superset, with the one genuine synonym collapsed:
+ * Fathom's 'annual' and retirement-sim's 'yearly' are the same cadence, spelled
+ * 'annual' canonically. Mappings that would lose information (a canonical
+ * cadence a target dialect can't express) THROW rather than guess a nearest
+ * neighbour.
+ */
+/** Fathom → canonical. Total (every Fathom value is a valid canonical value). */
+export function fromFathomRebalance(freq) {
+    return freq;
+}
+/**
+ * Canonical → Fathom. Fathom has no notion of the event/drift policies, so
+ * 'every-n-years' | 'on-withdrawal' | 'threshold' throw.
+ */
+export function toFathomRebalance(rebalance) {
+    switch (rebalance) {
+        case 'none':
+        case 'monthly':
+        case 'quarterly':
+        case 'annual':
+            return rebalance;
+        default:
+            throw new Error(`Canonical rebalance '${rebalance}' has no Fathom RebalanceFrequency equivalent`);
+    }
+}
+/** retirement-sim → canonical. Only 'yearly' is renamed (→ 'annual'). */
+export function fromRetirementRebalance(policy) {
+    return policy === 'yearly' ? 'annual' : policy;
+}
+/**
+ * Canonical → retirement-sim. retirement-sim has no sub-annual calendar
+ * cadence, so 'monthly' | 'quarterly' throw; 'annual' becomes 'yearly'.
+ */
+export function toRetirementRebalance(rebalance) {
+    switch (rebalance) {
+        case 'annual':
+            return 'yearly';
+        case 'none':
+        case 'every-n-years':
+        case 'on-withdrawal':
+        case 'threshold':
+            return rebalance;
+        default:
+            throw new Error(`Canonical rebalance '${rebalance}' has no retirement-sim RebalancePolicy equivalent`);
+    }
+}
+//# sourceMappingURL=rebalance.js.map

package/dist/canonical/rebalance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalance.js","sourceRoot":"","sources":["../../src/canonical/rebalance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAsBH,iFAAiF;AACjF,MAAM,UAAU,mBAAmB,CAAC,IAAwB;IAC1D,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAA6B;IAC7D,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,MAAM,CAAC;QACZ,KAAK,SAAS,CAAC;QACf,KAAK,WAAW,CAAC;QACjB,KAAK,QAAQ;YACX,OAAO,SAAS,CAAA;QAClB;YACE,MAAM,IAAI,KAAK,CACb,wBAAwB,SAAS,+CAA+C,CACjF,CAAA;IACL,CAAC;AACH,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,uBAAuB,CAAC,MAAiC;IACvE,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAA;AAChD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAA6B;IAE7B,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,QAAQ;YACX,OAAO,QAAQ,CAAA;QACjB,KAAK,MAAM,CAAC;QACZ,KAAK,eAAe,CAAC;QACrB,KAAK,eAAe,CAAC;QACrB,KAAK,WAAW;YACd,OAAO,SAAS,CAAA;QAClB;YACE,MAAM,IAAI,KAAK,CACb,wBAAwB,SAAS,oDAAoD,CACtF,CAAA;IACL,CAAC;AACH,CAAC"}