@actuarial-ts/core 0.7.1 → 0.8.0

package/src/reservingAdapter.ts

@@ -0,0 +1,98 @@
+import type {
+  AnalysisMeasureDefinitionV1,
+  AnalysisResult,
+  AnalysisTriangleAdapterResult,
+  CustomizationCapabilityFinding,
+  HistoricalScalar,
+} from "./customizationContracts.js";
+import { snapshotDiagnosticJson } from "./diagnosticRuntime.js";
+import type { TriangleKind } from "./types.js";
+
+function finding(message: string, code: CustomizationCapabilityFinding["code"] = "incompatible-semantics"): CustomizationCapabilityFinding {
+  return {
+    code,
+    capability: "reserving-triangle-adapter",
+    path: "$.values.coordinates",
+    message,
+  };
+}
+
+function unavailable(message: string, code?: CustomizationCapabilityFinding["code"]): AnalysisTriangleAdapterResult {
+  return snapshotDiagnosticJson({ status: "unavailable", triangle: null, findings: [finding(message, code)] });
+}
+
+function scalarEqual(left: HistoricalScalar | undefined, right: HistoricalScalar): boolean {
+  return left === right || (typeof left === "number" && typeof right === "number" && Object.is(left, right));
+}
+
+/**
+ * Adapts one explicitly selected cumulative result slice to the legacy
+ * reserving triangle shape. Every non-axis coordinate must be fixed by the
+ * caller, so the adapter never combines or silently discards result cells.
+ */
+export function adaptAnalysisResultToTriangle(input: {
+  readonly result: AnalysisResult;
+  readonly measure: AnalysisMeasureDefinitionV1;
+  readonly triangleKind: TriangleKind;
+  readonly originCoordinate: string;
+  readonly developmentAgeCoordinate: string;
+  readonly slice: Readonly<Record<string, HistoricalScalar>>;
+}): AnalysisTriangleAdapterResult {
+  if (input.measure.developmentSemantics !== "cumulative")
+    return unavailable("A reserving triangle requires a cumulative measure");
+  if (input.measure.statistic.kind !== "sum")
+    return unavailable("The reserving triangle adapter supports direct sum measures only");
+  if (input.originCoordinate === input.developmentAgeCoordinate)
+    return unavailable("Origin and development-age coordinates must be distinct", "invalid-configuration");
+  if (Object.hasOwn(input.slice, input.originCoordinate) || Object.hasOwn(input.slice, input.developmentAgeCoordinate))
+    return unavailable("The result slice cannot fix either triangle axis", "invalid-configuration");
+
+  const candidates = input.result.values.filter((value) =>
+    value.measureId === input.measure.id &&
+    Object.entries(input.slice).every(([key, expected]) => scalarEqual(value.coordinates[key], expected)),
+  );
+  if (candidates.length === 0)
+    return unavailable("No result values match the requested measure and coordinate slice", "missing-prerequisite");
+
+  const allowedCoordinates = new Set([
+    input.originCoordinate,
+    input.developmentAgeCoordinate,
+    ...Object.keys(input.slice),
+  ]);
+  for (const value of candidates) {
+    const extra = Object.keys(value.coordinates).filter((key) => !allowedCoordinates.has(key));
+    if (extra.length > 0)
+      return unavailable(`Every non-axis coordinate must be fixed in slice; unresolved: ${extra.join(", ")}`);
+    const origin = value.coordinates[input.originCoordinate];
+    const age = value.coordinates[input.developmentAgeCoordinate];
+    if (typeof origin !== "string" || origin.length === 0)
+      return unavailable("Every selected value requires a nonempty string origin coordinate", "missing-prerequisite");
+    if (typeof age !== "number" || !Number.isSafeInteger(age) || age < 0)
+      return unavailable("Every selected value requires a nonnegative safe-integer development age in months", "missing-prerequisite");
+  }
+
+  const origins = [...new Set(candidates.map((value) => value.coordinates[input.originCoordinate] as string))].sort();
+  const ages = [...new Set(candidates.map((value) => value.coordinates[input.developmentAgeCoordinate] as number))].sort((a, b) => a - b);
+  const cells = new Map<string, number | null>();
+  for (const value of candidates) {
+    const origin = value.coordinates[input.originCoordinate] as string;
+    const age = value.coordinates[input.developmentAgeCoordinate] as number;
+    const key = `${origin}\u0000${age}`;
+    if (cells.has(key))
+      return unavailable(`Multiple result values map to triangle cell ${origin}/${age}`);
+    if (value.status === "available" && (typeof value.value !== "number" || !Number.isFinite(value.value)))
+      return unavailable(`Available result value for ${origin}/${age} is not finite`, "invalid-configuration");
+    cells.set(key, value.status === "available" ? value.value : null);
+  }
+
+  return snapshotDiagnosticJson({
+    status: "available",
+    triangle: {
+      kind: input.triangleKind,
+      origins,
+      ages,
+      values: origins.map((origin) => ages.map((age) => cells.get(`${origin}\u0000${age}`) ?? null)),
+    },
+    findings: [],
+  });
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 /** This package's runtime version. A test pins it to package.json. */
-export const CORE_PACKAGE_VERSION = "0.7.1";
+export const CORE_PACKAGE_VERSION = "0.8.0";