@actuarial-ts/core 0.10.0 → 0.12.0

package/src/diagnosticKeys.ts

@@ -0,0 +1,22 @@
+import { canonicalJson } from "./canonical.js";
+
+/**
+ * `canonicalJson` for a flat array of JSON scalars through the native
+ * serializer. Arrays keep their order and each finite number, string, boolean
+ * and null has exactly one canonical rendering, so the text is byte-identical
+ * to `canonicalJson(values)`. Any other element defers to `canonicalJson`,
+ * including its errors, so callers keep the same contract on every input.
+ */
+export function canonicalScalarArrayJson(values: readonly unknown[]): string {
+  for (const value of values) {
+    if (
+      typeof value === "string" ||
+      typeof value === "boolean" ||
+      value === null ||
+      (typeof value === "number" && Number.isFinite(value))
+    )
+      continue;
+    return canonicalJson(values);
+  }
+  return JSON.stringify(values);
+}

package/src/diagnosticOrdering.ts

@@ -77,15 +77,17 @@ export function compareDiagnosticFindings(
   );
 }
 
+// Tuple comparisons are written out field by field: the section 15 order of two
+// equal-length tuples is exactly the first non-zero field comparison, and this
+// avoids allocating two arrays for every comparison inside large sorts.
 export function compareDiagnosticContributions(
   left: DiagnosticMeasureContribution,
   right: DiagnosticMeasureContribution,
 ): number {
   return (
-    compareDiagnosticIdentityValues(
-      [left.sourceId, left.status, left.deduplicated],
-      [right.sourceId, right.status, right.deduplicated],
-    ) ||
+    compareDiagnosticIdentityValues(left.sourceId, right.sourceId) ||
+    compareDiagnosticIdentityValues(left.status, right.status) ||
+    compareDiagnosticIdentityValues(left.deduplicated, right.deduplicated) ||
     compareSources(left.sources, right.sources) ||
     compareDiagnosticIdentityValues(left, right)
   );
@@ -96,10 +98,9 @@ export function compareDiagnosticBlockers(
   right: DiagnosticStructuralBlocker,
 ): number {
   return (
-    compareDiagnosticIdentityValues(
-      [left.code, left.message, left.sourceIds],
-      [right.code, right.message, right.sourceIds],
-    ) ||
+    compareDiagnosticIdentityValues(left.code, right.code) ||
+    compareDiagnosticIdentityValues(left.message, right.message) ||
+    compareDiagnosticIdentityValues(left.sourceIds, right.sourceIds) ||
     compareSources(left.sources, right.sources) ||
     compareDiagnosticIdentityValues(left.finding, right.finding)
   );

package/src/diagnosticPeriods.ts

@@ -14,11 +14,28 @@ export interface DiagnosticNormalizedPeriod {
   readonly coordinate: number;
 }
 
+// Labels repeat across every row, cell and query of a definition, and each
+// normalized period is an immutable value. Cache per axis object and side,
+// bounded so adversarial label streams cannot grow the tables without limit.
+const MAX_MEMOIZED_LABELS = 100_000;
+const normalizedByAxis = new WeakMap<
+  DiagnosticPeriodAxis,
+  Record<DiagnosticPeriodSide, Map<string, DiagnosticNormalizedPeriod>>
+>();
+
 function normalizeWithAxis(
   axis: DiagnosticPeriodAxis,
   side: DiagnosticPeriodSide,
   label: string,
 ): DiagnosticNormalizedPeriod {
+  let tables = normalizedByAxis.get(axis);
+  if (!tables) {
+    tables = { origin: new Map(), valuation: new Map() };
+    normalizedByAxis.set(axis, tables);
+  }
+  const table = tables[side];
+  const cached = table.get(label);
+  if (cached !== undefined) return cached;
   const normalized = normalizeDiagnosticPeriodWithAxis(axis, side, label);
   if (!normalized)
     throw new DiagnosticValidationError([
@@ -32,7 +49,10 @@ function normalizeWithAxis(
             : `Unknown ordered-axis ${side} label ${JSON.stringify(label)}`,
       },
     ]);
-  return Object.freeze(normalized);
+  const frozen = Object.freeze(normalized);
+  if (table.size >= MAX_MEMOIZED_LABELS) table.clear();
+  table.set(label, frozen);
+  return frozen;
 }
 
 export function normalizeDiagnosticPeriod(