@actuarial-ts/core 0.2.0 → 0.3.0

package/src/capping.ts

@@ -0,0 +1,295 @@
+import type { ClaimSnapshot } from "./types.js";
+import { ReservingError } from "./types.js";
+import { isNum } from "./util.js";
+
+/**
+ * Claim-level loss capping: the foundation of developing a reliable layer.
+ *
+ * Large losses are volatile and distort development patterns; capping every
+ * claim at a per-occurrence limit and developing the capped ("limited")
+ * triangles gives stable factors. The excess layer is restored later via
+ * increased-limits factors, applied to the developed capped ultimates.
+ *
+ * The cap can be INDEXED: stated at a base-year cost level and moved by an
+ * annual rate so the layer stays constant in real terms across origin years
+ * (a flat $250k cap in 2016 is a deeper real layer than in 2025). indexRate 0
+ * reproduces the flat-cap convention.
+ */
+
+export interface CapOptions {
+  /** Per-occurrence cap, stated at the baseYear cost level. */
+  cap: number;
+  /** Annual index rate moving the cap across accident years (0 = flat cap). */
+  indexRate?: number;
+  /**
+   * Accident year at whose cost level `cap` is stated. Defaults to the latest
+   * accident year present in the data.
+   */
+  baseYear?: number;
+}
+
+function accidentYear(snap: ClaimSnapshot): number {
+  return Number(snap.accidentDate.slice(0, 4));
+}
+
+/**
+ * The default base year for a cap index: the latest accident year with a
+ * snapshot evaluated on or before asOfDate. capClaims and
+ * claimSizeDiagnostics MUST resolve this identically, or the applied caps
+ * diverge from what the exhibits report; services should resolve it once via
+ * this helper and pass baseYear explicitly to both.
+ */
+export function latestAccidentYear(claims: ClaimSnapshot[], asOfDate?: string): number {
+  const asOf = asOfDate ?? "9999-12-31";
+  let year = -Infinity;
+  for (const snap of claims) {
+    if (snap.evaluationDate > asOf) continue;
+    year = Math.max(year, accidentYear(snap));
+  }
+  if (!Number.isFinite(year)) {
+    throw new ReservingError(
+      "NO_CLAIMS",
+      "No claim snapshots on or before the analysis date; cannot resolve a cap base year",
+    );
+  }
+  return year;
+}
+
+/** The effective cap for one accident year under the index. */
+export function effectiveCap(options: Required<CapOptions>, year: number): number {
+  return options.cap * Math.pow(1 + options.indexRate, year - options.baseYear);
+}
+
+function resolveOptions(claims: ClaimSnapshot[], options: CapOptions): Required<CapOptions> {
+  if (!isNum(options.cap) || options.cap <= 0) {
+    throw new ReservingError("BAD_CAP", "The per-occurrence cap must be a positive number");
+  }
+  const indexRate = options.indexRate ?? 0;
+  if (!isNum(indexRate) || indexRate <= -1) {
+    throw new ReservingError("BAD_CAP", "The cap index rate must be a number greater than -100%");
+  }
+  let baseYear = options.baseYear ?? null;
+  if (baseYear === null) {
+    baseYear = -Infinity;
+    for (const snap of claims) baseYear = Math.max(baseYear, accidentYear(snap));
+  }
+  if (!isNum(baseYear) || !Number.isFinite(baseYear)) {
+    throw new ReservingError("BAD_CAP", "Could not resolve a base year for the cap index");
+  }
+  return { cap: options.cap, indexRate, baseYear };
+}
+
+/**
+ * Caps every snapshot at the (indexed) per-occurrence limit for its accident
+ * year: capped incurred = min(reported incurred, cap_y); capped paid =
+ * min(paid, cap_y); capped case = capped incurred - capped paid (never
+ * negative by construction). Claim counts and statuses are untouched - the
+ * cap limits dollars, not claims.
+ */
+export function capClaims(claims: ClaimSnapshot[], options: CapOptions): ClaimSnapshot[] {
+  const resolved = resolveOptions(claims, options);
+  return claims.map((snap) => {
+    const capY = effectiveCap(resolved, accidentYear(snap));
+    const incurred = snap.paidToDate + snap.caseReserve;
+    const cappedIncurred = Math.min(incurred, capY);
+    const cappedPaid = Math.min(snap.paidToDate, capY);
+    if (cappedIncurred === incurred && cappedPaid === snap.paidToDate) return snap;
+    return {
+      ...snap,
+      paidToDate: cappedPaid,
+      caseReserve: cappedIncurred - cappedPaid,
+    };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Cap-selection diagnostics: the evidence an actuary picks the layer from.
+
+export interface ClaimSizeYearRow {
+  year: number;
+  claimCount: number;
+  /** Reported incurred at each claim's latest evaluation. */
+  totalIncurred: number;
+  maxClaim: number;
+  percentiles: { p: number; value: number }[];
+}
+
+export interface CapCandidateYearCell {
+  year: number;
+  /** The candidate cap at this year's cost level (indexed). */
+  effectiveCap: number;
+  /** Claims whose reported incurred pierces the effective cap. */
+  pierceCount: number;
+  pierceShare: number;
+  /** Dollars above the cap as a share of total reported incurred. */
+  excessShare: number;
+}
+
+export interface CapCandidate {
+  /** Candidate cap stated at the base-year cost level. */
+  cap: number;
+  byYear: CapCandidateYearCell[];
+  totalPierceCount: number;
+  totalPierceShare: number;
+  totalExcessShare: number;
+}
+
+export interface ClaimSizeDiagnostics {
+  years: ClaimSizeYearRow[];
+  candidates: CapCandidate[];
+  baseYear: number;
+  indexRate: number;
+  /** Claims with a positive reported incurred at their latest evaluation. */
+  nonZeroClaimCount: number;
+}
+
+export interface ClaimSizeDiagnosticsOptions {
+  /** Only snapshots evaluated on or before this ISO date are considered. */
+  asOfDate?: string;
+  /** Candidate caps stated at the base-year level; sensible defaults derived if omitted. */
+  candidateCaps?: number[];
+  /** Caps merged into the derived defaults (e.g. the currently-set cap). */
+  extraCaps?: number[];
+  indexRate?: number;
+  baseYear?: number;
+}
+
+const PERCENTILES = [0.5, 0.75, 0.9, 0.95, 0.99];
+
+// Crude empirical convention (ceil-rank, no interpolation) is deliberate:
+// candidate caps get rounded to 1-2 significant digits right after, so the
+// interpolated refinement in stochastic.ts's percentileOfSorted buys nothing.
+function percentile(sorted: number[], p: number): number {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p * sorted.length) - 1));
+  return sorted[idx]!;
+}
+
+/** Round to 1-2 significant digits for readable candidate caps. */
+function roundCandidate(value: number): number {
+  if (value <= 0) return 0;
+  const magnitude = Math.pow(10, Math.floor(Math.log10(value)));
+  const scaled = value / magnitude;
+  const nice = scaled < 1.5 ? 1 : scaled < 3.5 ? 2.5 : scaled < 7.5 ? 5 : 10;
+  return nice * magnitude;
+}
+
+/**
+ * Latest-evaluation claim-size distribution by accident year plus pierce and
+ * excess-share statistics for a set of candidate caps (indexed to each year).
+ */
+export function claimSizeDiagnostics(
+  claims: ClaimSnapshot[],
+  options: ClaimSizeDiagnosticsOptions = {},
+): ClaimSizeDiagnostics {
+  if (claims.length === 0) {
+    throw new ReservingError("NO_CLAIMS", "Cannot analyze claim sizes with no claims");
+  }
+  const asOf = options.asOfDate ?? "9999-12-31";
+  // Latest evaluation per claim on or before the analysis date.
+  const latest = new Map<string, ClaimSnapshot>();
+  for (const snap of claims) {
+    if (snap.evaluationDate > asOf) continue;
+    const prev = latest.get(snap.claimId);
+    if (!prev || snap.evaluationDate > prev.evaluationDate) latest.set(snap.claimId, snap);
+  }
+
+  const byYear = new Map<number, number[]>();
+  for (const snap of latest.values()) {
+    const year = accidentYear(snap);
+    const incurred = snap.paidToDate + snap.caseReserve;
+    let arr = byYear.get(year);
+    if (!arr) byYear.set(year, (arr = []));
+    arr.push(incurred);
+  }
+  const years = [...byYear.keys()].sort((a, b) => a - b);
+  const indexRate = options.indexRate ?? 0;
+  const baseYear = options.baseYear ?? years[years.length - 1]!;
+
+  const yearRows: ClaimSizeYearRow[] = years.map((year) => {
+    const sorted = [...byYear.get(year)!].sort((a, b) => a - b);
+    return {
+      year,
+      claimCount: sorted.length,
+      totalIncurred: sorted.reduce((a, v) => a + v, 0),
+      maxClaim: sorted[sorted.length - 1] ?? 0,
+      percentiles: PERCENTILES.map((p) => ({ p, value: percentile(sorted, p) })),
+    };
+  });
+
+  // Candidate caps: provided, or derived from the pooled distribution so the
+  // menu spans "caps almost nothing" to "caps only the extreme tail".
+  // Candidates are STATED at the base-year cost level, so each claim's
+  // incurred is deflated to that level before taking percentiles - otherwise
+  // a nominal anchor re-indexed forward overshoots the whole distribution
+  // and every derived candidate reads near-zero pierce.
+  let candidateCaps = options.candidateCaps;
+  if (!candidateCaps || candidateCaps.length === 0) {
+    const pooled = [...latest.values()]
+      .map((s) => {
+        const incurred = s.paidToDate + s.caseReserve;
+        return incurred / Math.pow(1 + indexRate, accidentYear(s) - baseYear);
+      })
+      .filter((v) => v > 0)
+      .sort((a, b) => a - b);
+    const anchors = [0.75, 0.9, 0.95, 0.99].map((p) => percentile(pooled, p));
+    const uniq = new Set<number>();
+    for (const a of anchors) {
+      const rounded = roundCandidate(a);
+      if (rounded > 0) uniq.add(rounded);
+    }
+    for (const extra of options.extraCaps ?? []) {
+      if (extra > 0) uniq.add(extra);
+    }
+    candidateCaps = [...uniq].sort((a, b) => a - b);
+  }
+
+  const resolved: Required<CapOptions> = { cap: 1, indexRate, baseYear };
+  const candidates: CapCandidate[] = candidateCaps.map((cap) => {
+    let totalPierce = 0;
+    let totalClaims = 0;
+    let totalExcess = 0;
+    let totalIncurred = 0;
+    const cells: CapCandidateYearCell[] = years.map((year) => {
+      const capY = cap * Math.pow(1 + resolved.indexRate, year - resolved.baseYear);
+      const values = byYear.get(year)!;
+      let pierce = 0;
+      let excess = 0;
+      let incurred = 0;
+      for (const v of values) {
+        incurred += v;
+        if (v > capY) {
+          pierce++;
+          excess += v - capY;
+        }
+      }
+      totalPierce += pierce;
+      totalClaims += values.length;
+      totalExcess += excess;
+      totalIncurred += incurred;
+      return {
+        year,
+        effectiveCap: capY,
+        pierceCount: pierce,
+        pierceShare: values.length > 0 ? pierce / values.length : 0,
+        excessShare: incurred > 0 ? excess / incurred : 0,
+      };
+    });
+    return {
+      cap,
+      byYear: cells,
+      totalPierceCount: totalPierce,
+      totalPierceShare: totalClaims > 0 ? totalPierce / totalClaims : 0,
+      totalExcessShare: totalIncurred > 0 ? totalExcess / totalIncurred : 0,
+    };
+  });
+
+  return {
+    years: yearRows,
+    candidates,
+    baseYear,
+    indexRate,
+    nonZeroClaimCount: [...latest.values()].filter((s) => s.paidToDate + s.caseReserve > 0)
+      .length,
+  };
+}

package/src/caseOutstanding.ts

@@ -0,0 +1,270 @@
+import type { Triangle } from "./types.js";
+import { ReservingError } from "./types.js";
+import { isNum, lastJointObservedIndex, lastObservedIndex, safeRatio } from "./util.js";
+
+/**
+ * Case-outstanding development technique (Friedland, "Estimating Unpaid
+ * Claims Using Basic Techniques", ch. 12): for books where the case reserves
+ * are the only reliable triangle (classic self-insured situation), unpaid
+ * claims are projected from the run-off of the case outstanding itself.
+ *
+ * Ground truth:
+ * - Two historical ratio triangles drive the review:
+ *   caseRatios[i][j]      = case[i][j+1] / case[i][j]   (case run-off), and
+ *   paidOnPriorCase[i][j] = (paid[i][j+1] - paid[i][j]) / case[i][j]
+ *   (incremental paid in the interval as a ratio of the case reserve held at
+ *   its start - "paid on prior case").
+ * - The CALLER selects both patterns (this module never picks factors). The
+ *   projection walks each origin's latest case forward: payments in the next
+ *   interval = case x paidOnCaseSelection, next case = case x caseSelection.
+ * - Case remaining at the last development age pays out at `tailPaidOnCase`
+ *   times its face value (default 1: paid in full, the conventional
+ *   assumption; a warning notes when the default was relied on).
+ * - unpaid = the sum of the projected future payments including the tail
+ *   payout - the reserve IS the projected paid stream, an identity the
+ *   self-consistency test enforces.
+ *
+ * Selection coercions (loud, never silent):
+ * - missing case selection -> 1.000 (case carried forward), warned;
+ * - negative case selection -> 0.000 (case cannot go negative), warned;
+ * - missing paid-on-case selection -> 0.000 (no payment projected), warned;
+ * - negative paid-on-case selection -> kept (projects net recoveries), warned;
+ * - ALL selections missing across both arrays -> NO_SELECTIONS.
+ */
+
+export interface CaseOutstandingOptions {
+  /** Selected case run-off ratios (next case / current case), one per interval. */
+  caseSelections: (number | null)[];
+  /** Selected incremental-paid-to-prior-case ratios, one per interval. */
+  paidOnCaseSelections: (number | null)[];
+  /**
+   * Payments after the last age as a ratio of the case remaining there.
+   * Default 1 (remaining case pays out in full).
+   */
+  tailPaidOnCase?: number;
+}
+
+export interface CaseOutstandingRow {
+  origin: string;
+  /** Age (months) of the latest cell observed in BOTH triangles. */
+  latestAge: number;
+  paidToDate: number;
+  /** Case outstanding at the latest age (the projection's seed). */
+  caseOutstanding: number;
+  /**
+   * Projected future incremental paid: futurePaid[m] pays in the interval
+   * ending at the (m+1)-th age after latestAge; the LAST element is the tail
+   * payout of the case remaining at the final development age.
+   */
+  futurePaid: number[];
+  /** Projected case outstanding at each later age (parallel run-off path). */
+  projectedCase: number[];
+  /** Sum of futurePaid (the reserve). */
+  unpaid: number;
+  /** paidToDate + unpaid. */
+  ultimate: number;
+}
+
+export interface CaseOutstandingResult {
+  method: "caseOutstanding";
+  /** Historical case run-off ratios, [origin][interval]; null where not computable. */
+  caseRatios: (number | null)[][];
+  /** Historical incremental paid / prior case, [origin][interval]. */
+  paidOnPriorCase: (number | null)[][];
+  /** The tail payout ratio the projection used. */
+  tailPaidOnCase: number;
+  rows: CaseOutstandingRow[];
+  totals: { paidToDate: number; caseOutstanding: number; unpaid: number; ultimate: number };
+  warnings: string[];
+}
+
+function assertSameShape(a: Triangle, b: Triangle): void {
+  const sameOrigins =
+    a.origins.length === b.origins.length && a.origins.every((o, i) => o === b.origins[i]);
+  const sameAges = a.ages.length === b.ages.length && a.ages.every((v, j) => v === b.ages[j]);
+  if (!sameOrigins || !sameAges) {
+    throw new ReservingError(
+      "SHAPE",
+      "The paid and case-outstanding triangles must share identical origins and development ages",
+    );
+  }
+}
+
+export function runCaseOutstanding(
+  paid: Triangle,
+  caseOutstanding: Triangle,
+  options: CaseOutstandingOptions,
+): CaseOutstandingResult {
+  assertSameShape(paid, caseOutstanding);
+  const nOrigins = paid.origins.length;
+  const nAges = paid.ages.length;
+  const nIntervals = nAges - 1;
+  for (const [name, selections] of [
+    ["caseSelections", options.caseSelections],
+    ["paidOnCaseSelections", options.paidOnCaseSelections],
+  ] as const) {
+    if (selections.length !== nIntervals) {
+      throw new ReservingError(
+        "SELECTION_SHAPE",
+        `Expected ${nIntervals} ${name} (one per development interval), got ${selections.length}`,
+      );
+    }
+  }
+  const tailPaidOnCase = options.tailPaidOnCase ?? 1;
+  if (!isNum(tailPaidOnCase) || tailPaidOnCase < 0) {
+    throw new ReservingError(
+      "BAD_TAIL",
+      `tailPaidOnCase must be a finite, non-negative ratio, got ${options.tailPaidOnCase}`,
+    );
+  }
+  const anySelected =
+    options.caseSelections.some((s) => isNum(s)) ||
+    options.paidOnCaseSelections.some((s) => isNum(s));
+  if (nIntervals > 0 && !anySelected) {
+    throw new ReservingError(
+      "NO_SELECTIONS",
+      "No case run-off or paid-on-case ratios are selected for any interval; select patterns before running the analysis",
+    );
+  }
+
+  const warnings: string[] = [];
+
+  // Effective selections with the documented coercions, warned per interval.
+  const effectiveCase: number[] = options.caseSelections.map((s, j) => {
+    const label = `${paid.ages[j]}-${paid.ages[j + 1]} months`;
+    if (!isNum(s)) {
+      warnings.push(`Missing case run-off selection for ${label}; treated as 1.000 (case carried forward)`);
+      return 1;
+    }
+    if (s < 0) {
+      warnings.push(
+        `Negative case run-off selection for ${label} would project negative case; treated as 0.000`,
+      );
+      return 0;
+    }
+    return s;
+  });
+  const effectivePaid: number[] = options.paidOnCaseSelections.map((s, j) => {
+    const label = `${paid.ages[j]}-${paid.ages[j + 1]} months`;
+    if (!isNum(s)) {
+      warnings.push(`Missing paid-on-case selection for ${label}; treated as 0.000 (no payment projected)`);
+      return 0;
+    }
+    if (s < 0) {
+      warnings.push(`Negative paid-on-case selection for ${label} projects net recoveries; kept as given`);
+    }
+    return s;
+  });
+
+  // Historical ratio triangles (null-safe: prior case must be positive, and
+  // an incremental paid needs both cumulative cells observed).
+  const caseRatios: (number | null)[][] = [];
+  const paidOnPriorCase: (number | null)[][] = [];
+  for (let i = 0; i < nOrigins; i++) {
+    const cRow: (number | null)[] = [];
+    const pRow: (number | null)[] = [];
+    for (let j = 0; j < nIntervals; j++) {
+      const casePrior = caseOutstanding.values[i]![j] ?? null;
+      const caseNext = caseOutstanding.values[i]![j + 1] ?? null;
+      const paidPrior = paid.values[i]![j] ?? null;
+      const paidNext = paid.values[i]![j + 1] ?? null;
+      cRow.push(safeRatio(caseNext, casePrior));
+      pRow.push(
+        isNum(paidPrior) && isNum(paidNext)
+          ? safeRatio(paidNext - paidPrior, casePrior)
+          : null,
+      );
+    }
+    caseRatios.push(cRow);
+    paidOnPriorCase.push(pRow);
+  }
+
+  const rows: CaseOutstandingRow[] = [];
+  let tailDefaultRelevant = false;
+  for (let i = 0; i < nOrigins; i++) {
+    const paidRow = paid.values[i]!;
+    const caseRow = caseOutstanding.values[i]!;
+    const lastPaid = lastObservedIndex(paidRow);
+    const lastCase = lastObservedIndex(caseRow);
+    const k = lastJointObservedIndex(paidRow, caseRow);
+    if (k < 0) {
+      warnings.push(
+        `Origin ${paid.origins[i]} has no age with both paid and case outstanding observed; excluded from results`,
+      );
+      continue;
+    }
+    if (lastPaid !== lastCase) {
+      warnings.push(
+        `Origin ${paid.origins[i]}: paid and case diagonals end at different ages (${paid.ages[lastPaid]} vs ${paid.ages[lastCase]}); projected from the latest jointly observed age ${paid.ages[k]}`,
+      );
+    }
+
+    const paidToDate = paidRow[k]!;
+    const seedCase = caseRow[k]!;
+    if (seedCase < 0) {
+      warnings.push(
+        `Origin ${paid.origins[i]}: case outstanding at the seed age is negative (${seedCase}); the projection carries the sign through, so review whether net recoveries are genuinely expected`,
+      );
+    }
+    const futurePaid: number[] = [];
+    const projectedCase: number[] = [];
+    let current = seedCase;
+    let warnedNegativeProjection = seedCase < 0;
+    for (let j = k; j < nIntervals; j++) {
+      futurePaid.push(current * effectivePaid[j]!);
+      current *= effectiveCase[j]!;
+      projectedCase.push(current);
+      if (current < 0 && !warnedNegativeProjection) {
+        warnedNegativeProjection = true;
+        warnings.push(
+          `Origin ${paid.origins[i]}: projected case outstanding turns negative (${current}) at age ${paid.ages[j + 1] ?? "tail"}; downstream reserves inherit the sign`,
+        );
+      }
+    }
+    if (current !== 0 && options.tailPaidOnCase === undefined) tailDefaultRelevant = true;
+    futurePaid.push(current * tailPaidOnCase);
+
+    const unpaid = futurePaid.reduce((a, v) => a + v, 0);
+    rows.push({
+      origin: paid.origins[i]!,
+      latestAge: paid.ages[k]!,
+      paidToDate,
+      caseOutstanding: seedCase,
+      futurePaid,
+      projectedCase,
+      unpaid,
+      ultimate: paidToDate + unpaid,
+    });
+  }
+  if (rows.length === 0) {
+    throw new ReservingError(
+      "NO_DATA",
+      "No origin period has both paid and case outstanding observed at any age",
+    );
+  }
+  if (tailDefaultRelevant) {
+    warnings.push(
+      `Case outstanding remaining at ${paid.ages[nAges - 1]} months is assumed paid in full (tailPaidOnCase defaulted to 1); supply tailPaidOnCase to select otherwise`,
+    );
+  }
+
+  const totals = rows.reduce(
+    (acc, r) => ({
+      paidToDate: acc.paidToDate + r.paidToDate,
+      caseOutstanding: acc.caseOutstanding + r.caseOutstanding,
+      unpaid: acc.unpaid + r.unpaid,
+      ultimate: acc.ultimate + r.ultimate,
+    }),
+    { paidToDate: 0, caseOutstanding: 0, unpaid: 0, ultimate: 0 },
+  );
+
+  return {
+    method: "caseOutstanding",
+    caseRatios,
+    paidOnPriorCase,
+    tailPaidOnCase,
+    rows,
+    totals,
+    warnings,
+  };
+}

package/src/chainladder.ts

@@ -0,0 +1,101 @@
+import type { ChainLadderResult, ChainLadderRow, LdfSelections, Triangle } from "./types.js";
+import { ReservingError } from "./types.js";
+import { isNum, lastObservedIndex } from "./util.js";
+
+/**
+ * Chain Ladder (development) method.
+ *
+ * Ground truth:
+ * - CDFs are computed right to left: CDF at the last observed age = tail
+ *   factor; CDF_j = LDF_j x CDF_{j+1}.
+ * - Percent developed = 1 / CDF.
+ * - Ultimate = latest diagonal value x CDF at its age.
+ * - IBNR (incurred basis) / unpaid (paid basis) = ultimate - current.
+ * - Missing LDF selections: warn loudly and treat as 1.0; refuse to run when
+ *   ALL selections are missing.
+ */
+export function runChainLadder(tri: Triangle, selections: LdfSelections): ChainLadderResult {
+  const nAges = tri.ages.length;
+  const nLdfs = nAges - 1;
+  if (selections.selected.length !== nLdfs) {
+    throw new ReservingError(
+      "SELECTION_SHAPE",
+      `Expected ${nLdfs} LDF selections (one per development interval), got ${selections.selected.length}`,
+    );
+  }
+  if (!isNum(selections.tailFactor) || selections.tailFactor <= 0) {
+    throw new ReservingError("BAD_TAIL", "Tail factor must be a positive number");
+  }
+
+  const warnings: string[] = [];
+  const anySelected = selections.selected.some((s) => isNum(s));
+  if (nLdfs > 0 && !anySelected) {
+    throw new ReservingError(
+      "NO_SELECTIONS",
+      "No LDFs are selected for any development interval; select factors before running the analysis",
+    );
+  }
+
+  const effective: number[] = selections.selected.map((s, j) => {
+    if (isNum(s)) {
+      if (s <= 0) {
+        warnings.push(
+          `Selected LDF for ${tri.ages[j]}-${tri.ages[j + 1]} months is not positive; treated as 1.000`,
+        );
+        return 1;
+      }
+      return s;
+    }
+    warnings.push(
+      `Missing LDF selection for ${tri.ages[j]}-${tri.ages[j + 1]} months; treated as 1.000`,
+    );
+    return 1;
+  });
+
+  // Right-to-left cumulative development factors; cdfs[j] develops age[j] to ultimate.
+  const cdfs: number[] = new Array(nAges).fill(selections.tailFactor);
+  for (let j = nAges - 2; j >= 0; j--) {
+    cdfs[j] = effective[j]! * cdfs[j + 1]!;
+  }
+  const percentDeveloped = cdfs.map((c) => 1 / c);
+
+  const rows: ChainLadderRow[] = [];
+  for (let i = 0; i < tri.origins.length; i++) {
+    const latestIdx = lastObservedIndex(tri.values[i]!);
+    if (latestIdx < 0) {
+      warnings.push(`Origin ${tri.origins[i]} has no observed values; excluded from results`);
+      continue;
+    }
+    const latestValue = tri.values[i]![latestIdx]!;
+    const cdf = cdfs[latestIdx]!;
+    const ultimate = latestValue * cdf;
+    rows.push({
+      origin: tri.origins[i]!,
+      latestAge: tri.ages[latestIdx]!,
+      latestValue,
+      cdf,
+      percentDeveloped: 1 / cdf,
+      ultimate,
+      unpaid: ultimate - latestValue,
+    });
+  }
+
+  const totals = rows.reduce(
+    (acc, r) => ({
+      latest: acc.latest + r.latestValue,
+      ultimate: acc.ultimate + r.ultimate,
+      unpaid: acc.unpaid + r.unpaid,
+    }),
+    { latest: 0, ultimate: 0, unpaid: 0 },
+  );
+
+  return {
+    method: "chainLadder",
+    basis: tri.kind,
+    cdfs,
+    percentDeveloped,
+    rows,
+    totals,
+    warnings,
+  };
+}