@actuarial-ts/data 0.5.0 → 0.6.1

package/src/exposure.ts

@@ -11,9 +11,12 @@ export const exposureRecordSchema = z
     exposureUnits: z.number().finite().nullable(),
   })
   .strict()
-  .refine((record) => record.earnedPremium !== null || record.exposureUnits !== null, {
-    message: "earnedPremium and exposureUnits cannot both be null",
-  });
+  .refine(
+    (record) => record.earnedPremium !== null || record.exposureUnits !== null,
+    {
+      message: "earnedPremium and exposureUnits cannot both be null",
+    },
+  );
 
 export interface ExposureRowError {
   /** 1-based physical file line where the row starts. */
@@ -45,7 +48,9 @@ function optionalAmount(
   }
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) {
-    errors.push(`${name} must be blank or a finite decimal number (got "${raw}")`);
+    errors.push(
+      `${name} must be blank or a finite decimal number (got "${raw}")`,
+    );
     return null;
   }
   return parsed;
@@ -63,13 +68,29 @@ function optionalAmount(
 export function parseExposureCsv(text: string): ExposureParseResult {
   const { rows: grid, rowLines, warnings } = parseCsv(text);
   const headers = (grid[0] ?? []).map(normalizeHeader);
+  const duplicateHeaders = [
+    ...new Set(
+      headers.filter(
+        (header, index) => header !== "" && headers.indexOf(header) !== index,
+      ),
+    ),
+  ].sort();
+  if (duplicateHeaders.length > 0) {
+    throw new ReservingError(
+      "SHAPE",
+      `Duplicate normalized column(s): ${duplicateHeaders.join(", ")}`,
+    );
+  }
   if (!headers.includes("origin")) {
     throw new ReservingError(
       "SHAPE",
       `Missing required column: origin. Found: ${headers.filter(Boolean).join(", ") || "(none)"}`,
     );
   }
-  if (!headers.includes("earned_premium") && !headers.includes("exposure_units")) {
+  if (
+    !headers.includes("earned_premium") &&
+    !headers.includes("exposure_units")
+  ) {
     throw new ReservingError(
       "SHAPE",
       "Exposure CSV must include earned_premium, exposure_units, or both",
@@ -77,12 +98,13 @@ export function parseExposureCsv(text: string): ExposureParseResult {
   }
 
   const columnIndex = new Map<string, number>();
-  headers.forEach((header, index) => {
-    if (!columnIndex.has(header)) columnIndex.set(header, index);
-  });
+  headers.forEach((header, index) => columnIndex.set(header, index));
   const errors: ExposureRowError[] = warnings.map((warning) => {
     const line = /line (\d+)/.exec(warning)?.[1];
-    return { row: line === undefined ? 1 : Number(line), message: `CSV structure: ${warning}` };
+    return {
+      row: line === undefined ? 1 : Number(line),
+      message: `CSV structure: ${warning}`,
+    };
   });
   const parsedRows: { exposure: ExposureRecord; row: number }[] = [];
 
@@ -96,16 +118,32 @@ export function parseExposureCsv(text: string): ExposureParseResult {
     const rowErrors: string[] = [];
     const origin = cell("origin");
     if (origin === "") rowErrors.push("origin is required");
-    const earnedPremium = optionalAmount("earned_premium", cell("earned_premium"), rowErrors);
-    const exposureUnits = optionalAmount("exposure_units", cell("exposure_units"), rowErrors);
-    if (earnedPremium === null && exposureUnits === null && rowErrors.length === 0) {
+    const earnedPremium = optionalAmount(
+      "earned_premium",
+      cell("earned_premium"),
+      rowErrors,
+    );
+    const exposureUnits = optionalAmount(
+      "exposure_units",
+      cell("exposure_units"),
+      rowErrors,
+    );
+    if (
+      earnedPremium === null &&
+      exposureUnits === null &&
+      rowErrors.length === 0
+    ) {
       rowErrors.push("earned_premium and exposure_units cannot both be blank");
     }
     if (rowErrors.length > 0) {
       for (const message of rowErrors) errors.push({ row: rowNumber, message });
       continue;
     }
-    const validated = exposureRecordSchema.safeParse({ origin, earnedPremium, exposureUnits });
+    const validated = exposureRecordSchema.safeParse({
+      origin,
+      earnedPremium,
+      exposureUnits,
+    });
     if (!validated.success) {
       for (const issue of validated.error.issues) {
         errors.push({ row: rowNumber, message: issue.message });
@@ -115,17 +153,24 @@ export function parseExposureCsv(text: string): ExposureParseResult {
     parsedRows.push({ exposure: validated.data, row: rowNumber });
   }
 
-  const rowsByOrigin = new Map<string, { exposure: ExposureRecord; row: number }[]>();
+  const rowsByOrigin = new Map<
+    string,
+    { exposure: ExposureRecord; row: number }[]
+  >();
   for (const parsed of parsedRows) {
     const sameOrigin = rowsByOrigin.get(parsed.exposure.origin);
-    if (sameOrigin === undefined) rowsByOrigin.set(parsed.exposure.origin, [parsed]);
+    if (sameOrigin === undefined)
+      rowsByOrigin.set(parsed.exposure.origin, [parsed]);
     else sameOrigin.push(parsed);
   }
   const exposures: ExposureRecord[] = [];
   for (const [origin, sameOrigin] of rowsByOrigin) {
     if (sameOrigin.length > 1) {
       for (const duplicate of sameOrigin) {
-        errors.push({ row: duplicate.row, message: `duplicate origin "${origin}"` });
+        errors.push({
+          row: duplicate.row,
+          message: `duplicate origin "${origin}"`,
+        });
       }
     } else {
       exposures.push(sameOrigin[0]!.exposure);

package/src/index.ts

@@ -2,7 +2,10 @@ export * from "./csv.js";
 export * from "./annualDevelopment.js";
 export * from "./exposure.js";
 export * from "./diagnosticInput.js";
-export * from "./diagnosticReview.js";
+export * from "./diagnosticDefinition.js";
+export * from "./version.js";
+export * from "./diagnosticPreparedReview.js";
+export * from "./casualtyDiagnosticReview.js";
 export * from "./lossRun.js";
 export * from "./longFormat.js";
 export * from "./review.js";

package/src/lossRun.ts

@@ -63,7 +63,20 @@ function isValidIsoDate(value: string): boolean {
   // preserve leapness for every year except 0000, so this is a correctness-of-
   // form consolidation rather than a live-bug fix.
   const leap = (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
-  const daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][m - 1]!;
+  const daysInMonth = [
+    31,
+    leap ? 29 : 28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31,
+  ][m - 1]!;
   return d <= daysInMonth;
 }
 
@@ -71,6 +84,19 @@ function isValidIsoDate(value: string): boolean {
 export function parseLossRunCsv(text: string): LossRunParseResult {
   const { rows: grid, rowLines, warnings: csvWarnings } = parseCsv(text);
   const headers = (grid[0] ?? []).map(normalizeHeader);
+  const duplicateHeaders = [
+    ...new Set(
+      headers.filter(
+        (header, index) => header !== "" && headers.indexOf(header) !== index,
+      ),
+    ),
+  ].sort();
+  if (duplicateHeaders.length > 0) {
+    throw new ReservingError(
+      "SHAPE",
+      `Duplicate normalized column(s): ${duplicateHeaders.join(", ")}`,
+    );
+  }
   const missing = REQUIRED_COLUMNS.filter((c) => !headers.includes(c));
   if (missing.length > 0) {
     throw new ReservingError(
@@ -81,9 +107,7 @@ export function parseLossRunCsv(text: string): LossRunParseResult {
     );
   }
   const columnIndex = new Map<string, number>();
-  headers.forEach((h, idx) => {
-    if (!columnIndex.has(h)) columnIndex.set(h, idx);
-  });
+  headers.forEach((h, idx) => columnIndex.set(h, idx));
 
   const claims: ClaimSnapshot[] = [];
   const errors: LossRunRowError[] = [];
@@ -91,7 +115,10 @@ export function parseLossRunCsv(text: string): LossRunParseResult {
     // Structural CSV problems surface through the same channel as row errors:
     // partial loading is intended behavior here, silent partial loading is not.
     const lineMatch = warning.match(/line (\d+)/);
-    errors.push({ row: lineMatch ? Number(lineMatch[1]) : 1, message: `CSV structure: ${warning}` });
+    errors.push({
+      row: lineMatch ? Number(lineMatch[1]) : 1,
+      message: `CSV structure: ${warning}`,
+    });
   }
 
   for (let r = 1; r < grid.length; r++) {
@@ -101,7 +128,8 @@ export function parseLossRunCsv(text: string): LossRunParseResult {
     // lines. One errors array, one numbering scheme.
     const rowNumber = rowLines[r]!;
     const cells = grid[r]!;
-    const cell = (name: string): string => (cells[columnIndex.get(name)!] ?? "").trim();
+    const cell = (name: string): string =>
+      (cells[columnIndex.get(name)!] ?? "").trim();
     const rowErrors: string[] = [];
 
     const claimId = cell("claim_id");
@@ -110,7 +138,9 @@ export function parseLossRunCsv(text: string): LossRunParseResult {
     const date = (name: string): string | null => {
       const value = cell(name);
       if (!isValidIsoDate(value)) {
-        rowErrors.push(`${name} must be a real calendar date in yyyy-mm-dd form (got "${value}")`);
+        rowErrors.push(
+          `${name} must be a real calendar date in yyyy-mm-dd form (got "${value}")`,
+        );
         return null;
       }
       return value;
@@ -134,9 +164,13 @@ export function parseLossRunCsv(text: string): LossRunParseResult {
         );
         return null;
       }
-      const n = /^-?\d+(\.\d+)?$/.test(value.trim()) ? Number(value.trim()) : NaN;
+      const n = /^-?\d+(\.\d+)?$/.test(value.trim())
+        ? Number(value.trim())
+        : NaN;
       if (!Number.isFinite(n)) {
-        rowErrors.push(`${name} must be a finite decimal number (got "${value}")`);
+        rowErrors.push(
+          `${name} must be a finite decimal number (got "${value}")`,
+        );
         return null;
       }
       return n;
@@ -148,13 +182,21 @@ export function parseLossRunCsv(text: string): LossRunParseResult {
     const status: "open" | "closed" | null =
       statusRaw === "open" || statusRaw === "closed" ? statusRaw : null;
     if (status === null) {
-      rowErrors.push(`status must be "open" or "closed" (got "${cell("status")}")`);
+      rowErrors.push(
+        `status must be "open" or "closed" (got "${cell("status")}")`,
+      );
     }
 
     // Cross-field checks need all three dates to be individually valid.
-    if (accidentDate !== null && reportDate !== null && evaluationDate !== null) {
-      if (reportDate < accidentDate) rowErrors.push("report_date precedes accident_date");
-      if (evaluationDate < reportDate) rowErrors.push("evaluation_date precedes report_date");
+    if (
+      accidentDate !== null &&
+      reportDate !== null &&
+      evaluationDate !== null
+    ) {
+      if (reportDate < accidentDate)
+        rowErrors.push("report_date precedes accident_date");
+      if (evaluationDate < reportDate)
+        rowErrors.push("evaluation_date precedes report_date");
     }
 
     if (rowErrors.length > 0) {

package/src/review.ts

@@ -1,4 +1,8 @@
-import type { ClaimSnapshot, Triangle } from "@actuarial-ts/core";
+import {
+  isRealIsoDate,
+  type ClaimSnapshot,
+  type Triangle,
+} from "@actuarial-ts/core";
 
 /**
  * ASOP No. 23 (Data Quality)-oriented data review.
@@ -25,12 +29,25 @@ import type { ClaimSnapshot, Triangle } from "@actuarial-ts/core";
 export type DataCheckStatus = "pass" | "warning" | "fail" | "not-evaluated";
 
 export interface DataFindingContext {
+  ruleId?: string;
+  measureId?: string;
+  expressionPath?: string;
+  offendingKey?: string;
+  groupingKey?: string;
+  cachedEvidenceId?: string;
+  sourceGroup?: string;
   origin?: string;
   valuation?: string;
-  ageMonths?: number;
+  developmentAge?: number;
+  ageUnit?: string;
+  recordId?: string;
+  claimId?: string;
+  exposureKey?: string;
   group?: string;
   sourceFile?: string;
   sourceRow?: number;
+  sources?: readonly import("@actuarial-ts/core").DiagnosticSourceLocation[];
+  reviewScope?: import("@actuarial-ts/core").DiagnosticReviewEvaluationScope;
 }
 
 export interface DataFinding {
@@ -46,12 +63,17 @@ export interface DataCheck {
   status: DataCheckStatus;
   details: string[];
   /** Additive structured detail for consumers that should not parse prose. */
-  findings?: DataFinding[];
+  findings: DataFinding[];
 }
 
 export interface DataReviewReport {
   checks: DataCheck[];
-  summary: { pass: number; warning: number; fail: number; notEvaluated: number };
+  summary: {
+    pass: number;
+    warning: number;
+    fail: number;
+    notEvaluated: number;
+  };
 }
 
 export interface ReviewClaimDataOptions {
@@ -64,7 +86,10 @@ const MAX_DETAILS = 20;
 
 function capDetails(items: string[]): string[] {
   if (items.length <= MAX_DETAILS) return items;
-  return [...items.slice(0, MAX_DETAILS), `+${items.length - MAX_DETAILS} more`];
+  return [
+    ...items.slice(0, MAX_DETAILS),
+    `+${items.length - MAX_DETAILS} more`,
+  ];
 }
 
 function makeCheck(
@@ -78,13 +103,24 @@ function makeCheck(
     description,
     status: findings.length > 0 ? statusWhenFound : "pass",
     details: capDetails(findings),
+    findings: [],
   };
 }
 
-function notEvaluated(id: string, description: string, reason: string): DataCheck {
+function notEvaluated(
+  id: string,
+  description: string,
+  reason: string,
+): DataCheck {
   // A check that could not run is REPORTED as such - counting it as "pass"
   // would overstate the review in the very disclosure this feeds.
-  return { id, description, status: "not-evaluated", details: [`not evaluated: ${reason}`] };
+  return {
+    id,
+    description,
+    status: "not-evaluated",
+    details: [`not evaluated: ${reason}`],
+    findings: [],
+  };
 }
 
 function summarize(checks: DataCheck[]): DataReviewReport {
@@ -103,15 +139,19 @@ export function createStructuredDataCheck(
   statusWhenFound: "warning" | "fail",
   findings: readonly DataFinding[],
 ): DataCheck {
-  const capped = findings.length <= MAX_DETAILS ? [...findings] : [...findings.slice(0, MAX_DETAILS)];
+  const capped =
+    findings.length <= MAX_DETAILS
+      ? [...findings]
+      : [...findings.slice(0, MAX_DETAILS)];
   const details = capped.map((finding) => finding.message);
-  if (findings.length > MAX_DETAILS) details.push(`+${findings.length - MAX_DETAILS} more`);
+  if (findings.length > MAX_DETAILS)
+    details.push(`+${findings.length - MAX_DETAILS} more`);
   return {
     id,
     description,
     status: findings.length > 0 ? statusWhenFound : "pass",
     details,
-    findings: capped,
+    findings: [...findings],
   };
 }
 
@@ -130,13 +170,19 @@ export function createNotEvaluatedDataCheck(
 }
 
 const CLAIM_DESCRIPTIONS = {
-  "non-finite-value": "Every money field is a finite number (no NaN or Infinity)",
+  "non-finite-value":
+    "Every money field is a finite number (no NaN or Infinity)",
   "negative-paid": "Cumulative paid amounts are non-negative",
-  "negative-case": "Case reserves are non-negative (negative case is legitimate but rare)",
+  "negative-case":
+    "Case reserves are non-negative (negative case is legitimate but rare)",
   "paid-decreasing":
     "Cumulative paid never decreases across a claim's snapshots ordered by evaluation date",
-  "date-order": "accident_date <= report_date <= evaluation_date on every snapshot",
-  "duplicate-snapshot": "No claim has two snapshots at the same evaluation date",
+  "date-order":
+    "accident_date <= report_date <= evaluation_date on every snapshot",
+  "duplicate-snapshot":
+    "No claim has two snapshots at the same evaluation date",
+  "claim-identity":
+    "Every snapshot for one claim has the same accident and report identity",
   "future-dated": "No claim date exceeds the as-of date",
   "closed-with-case": "Closed claims carry no outstanding case reserve",
 } as const;
@@ -160,6 +206,16 @@ export function reviewClaimData(
     // pointed auditors at the wrong line; an identifier we cannot compute is
     // one we must not print.
     const where = `claim ${c.claimId} (eval ${c.evaluationDate})`;
+    for (const [name, value] of [
+      ["accident_date", c.accidentDate],
+      ["report_date", c.reportDate],
+      ["evaluation_date", c.evaluationDate],
+    ] as const) {
+      if (!isRealIsoDate(value))
+        dateOrder.push(
+          `${where}: ${name} is not a real yyyy-mm-dd calendar date`,
+        );
+    }
     if (c.paidToDate < 0) {
       negativePaid.push(`${where}: paid_to_date ${c.paidToDate}`);
     }
@@ -179,17 +235,25 @@ export function reviewClaimData(
     if (opts.asOfDate !== undefined) {
       const asOf = opts.asOfDate;
       if (c.accidentDate > asOf) {
-        futureDated.push(`${where}: accident_date ${c.accidentDate} exceeds as-of ${asOf}`);
+        futureDated.push(
+          `${where}: accident_date ${c.accidentDate} exceeds as-of ${asOf}`,
+        );
       }
       if (c.reportDate > asOf) {
-        futureDated.push(`${where}: report_date ${c.reportDate} exceeds as-of ${asOf}`);
+        futureDated.push(
+          `${where}: report_date ${c.reportDate} exceeds as-of ${asOf}`,
+        );
       }
       if (c.evaluationDate > asOf) {
-        futureDated.push(`${where}: evaluation_date ${c.evaluationDate} exceeds as-of ${asOf}`);
+        futureDated.push(
+          `${where}: evaluation_date ${c.evaluationDate} exceeds as-of ${asOf}`,
+        );
       }
     }
     if (c.status === "closed" && c.caseReserve > 0) {
-      closedWithCase.push(`${where}: case_reserve ${c.caseReserve} on a closed claim`);
+      closedWithCase.push(
+        `${where}: case_reserve ${c.caseReserve} on a closed claim`,
+      );
     }
   });
 
@@ -202,12 +266,24 @@ export function reviewClaimData(
   }
   const paidDecreasing: string[] = [];
   const duplicates: string[] = [];
+  const identityConflicts: string[] = [];
   for (const [claimId, snaps] of byClaim) {
-    const sorted = [...snaps].sort((a, b) => a.evaluationDate.localeCompare(b.evaluationDate));
+    const identities = new Set(
+      snaps.map((snap) => `${snap.accidentDate}|${snap.reportDate}`),
+    );
+    if (identities.size > 1)
+      identityConflicts.push(
+        `claim ${claimId}: snapshots contain conflicting accident_date or report_date values`,
+      );
+    const sorted = [...snaps].sort((a, b) =>
+      a.evaluationDate.localeCompare(b.evaluationDate),
+    );
     const seenEvals = new Set<string>();
     for (const s of sorted) {
       if (seenEvals.has(s.evaluationDate)) {
-        duplicates.push(`claim ${claimId}: duplicate snapshot at ${s.evaluationDate}`);
+        duplicates.push(
+          `claim ${claimId}: duplicate snapshot at ${s.evaluationDate}`,
+        );
       }
       seenEvals.add(s.evaluationDate);
     }
@@ -227,32 +303,87 @@ export function reviewClaimData(
   const nonFinite: string[] = [];
   for (const c of claims) {
     const where = `claim ${c.claimId}`;
-    if (!Number.isFinite(c.paidToDate)) nonFinite.push(`${where}: paid_to_date ${String(c.paidToDate)}`);
-    if (!Number.isFinite(c.caseReserve)) nonFinite.push(`${where}: case_reserve ${String(c.caseReserve)}`);
+    if (!Number.isFinite(c.paidToDate))
+      nonFinite.push(`${where}: paid_to_date ${String(c.paidToDate)}`);
+    if (!Number.isFinite(c.caseReserve))
+      nonFinite.push(`${where}: case_reserve ${String(c.caseReserve)}`);
   }
 
   const futureCheck =
     opts.asOfDate === undefined
-      ? notEvaluated("future-dated", CLAIM_DESCRIPTIONS["future-dated"], "no asOfDate provided")
-      : makeCheck("future-dated", CLAIM_DESCRIPTIONS["future-dated"], "fail", futureDated);
+      ? notEvaluated(
+          "future-dated",
+          CLAIM_DESCRIPTIONS["future-dated"],
+          "no asOfDate provided",
+        )
+      : makeCheck(
+          "future-dated",
+          CLAIM_DESCRIPTIONS["future-dated"],
+          "fail",
+          futureDated,
+        );
 
   return summarize([
     // First: if the numbers are not numbers, the other verdicts are noise.
-    makeCheck("non-finite-value", CLAIM_DESCRIPTIONS["non-finite-value"], "fail", nonFinite),
-    makeCheck("negative-paid", CLAIM_DESCRIPTIONS["negative-paid"], "fail", negativePaid),
-    makeCheck("negative-case", CLAIM_DESCRIPTIONS["negative-case"], "warning", negativeCase),
-    makeCheck("paid-decreasing", CLAIM_DESCRIPTIONS["paid-decreasing"], "fail", paidDecreasing),
-    makeCheck("date-order", CLAIM_DESCRIPTIONS["date-order"], "fail", dateOrder),
-    makeCheck("duplicate-snapshot", CLAIM_DESCRIPTIONS["duplicate-snapshot"], "fail", duplicates),
+    makeCheck(
+      "non-finite-value",
+      CLAIM_DESCRIPTIONS["non-finite-value"],
+      "fail",
+      nonFinite,
+    ),
+    makeCheck(
+      "negative-paid",
+      CLAIM_DESCRIPTIONS["negative-paid"],
+      "fail",
+      negativePaid,
+    ),
+    makeCheck(
+      "negative-case",
+      CLAIM_DESCRIPTIONS["negative-case"],
+      "warning",
+      negativeCase,
+    ),
+    makeCheck(
+      "paid-decreasing",
+      CLAIM_DESCRIPTIONS["paid-decreasing"],
+      "fail",
+      paidDecreasing,
+    ),
+    makeCheck(
+      "date-order",
+      CLAIM_DESCRIPTIONS["date-order"],
+      "fail",
+      dateOrder,
+    ),
+    makeCheck(
+      "duplicate-snapshot",
+      CLAIM_DESCRIPTIONS["duplicate-snapshot"],
+      "fail",
+      duplicates,
+    ),
+    makeCheck(
+      "claim-identity",
+      CLAIM_DESCRIPTIONS["claim-identity"],
+      "fail",
+      identityConflicts,
+    ),
     futureCheck,
-    makeCheck("closed-with-case", CLAIM_DESCRIPTIONS["closed-with-case"], "warning", closedWithCase),
+    makeCheck(
+      "closed-with-case",
+      CLAIM_DESCRIPTIONS["closed-with-case"],
+      "warning",
+      closedWithCase,
+    ),
   ]);
 }
 
 const TRIANGLE_DESCRIPTIONS = {
-  "non-finite-value": "Every observed cell is a finite number (no NaN or Infinity)",
-  "shape-mismatch": "Paid and incurred triangles share the same origins and ages",
-  "paid-exceeds-incurred": "Paid never exceeds incurred in any cell (1e-9 relative tolerance)",
+  "non-finite-value":
+    "Every observed cell is a finite number (no NaN or Infinity)",
+  "shape-mismatch":
+    "Paid and incurred triangles share the same origins and ages",
+  "paid-exceeds-incurred":
+    "Paid never exceeds incurred in any cell (1e-9 relative tolerance)",
   "negative-incremental-paid":
     "Cumulative paid is non-decreasing along each origin row (salvage/subrogation can legitimately violate this)",
   "negative-incremental-incurred":
@@ -275,7 +406,9 @@ function nonFiniteTriangleFindings(tri: Triangle): string[] {
       const v = row[j];
       if (v === null || v === undefined) continue;
       if (!Number.isFinite(v)) {
-        out.push(`${tri.kind} ${tri.origins[i]} age ${tri.ages[j]}: ${String(v)}`);
+        out.push(
+          `${tri.kind} ${tri.origins[i]} age ${tri.ages[j]}: ${String(v)}`,
+        );
       }
     }
   }
@@ -319,7 +452,9 @@ function interiorMissingFindings(tri: Triangle): string[] {
     if (first === -1) continue;
     for (let j = first + 1; j < last; j++) {
       if (!observed[j]) {
-        out.push(`${tri.kind} ${tri.origins[i]} age ${tri.ages[j]}: interior cell missing`);
+        out.push(
+          `${tri.kind} ${tri.origins[i]} age ${tri.ages[j]}: interior cell missing`,
+        );
       }
     }
   }
@@ -327,7 +462,10 @@ function interiorMissingFindings(tri: Triangle): string[] {
 }
 
 /** Reviews a paid/incurred triangle pair for cross-triangle consistency. */
-export function reviewTriangles(paid: Triangle, incurred: Triangle): DataReviewReport {
+export function reviewTriangles(
+  paid: Triangle,
+  incurred: Triangle,
+): DataReviewReport {
   const shapeFindings: string[] = [];
   const sameOrigins =
     paid.origins.length === incurred.origins.length &&
@@ -349,7 +487,10 @@ export function reviewTriangles(paid: Triangle, incurred: Triangle): DataReviewR
     "non-finite-value",
     TRIANGLE_DESCRIPTIONS["non-finite-value"],
     "fail",
-    [...nonFiniteTriangleFindings(paid), ...nonFiniteTriangleFindings(incurred)],
+    [
+      ...nonFiniteTriangleFindings(paid),
+      ...nonFiniteTriangleFindings(incurred),
+    ],
   );
   const shapeCheck = makeCheck(
     "shape-mismatch",
@@ -364,7 +505,11 @@ export function reviewTriangles(paid: Triangle, incurred: Triangle): DataReviewR
     return summarize([
       nonFiniteCheck,
       shapeCheck,
-      notEvaluated("paid-exceeds-incurred", TRIANGLE_DESCRIPTIONS["paid-exceeds-incurred"], reason),
+      notEvaluated(
+        "paid-exceeds-incurred",
+        TRIANGLE_DESCRIPTIONS["paid-exceeds-incurred"],
+        reason,
+      ),
       notEvaluated(
         "negative-incremental-paid",
         TRIANGLE_DESCRIPTIONS["negative-incremental-paid"],
@@ -375,7 +520,11 @@ export function reviewTriangles(paid: Triangle, incurred: Triangle): DataReviewR
         TRIANGLE_DESCRIPTIONS["negative-incremental-incurred"],
         reason,
       ),
-      notEvaluated("interior-missing", TRIANGLE_DESCRIPTIONS["interior-missing"], reason),
+      notEvaluated(
+        "interior-missing",
+        TRIANGLE_DESCRIPTIONS["interior-missing"],
+        reason,
+      ),
     ]);
   }
 
@@ -386,10 +535,13 @@ export function reviewTriangles(paid: Triangle, incurred: Triangle): DataReviewR
     for (let j = 0; j < paidRow.length; j++) {
       const p = paidRow[j];
       const inc = incRow[j];
-      if (p === null || p === undefined || inc === null || inc === undefined) continue;
+      if (p === null || p === undefined || inc === null || inc === undefined)
+        continue;
       const tolerance = 1e-9 * Math.max(1, Math.abs(p), Math.abs(inc));
       if (p - inc > tolerance) {
-        paidExceeds.push(`${paid.origins[i]} age ${paid.ages[j]}: paid ${p} > incurred ${inc}`);
+        paidExceeds.push(
+          `${paid.origins[i]} age ${paid.ages[j]}: paid ${p} > incurred ${inc}`,
+        );
       }
     }
   }

package/src/version.ts

@@ -0,0 +1 @@
+export const DATA_PACKAGE_VERSION = "0.6.1";