@actuarial-ts/core 0.10.0 → 0.11.0

package/src/diagnosticReview.ts

@@ -2,12 +2,14 @@ import {
   getCompiledDiagnosticDefinitionInternals,
   type DiagnosticControlTotalProjection,
   type DiagnosticDeepReadonly,
+  type DiagnosticMeasureStats,
   type DiagnosticReviewFilter,
   type DiagnosticReviewRule,
   type DiagnosticSourceLocation,
 } from "./diagnosticDefinitions.js";
 import type { NormalizedDiagnosticReviewFilterIdentity } from "./diagnosticIdentity.js";
 import { canonicalJson } from "./canonical.js";
+import { canonicalScalarArrayJson } from "./diagnosticKeys.js";
 import { createDiagnosticReviewSourcePool } from "./diagnosticReviewSources.js";
 import { createDiagnosticEvidenceInterner } from "./diagnosticEvidenceIntern.js";
 import { normalizeDiagnosticPeriod } from "./diagnosticPeriods.js";
@@ -15,6 +17,7 @@ import {
   evaluateDiagnosticMeasureExpression,
   type FinalizedDiagnosticMeasure,
 } from "./diagnosticFormulas.js";
+import { hasDiagnosticOwn } from "./diagnosticRuntime.js";
 import {
   assertPreparedDiagnosticData,
   assertCompactPreparedDiagnosticData,
@@ -128,6 +131,12 @@ interface EvaluatedOperand {
   readonly sources: readonly DiagnosticSourceLocation[];
 }
 
+// Shared immutable empties for the overwhelmingly common clean cell: readers
+// only iterate or spread these, and every retained evaluation owns fresh arrays.
+const NO_REASONS: readonly DiagnosticRuleNotEvaluatedReason[] = Object.freeze([]);
+const NO_REVIEW_OVERFLOWS: readonly DiagnosticReviewExpressionOverflow[] = Object.freeze([]);
+const NO_SOURCES: readonly DiagnosticSourceLocation[] = Object.freeze([]);
+
 const REASON_ORDER: readonly DiagnosticRuleNotEvaluatedReason[] = [
   "missing",
   "imputed",
@@ -184,46 +193,66 @@ function expressionLeafPaths(
   ];
 }
 
+// A projected state depends only on its measure's definition and the cell's
+// statistics record, and preparation shares equal statistics records across
+// cells, so one projection per (measure, record) serves every cell holding it.
+// The cache lives in one review invocation, so no projection crosses
+// preparations or definitions. Bounded like the interner.
+const MAX_CACHED_STATES = 100_000;
+type StateCache = Map<string, Map<DiagnosticMeasureStats, FinalizedDiagnosticMeasure>>;
+
 function states(
   prepared: PreparedDiagnosticDataContent,
   cell: PreparedDiagnosticData["cells"][number],
+  cache: StateCache,
 ): Record<string, FinalizedDiagnosticMeasure> {
   const internals = getCompiledDiagnosticDefinitionInternals(
     prepared.definition,
   );
-  return Object.fromEntries(
-    Object.entries(cell.components).map(([id, stats]) => {
+  const result: Record<string, FinalizedDiagnosticMeasure> = {};
+  const ids = Object.keys(cell.components);
+  let cached = 0;
+  for (let index = 0; index < ids.length; index++) {
+    const id = ids[index]!;
+    const stats = cell.components[id]!;
+    let byStats = cache.get(id);
+    if (byStats === undefined) {
+      byStats = new Map();
+      cache.set(id, byStats);
+    }
+    let state = byStats.get(stats);
+    if (state === undefined) {
       const measure = internals.measuresById.get(id)!;
-      const readiness: DiagnosticRuleNotEvaluatedReason[] = [];
+      let readiness: DiagnosticRuleNotEvaluatedReason[] | undefined;
       if (stats.missing)
-        readiness.push(stats.imputedZero ? "imputed" : "missing");
-      if (stats.nonFinite) readiness.push("non-finite");
-      if (stats.structural) readiness.push("structural-ambiguity");
+        (readiness ??= []).push(stats.imputedZero ? "imputed" : "missing");
+      if (stats.nonFinite) (readiness ??= []).push("non-finite");
+      if (stats.structural) (readiness ??= []).push("structural-ambiguity");
       if (stats.sum === null && !stats.nonFinite && !stats.structural)
-        readiness.push("aggregation-overflow");
-      return [
-        id,
-        {
-          quantity: {
-            kind: measure.kind,
-            unit: measure.unit,
-            ...(measure.basisId ? { basisId: measure.basisId } : {}),
-            ...(measure.countPopulationId
-              ? { countPopulationId: measure.countPopulationId }
-              : {}),
-            ...(measure.exposureBasisId
-              ? { exposureBasisId: measure.exposureBasisId }
-              : {}),
-            value: stats.value,
-          },
-          stats,
-          readiness,
-          // Cell expressions attach complete leaf-source evidence separately.
-          // Per-measure source lists here would be discarded and rebuilt.
-        },
-      ];
-    }),
-  );
+        (readiness ??= []).push("aggregation-overflow");
+      const quantity: Record<string, unknown> = {
+        kind: measure.kind,
+        unit: measure.unit,
+      };
+      if (measure.basisId) quantity.basisId = measure.basisId;
+      if (measure.countPopulationId)
+        quantity.countPopulationId = measure.countPopulationId;
+      if (measure.exposureBasisId)
+        quantity.exposureBasisId = measure.exposureBasisId;
+      quantity.value = stats.value;
+      state = {
+        quantity: quantity as unknown as FinalizedDiagnosticMeasure["quantity"],
+        stats,
+        readiness: readiness ?? NO_REASONS,
+        // Cell expressions attach complete leaf-source evidence separately.
+        // Per-measure source lists here would be discarded and rebuilt.
+      };
+      cached += byStats.size;
+      if (cached < MAX_CACHED_STATES) byStats.set(stats, state);
+    }
+    result[id] = state;
+  }
+  return result;
 }
 
 function coordinate(
@@ -300,18 +329,32 @@ function cellSourcesForSelection(
 }
 
 /** Compact-only, invocation-owned caches. Never retain these on a prepared cell. */
-function createCompactCellSourceReader() {
+function createCompactCellSourceReader(cellCount: number) {
   const pool = createDiagnosticReviewSourcePool();
   const addCellSources = (
     target: ReturnType<typeof pool.collection>,
     cell: PreparedDiagnosticData["cells"][number],
     ids: readonly string[],
   ): void => {
-    for (const id of ids) {
-      for (const contribution of cell.contributions[id] ?? [])
-        for (const source of contribution.sources) target.add(source, true);
-      for (const blocker of cell.structuralBlockers[id] ?? [])
-        for (const source of blocker.sources) target.add(source, true);
+    // Preparation cites one frozen list per source row across its measures;
+    // adding the same list again is a no-op, so skip it by identity.
+    let previous: readonly DiagnosticSourceLocation[] | undefined;
+    for (let position = 0; position < ids.length; position++) {
+      const id = ids[position]!;
+      const contributions = cell.contributions[id];
+      if (contributions !== undefined)
+        for (let index = 0; index < contributions.length; index++) {
+          const sources = contributions[index]!.sources;
+          if (sources === previous) continue;
+          previous = sources;
+          for (let at = 0; at < sources.length; at++) target.add(sources[at]!, true);
+        }
+      const blockers = cell.structuralBlockers[id];
+      if (blockers !== undefined)
+        for (let index = 0; index < blockers.length; index++) {
+          const sources = blockers[index]!.sources;
+          for (let at = 0; at < sources.length; at++) target.add(sources[at]!, true);
+        }
     }
   };
   const forSelection = (
@@ -324,11 +367,33 @@ function createCompactCellSourceReader() {
     return target.finish();
   };
   const dependencies = new WeakMap<object, readonly string[]>();
-  const dependencyKeys = new WeakMap<object, string>();
-  const byCell = new WeakMap<
-    PreparedDiagnosticData["cells"][number],
-    Map<string, readonly DiagnosticSourceLocation[]>
-  >();
+  // Distinct dependency subsets are few (one per rule expression); each gets a
+  // small index, and equal subsets from different expressions share it.
+  const subsetIndexByKey = new Map<string, number>();
+  const subsetIndexByIds = new Map<readonly string[], number>();
+  // Invocation-scoped like the pool: cached lists live in flat arrays indexed
+  // by subset and cell position, released with this reader and never attached
+  // to a prepared cell.
+  const listsBySubset: ((readonly DiagnosticSourceLocation[] | undefined)[])[] = [];
+  const subsetIndex = (ids: readonly string[]): number => {
+    let index = subsetIndexByIds.get(ids);
+    if (index === undefined) {
+      const key = canonicalJson(ids);
+      index = subsetIndexByKey.get(key);
+      if (index === undefined) {
+        index = listsBySubset.length;
+        listsBySubset.push(new Array(cellCount));
+        subsetIndexByKey.set(key, index);
+      }
+      subsetIndexByIds.set(ids, index);
+    }
+    return index;
+  };
+  // The one citation list most of a cell's subsets resolve to, and its owned list.
+  const cellSingletons: (
+    | { readonly cited: readonly DiagnosticSourceLocation[]; readonly list: readonly DiagnosticSourceLocation[] }
+    | undefined
+  )[] = new Array(cellCount);
   const measureIds = (
     expression: import("./diagnosticExpressions.js").DiagnosticMeasureExpression,
   ): readonly string[] => {
@@ -341,24 +406,46 @@ function createCompactCellSourceReader() {
   };
   const forCell = (
     cell: PreparedDiagnosticData["cells"][number],
+    cellIndex: number,
     ids: readonly string[],
   ): readonly DiagnosticSourceLocation[] => {
-    let key = dependencyKeys.get(ids);
-    if (key === undefined) {
-      key = canonicalJson(ids);
-      dependencyKeys.set(ids, key);
-    }
-    let subsets = byCell.get(cell);
-    if (!subsets) {
-      subsets = new Map();
-      byCell.set(cell, subsets);
-    }
-    let sources = subsets.get(key);
+    const lists = listsBySubset[subsetIndex(ids)]!;
+    let sources = lists[cellIndex];
     if (!sources) {
-      const target = pool.collection();
-      addCellSources(target, cell, ids);
-      sources = target.finish();
-      subsets.set(key, sources);
+      // Most subsets cite exactly one citation list of one prepared source
+      // (the cell's single row) and no blockers: resolve that list directly.
+      // Any other shape goes through the general collection.
+      let only: readonly DiagnosticSourceLocation[] | null | undefined;
+      for (let position = 0; position < ids.length && only !== null; position++) {
+        const id = ids[position]!;
+        const contributions = cell.contributions[id];
+        if (contributions !== undefined)
+          for (let index = 0; index < contributions.length; index++) {
+            const cited = contributions[index]!.sources;
+            if (only === undefined) only = cited;
+            else if (only !== cited) {
+              only = null;
+              break;
+            }
+          }
+        const blockers = cell.structuralBlockers[id];
+        if (blockers !== undefined && blockers.length > 0) only = null;
+      }
+      if (only === undefined) sources = pool.emptyList;
+      else if (only !== null && only.length === 1) {
+        const cached = cellSingletons[cellIndex];
+        if (cached !== undefined && cached.cited === only) sources = cached.list;
+        else {
+          sources = pool.singletonForPrepared(only[0]!);
+          cellSingletons[cellIndex] = { cited: only, list: sources };
+        }
+      } else if (only !== null && only.length === 0) sources = pool.emptyList;
+      else {
+        const target = pool.collection();
+        addCellSources(target, cell, ids);
+        sources = target.finish();
+      }
+      lists[cellIndex] = sources;
     }
     return sources;
   };
@@ -377,45 +464,174 @@ function createCellExpressionEvaluator(
   // Reuse projections across this review's rules, then release them before the
   // receipt identity is constructed. Retaining a prepared cell must not retain
   // this temporary bookkeeping or reuse another review's state.
-  const statesByCell = new WeakMap<
-    PreparedDiagnosticData["cells"][number],
-    Record<string, FinalizedDiagnosticMeasure>
-  >();
+  const statesByCell: (Record<string, FinalizedDiagnosticMeasure> | undefined)[] =
+    new Array(prepared.cells.length);
+  const stateCache: StateCache = new Map();
+  // Compact mode: the two operands of an evaluation are read and dropped, so
+  // one mutable operand per side is reused. The eager path keeps fresh objects.
+  const reusable: MutableOperand[] | undefined = compactSources
+    ? [
+        { value: null, reasons: NO_REASONS, overflows: NO_REVIEW_OVERFLOWS, sources: NO_SOURCES },
+        { value: null, reasons: NO_REASONS, overflows: NO_REVIEW_OVERFLOWS, sources: NO_SOURCES },
+      ]
+    : undefined;
+  const operand = (
+    slot: number,
+    value: number | null,
+    reasons: readonly DiagnosticRuleNotEvaluatedReason[],
+    overflows: readonly DiagnosticReviewExpressionOverflow[],
+    sources: readonly DiagnosticSourceLocation[],
+  ): EvaluatedOperand => {
+    if (reusable === undefined || slot < 0) return { value, reasons, overflows, sources };
+    const target = reusable[slot]!;
+    target.value = value;
+    target.reasons = reasons;
+    target.overflows = overflows;
+    target.sources = sources;
+    return target;
+  };
   return (
     cell: PreparedDiagnosticData["cells"][number],
+    cellIndex: number,
     expression: import("./diagnosticExpressions.js").DiagnosticMeasureExpression,
     path: string,
+    slot = -1,
   ): EvaluatedOperand => {
-    let measures = statesByCell.get(cell);
+    let measures = statesByCell[cellIndex];
     if (!measures) {
-      measures = states(prepared, cell);
-      statesByCell.set(cell, measures);
+      measures = states(prepared, cell, stateCache);
+      statesByCell[cellIndex] = measures;
+    }
+    const sources = compactSources
+      ? compactSources.forCell(cell, cellIndex, compactSources.measureIds(expression))
+      : cellSources(cell, expressionMeasureIds(expression));
+    // A measure leaf is read straight from the projected state: the generic
+    // evaluator would build the same result and hand it back unchanged.
+    if (expression.op === "measure") {
+      const state = hasDiagnosticOwn(measures, expression.measureId)
+        ? measures[expression.measureId]
+        : undefined;
+      if (state === undefined)
+        return operand(slot, null, ["missing"], NO_REVIEW_OVERFLOWS, sources);
+      const overflows = state.expressionOverflows;
+      return operand(
+        slot,
+        state.quantity.value,
+        state.readiness,
+        overflows === undefined || overflows.length === 0
+          ? NO_REVIEW_OVERFLOWS
+          : overflows.map((overflow) => ({ ...overflow, coordinate: coordinate(cell), sources })),
+        sources,
+      );
     }
     const result = evaluateDiagnosticMeasureExpression(
       expression,
       measures,
       path,
     );
-    const sources = compactSources
-      ? compactSources.forCell(cell, compactSources.measureIds(expression))
-      : cellSources(cell, expressionMeasureIds(expression));
-    return {
-      value: result.value,
-      reasons: result.reasons,
-      overflows: result.overflows.map((overflow) => ({
-        ...overflow,
-        coordinate: coordinate(cell),
-        sources,
-      })),
+    return operand(
+      slot,
+      result.value,
+      result.reasons,
+      result.overflows.length === 0
+        ? NO_REVIEW_OVERFLOWS
+        : result.overflows.map((overflow) => ({
+            ...overflow,
+            coordinate: coordinate(cell),
+            sources,
+          })),
       sources,
-    };
+    );
   };
 }
 
+interface MutableOperand {
+  value: number | null;
+  reasons: readonly DiagnosticRuleNotEvaluatedReason[];
+  overflows: readonly DiagnosticReviewExpressionOverflow[];
+  sources: readonly DiagnosticSourceLocation[];
+}
+
 function constant(value: number): EvaluatedOperand {
   return { value, reasons: [], overflows: [], sources: [] };
 }
 
+/**
+ * Compact-mode reuse. The compact builder copies every field it keeps from an
+ * evaluation record and its scope, so one mutable record, one cell scope and
+ * one valuation-pair scope per invocation can carry every evaluation to it.
+ * The eager path retains its records and never receives these.
+ */
+interface EvaluationScratch {
+  readonly record: {
+    ruleId: string;
+    ruleKind: DiagnosticReviewRule["kind"];
+    severity: "warning" | "fail";
+    scope: DiagnosticReviewEvaluationScope;
+    status: DiagnosticReviewRuleEvaluationBase["status"];
+    triggerReason: DiagnosticReviewRuleEvaluationBase["triggerReason"];
+    left: number | null;
+    right: number | null;
+    relation: DiagnosticReviewRuleEvaluationBase["relation"];
+    notEvaluatedReasons: readonly DiagnosticRuleNotEvaluatedReason[];
+    expressionOverflows: readonly DiagnosticReviewExpressionOverflow[];
+    comparability: unknown;
+  };
+  readonly cellScope: {
+    readonly kind: "cell";
+    cell: DiagnosticReviewCoordinate;
+    sources: readonly DiagnosticSourceLocation[];
+  };
+  readonly pairScope: {
+    readonly kind: "valuation-pair";
+    previous: DiagnosticReviewCoordinate;
+    current: DiagnosticReviewCoordinate;
+    sources: readonly DiagnosticSourceLocation[];
+  };
+  /** Constant operands by value; they are read, never retained. */
+  readonly constants: Map<number, EvaluatedOperand>;
+}
+function createEvaluationScratch(): EvaluationScratch {
+  const placeholder: DiagnosticReviewCoordinate = {
+    sourceGroup: "",
+    origin: "",
+    valuation: "",
+    developmentAge: 0,
+    ageUnit: "",
+  };
+  return {
+    record: {
+      ruleId: "",
+      ruleKind: "compare",
+      severity: "warning",
+      scope: { kind: "cell", cell: placeholder, sources: NO_SOURCES },
+      status: "pass",
+      triggerReason: null,
+      left: null,
+      right: null,
+      relation: null,
+      notEvaluatedReasons: NO_REASONS,
+      expressionOverflows: NO_REVIEW_OVERFLOWS,
+      comparability: undefined,
+    },
+    cellScope: { kind: "cell", cell: placeholder, sources: NO_SOURCES },
+    pairScope: { kind: "valuation-pair", previous: placeholder, current: placeholder, sources: NO_SOURCES },
+    constants: new Map(),
+  };
+}
+
+/** Empty lists owned by one review invocation; its evaluations may share them. */
+interface OwnedEmptyLists {
+  readonly reasons: readonly DiagnosticRuleNotEvaluatedReason[];
+  readonly overflows: readonly DiagnosticReviewExpressionOverflow[];
+}
+// One empty array serves both roles, exactly as the eager finalizer's interner
+// would merge equal frozen empties into a single shared instance.
+const freshEmptyLists = (): OwnedEmptyLists => {
+  const empty = Object.freeze([]) as readonly never[];
+  return { reasons: empty, overflows: empty };
+};
+
 function evaluation(
   prepared: PreparedDiagnosticDataContent,
   rule: DiagnosticReviewRule,
@@ -423,9 +639,11 @@ function evaluation(
   left: EvaluatedOperand,
   right: EvaluatedOperand,
   passes: (relation: "less" | "equal" | "greater") => boolean,
-  extraReasons: readonly DiagnosticRuleNotEvaluatedReason[] = [],
+  extraReasons: readonly DiagnosticRuleNotEvaluatedReason[] = NO_REASONS,
+  empty: OwnedEmptyLists = freshEmptyLists(),
+  scratch?: EvaluationScratch,
 ): DiagnosticReviewRuleEvaluation {
-  const expressionOverflows = [
+  const expressionOverflows = left.overflows.length === 0 && right.overflows.length === 0 ? [] : [
     ...new Map(
       [...left.overflows, ...right.overflows].map((item) => [
         canonicalJson(item),
@@ -475,88 +693,144 @@ function evaluation(
     }
     return a.sources.length - b.sources.length;
   });
-  const reasons = uniqueReasons([
-    ...left.reasons,
-    ...right.reasons,
-    ...extraReasons,
-    ...(expressionOverflows.length > 0 ? ["expression-overflow" as const] : []),
-    ...((left.value === null || right.value === null) &&
+  // Clean evaluated operands carry no reasons; skip the spread/filter round trip.
+  const reasons: readonly DiagnosticRuleNotEvaluatedReason[] =
     left.reasons.length === 0 &&
     right.reasons.length === 0 &&
-    expressionOverflows.length === 0
-      ? ["missing" as const]
-      : []),
-  ]);
-  const missingReason = (): DiagnosticReviewRuleEvaluation["triggerReason"] => {
-    if (
-      reasons.some((reason) =>
-        ["missing", "imputed", "non-finite", "structural-ambiguity"].includes(
-          reason,
-        ),
-      )
-    )
-      return "missing-input";
-    if (reasons.includes("aggregation-overflow")) return "aggregation-overflow";
-    if (reasons.includes("expression-overflow")) return "expression-overflow";
-    if (reasons.includes("tolerance-overflow")) return "tolerance-overflow";
-    return "missing-input";
-  };
-  const result = (
-    value: Omit<
-      DiagnosticReviewRuleEvaluationBase,
-      "ruleId" | "ruleKind" | "severity" | "scope"
-    >,
-  ): DiagnosticReviewRuleEvaluation =>
-    ({
-      ruleId: rule.id,
-      ruleKind: rule.kind,
-      severity: rule.severity,
-      scope,
-      ...value,
-      ...(rule.kind === "layer-order"
-        ? { comparability: rule.comparability }
-        : {}),
-    }) as DiagnosticReviewRuleEvaluation;
+    extraReasons.length === 0 &&
+    expressionOverflows.length === 0 &&
+    left.value !== null &&
+    right.value !== null
+      ? []
+      : uniqueReasons([
+          ...left.reasons,
+          ...right.reasons,
+          ...extraReasons,
+          ...(expressionOverflows.length > 0 ? ["expression-overflow" as const] : []),
+          ...((left.value === null || right.value === null) &&
+          left.reasons.length === 0 &&
+          right.reasons.length === 0 &&
+          expressionOverflows.length === 0
+            ? ["missing" as const]
+            : []),
+        ]);
   if (reasons.length > 0)
-    return result({
-      status: rule.missingInput === "finding" ? "triggered" : "not-evaluated",
-      triggerReason: rule.missingInput === "finding" ? missingReason() : null,
-      left: left.value,
-      right: right.value,
-      relation: null,
-      notEvaluatedReasons: reasons,
+    return evaluationRecord(
+      rule,
+      scope,
+      left,
+      right,
+      rule.missingInput === "finding" ? "triggered" : "not-evaluated",
+      rule.missingInput === "finding" ? missingTriggerReason(reasons) : null,
+      null,
+      reasons,
       expressionOverflows,
-    });
+      scratch,
+    );
   const compared = classifyDiagnosticComparison(
     left.value,
     right.value,
     rule.tolerance,
   );
+  // Empty reason and overflow lists are this review's own immutable values;
+  // the eager finalizer leaves frozen children as they are and readers only
+  // iterate them, and no other invocation ever sees the same arrays.
   if (compared.status === "not-evaluated")
-    return result({
-      status: rule.missingInput === "finding" ? "triggered" : "not-evaluated",
-      triggerReason:
-        rule.missingInput === "finding"
-          ? compared.reason === "tolerance-overflow"
-            ? "tolerance-overflow"
-            : "missing-input"
-          : null,
-      left: left.value,
-      right: right.value,
-      relation: null,
-      notEvaluatedReasons: [compared.reason],
-      expressionOverflows: [],
-    });
+    return evaluationRecord(
+      rule,
+      scope,
+      left,
+      right,
+      rule.missingInput === "finding" ? "triggered" : "not-evaluated",
+      rule.missingInput === "finding"
+        ? compared.reason === "tolerance-overflow"
+          ? "tolerance-overflow"
+          : "missing-input"
+        : null,
+      null,
+      [compared.reason],
+      empty.overflows,
+      scratch,
+    );
   const pass = passes(compared.relation);
-  return result({
-    status: pass ? "pass" : "triggered",
-    triggerReason: pass ? null : "predicate",
+  return evaluationRecord(
+    rule,
+    scope,
+    left,
+    right,
+    pass ? "pass" : "triggered",
+    pass ? null : "predicate",
+    compared.relation,
+    empty.reasons,
+    empty.overflows,
+    scratch,
+  );
+}
+
+function missingTriggerReason(
+  reasons: readonly DiagnosticRuleNotEvaluatedReason[],
+): DiagnosticReviewRuleEvaluation["triggerReason"] {
+  if (
+    reasons.some((reason) =>
+      ["missing", "imputed", "non-finite", "structural-ambiguity"].includes(
+        reason,
+      ),
+    )
+  )
+    return "missing-input";
+  if (reasons.includes("aggregation-overflow")) return "aggregation-overflow";
+  if (reasons.includes("expression-overflow")) return "expression-overflow";
+  if (reasons.includes("tolerance-overflow")) return "tolerance-overflow";
+  return "missing-input";
+}
+
+/** One literal in the contract's key order; no intermediate spread objects. */
+function evaluationRecord(
+  rule: DiagnosticReviewRule,
+  scope: DiagnosticReviewEvaluationScope,
+  left: EvaluatedOperand,
+  right: EvaluatedOperand,
+  status: DiagnosticReviewRuleEvaluationBase["status"],
+  triggerReason: DiagnosticReviewRuleEvaluationBase["triggerReason"],
+  relation: DiagnosticReviewRuleEvaluationBase["relation"],
+  notEvaluatedReasons: readonly DiagnosticRuleNotEvaluatedReason[],
+  overflows: readonly DiagnosticReviewExpressionOverflow[],
+  scratch?: EvaluationScratch,
+): DiagnosticReviewRuleEvaluation {
+  if (scratch !== undefined) {
+    const target = scratch.record;
+    target.ruleId = rule.id;
+    target.ruleKind = rule.kind;
+    target.severity = rule.severity;
+    target.scope = scope;
+    target.status = status;
+    target.triggerReason = triggerReason;
+    target.left = left.value;
+    target.right = right.value;
+    target.relation = relation;
+    target.notEvaluatedReasons = notEvaluatedReasons;
+    target.expressionOverflows = overflows;
+    target.comparability = rule.kind === "layer-order" ? rule.comparability : undefined;
+    return target as unknown as DiagnosticReviewRuleEvaluation;
+  }
+  const value = {
+    ruleId: rule.id,
+    ruleKind: rule.kind,
+    severity: rule.severity,
+    scope,
+    status,
+    triggerReason,
     left: left.value,
     right: right.value,
-    relation: compared.relation,
-    notEvaluatedReasons: [],
-    expressionOverflows: [],
-  });
+    relation,
+    notEvaluatedReasons,
+    expressionOverflows: overflows,
+  };
+  return (
+    rule.kind === "layer-order"
+      ? { ...value, comparability: rule.comparability }
+      : value
+  ) as DiagnosticReviewRuleEvaluation;
 }
 
 function filterCells(
@@ -720,7 +994,7 @@ export function evaluateDiagnosticReviewRulesCompact(
   const invariant = parent
     ? compactEvaluationCache.get(parent) ?? evaluateDiagnosticReviewRulesCompact(parent)
     : undefined;
-  const compactSources = createCompactCellSourceReader();
+  const compactSources = createCompactCellSourceReader(prepared.cells.length);
   const builder = createCompactReviewBuilder(
     prepared.definition.definition.reviewRules,
     compactSources,
@@ -747,10 +1021,21 @@ function visitDiagnosticReviewRules(
     prepared,
     compactSources,
   );
-  const cellByCoordinate = new Map<
-    string,
-    PreparedDiagnosticData["cells"][number]
-  >();
+  const ownedEmpty = freshEmptyLists();
+  // Only the compact builder, which copies what it keeps, receives reused records.
+  const scratch = compactSources === undefined ? undefined : createEvaluationScratch();
+  const constantOperand = (value: number): EvaluatedOperand => {
+    if (scratch === undefined) return constant(value);
+    let operand = scratch.constants.get(value);
+    if (operand === undefined) {
+      operand = { value, reasons: NO_REASONS, overflows: NO_REVIEW_OVERFLOWS, sources: NO_SOURCES };
+      scratch.constants.set(value, operand);
+    }
+    return operand;
+  };
+  const cells = prepared.cells;
+  // Cell positions, not cell objects, key every per-cell cache in this walk.
+  const cellIndexByCoordinate = new Map<string, number>();
   const expectedSourcesByCoordinate = new Map<
     string,
     DiagnosticSourceLocation[]
@@ -759,8 +1044,29 @@ function visitDiagnosticReviewRules(
     sourceGroup: string,
     origin: string,
     valuation: string,
-  ) => canonicalJson([sourceGroup, origin, valuation]);
-  const monotonicGroups: Array<{ sourceGroup: string; origin: string; valuations: string[] }> = [];
+  ) => canonicalScalarArrayJson([sourceGroup, origin, valuation]);
+  // One review coordinate per cell; every rule's scope for that cell cites it.
+  const coordinates: (DiagnosticReviewCoordinate | undefined)[] = new Array(cells.length);
+  const coordinateOf = (
+    cell: PreparedDiagnosticData["cells"][number],
+    cellIndex: number,
+  ): DiagnosticReviewCoordinate => {
+    let value = coordinates[cellIndex];
+    if (!value) {
+      value = coordinate(cell);
+      coordinates[cellIndex] = value;
+    }
+    return value;
+  };
+  // Cells and expected-cell sources are resolved once per group; every
+  // monotonic rule then walks the same ordered valuations by position.
+  const monotonicGroups: Array<{
+    sourceGroup: string;
+    origin: string;
+    valuations: string[];
+    cellIndices: (number | undefined)[];
+    expected: (readonly DiagnosticSourceLocation[])[];
+  }> = [];
   // Keep the original traversal and source order; only replace repeated searches.
   // Other rule families do not need these indices.
   if (
@@ -768,9 +1074,10 @@ function visitDiagnosticReviewRules(
       (rule) => rule.kind === "monotonic",
     )
   ) {
-    for (const cell of prepared.cells) {
+    for (let index = 0; index < cells.length; index++) {
+      const cell = cells[index]!;
       const key = coordinateKey(cell.sourceGroup, cell.origin, cell.valuation);
-      if (!cellByCoordinate.has(key)) cellByCoordinate.set(key, cell);
+      if (!cellIndexByCoordinate.has(key)) cellIndexByCoordinate.set(key, index);
     }
     for (const cell of prepared.expectedCells) {
       if (!cell.source) continue;
@@ -783,7 +1090,7 @@ function visitDiagnosticReviewRules(
     // the rule expression. Build them once for all monotonic rules in this run.
     const groups = new Map<string, Set<string>>();
     for (const cell of [...prepared.cells, ...prepared.expectedCells]) {
-      const key = canonicalJson([cell.sourceGroup, cell.origin]);
+      const key = canonicalScalarArrayJson([cell.sourceGroup, cell.origin]);
       const values = groups.get(key) ?? new Set<string>();
       values.add(cell.valuation);
       groups.set(key, values);
@@ -801,7 +1108,15 @@ function visitDiagnosticReviewRules(
       const [sourceGroup, origin] = JSON.parse(key) as [string, string];
       const valuations = [...values].sort((left, right) =>
         valuationCoordinate(left) - valuationCoordinate(right) || codeUnit(left, right));
-      monotonicGroups.push({ sourceGroup, origin, valuations });
+      monotonicGroups.push({
+        sourceGroup,
+        origin,
+        valuations,
+        cellIndices: valuations.map((valuation) =>
+          cellIndexByCoordinate.get(coordinateKey(sourceGroup, origin, valuation))),
+        expected: valuations.map((valuation) =>
+          expectedSourcesByCoordinate.get(coordinateKey(sourceGroup, origin, valuation)) ?? NO_SOURCES),
+      });
     }
   }
   for (const [ruleIndex, rule] of (
@@ -947,84 +1262,77 @@ function visitDiagnosticReviewRules(
           left,
           constant(rule.expected),
           (relation) => relation === "equal",
+          NO_REASONS,
+          ownedEmpty,
         ),
       );
       continue;
     }
     if (rule.kind === "monotonic") {
-      for (const { sourceGroup, origin, valuations: sorted } of monotonicGroups) {
+      const expressionPath = `${basePath}/expression`;
+      const monotonicPasses = (relation: "less" | "equal" | "greater") =>
+        rule.direction === "nondecreasing" ? relation !== "greater" : relation !== "less";
+      for (const { sourceGroup, origin, valuations: sorted, cellIndices, expected } of monotonicGroups) {
         for (let index = 1; index < sorted.length; index++) {
           const previousValuation = sorted[index - 1]!;
           const currentValuation = sorted[index]!;
-          const previous = cellByCoordinate.get(
-            coordinateKey(sourceGroup, origin, previousValuation),
-          );
-          const current = cellByCoordinate.get(
-            coordinateKey(sourceGroup, origin, currentValuation),
-          );
-          const expectedSources = (valuation: string) =>
-            expectedSourcesByCoordinate.get(
-              coordinateKey(sourceGroup, origin, valuation),
-            ) ?? [];
+          const previousIndex = cellIndices[index - 1];
+          const currentIndex = cellIndices[index];
+          const previous = previousIndex === undefined ? undefined : cells[previousIndex];
+          const current = currentIndex === undefined ? undefined : cells[currentIndex];
           const left = previous
-            ? evaluateExpression(
-                previous,
-                rule.expression,
-                `${basePath}/expression`,
-              )
+            ? evaluateExpression(previous, previousIndex!, rule.expression, expressionPath, 0)
             : {
                 value: null,
                 reasons: ["missing" as const],
                 overflows: [],
                 sources: compactSources
-                  ? compactSources.forPreparedSources(
-                      expectedSources(previousValuation),
-                    )
-                  : uniqueSources(expectedSources(previousValuation)),
+                  ? compactSources.forPreparedSources(expected[index - 1]!)
+                  : uniqueSources(expected[index - 1]!),
               };
           const right = current
-            ? evaluateExpression(
-                current,
-                rule.expression,
-                `${basePath}/expression`,
-              )
+            ? evaluateExpression(current, currentIndex!, rule.expression, expressionPath, 1)
             : {
                 value: null,
                 reasons: ["missing" as const],
                 overflows: [],
                 sources: compactSources
-                  ? compactSources.forPreparedSources(
-                      expectedSources(currentValuation),
-                    )
-                  : uniqueSources(expectedSources(currentValuation)),
+                  ? compactSources.forPreparedSources(expected[index]!)
+                  : uniqueSources(expected[index]!),
               };
-          const scope: DiagnosticReviewEvaluationScope = {
-            kind: "valuation-pair",
-            previous: previous
-              ? coordinate(previous)
-              : coordinateFromLabels(
-                  prepared,
-                  sourceGroup,
-                  origin,
-                  previousValuation,
-                ),
-            current: current
-              ? coordinate(current)
-              : coordinateFromLabels(
-                  prepared,
-                  sourceGroup,
-                  origin,
-                  currentValuation,
-                ),
-            sources: compactSources
-              ? compactSources.union([left.sources, right.sources])
-              : uniqueSources([...left.sources, ...right.sources]),
-          };
+          const previousCoordinate = previous
+            ? coordinateOf(previous, previousIndex!)
+            : coordinateFromLabels(prepared, sourceGroup, origin, previousValuation);
+          const currentCoordinate = current
+            ? coordinateOf(current, currentIndex!)
+            : coordinateFromLabels(prepared, sourceGroup, origin, currentValuation);
+          const pairSources = compactSources
+            ? compactSources.union([left.sources, right.sources])
+            : uniqueSources([...left.sources, ...right.sources]);
+          let scope: DiagnosticReviewEvaluationScope;
+          if (scratch !== undefined) {
+            scratch.pairScope.previous = previousCoordinate;
+            scratch.pairScope.current = currentCoordinate;
+            scratch.pairScope.sources = pairSources;
+            scope = scratch.pairScope;
+          } else
+            scope = {
+              kind: "valuation-pair",
+              previous: previousCoordinate,
+              current: currentCoordinate,
+              sources: pairSources,
+            };
           appendEvaluation(
-            evaluation(prepared, rule, scope, left, right, (relation) =>
-              rule.direction === "nondecreasing"
-                ? relation !== "greater"
-                : relation !== "less",
+            evaluation(
+              prepared,
+              rule,
+              scope,
+              left,
+              right,
+              monotonicPasses,
+              NO_REASONS,
+              ownedEmpty,
+              scratch,
             ),
           );
         }
@@ -1051,75 +1359,65 @@ function visitDiagnosticReviewRules(
           ].sort(codeUnit),
         )
       : undefined;
-    for (const cell of prepared.cells) {
-      const scopeFor = (
-        leftSources: readonly DiagnosticSourceLocation[],
-        rightSources: readonly DiagnosticSourceLocation[],
-      ): DiagnosticCellReviewScope => ({
+    // Operand paths depend only on the rule; build them once, not per cell.
+    const leftPath = `${basePath}/when/left`;
+    const rightPath = `${basePath}/when/right`;
+    const actualPath = `${basePath}/actual`;
+    const expectedPath = `${basePath}/expected`;
+    const narrowerPath = `${basePath}/narrower`;
+    const broaderPath = `${basePath}/broader`;
+    // Per-rule helpers: created once, not once per cell.
+    const scopeFor = (
+      cell: PreparedDiagnosticData["cells"][number],
+      cellIndex: number,
+      leftSources: readonly DiagnosticSourceLocation[],
+      rightSources: readonly DiagnosticSourceLocation[],
+    ): DiagnosticCellReviewScope => {
+      if (scratch !== undefined) {
+        scratch.cellScope.cell = coordinateOf(cell, cellIndex);
+        scratch.cellScope.sources = compactSources!.forCell(cell, cellIndex, scopeDependencies!);
+        return scratch.cellScope;
+      }
+      return {
         kind: "cell",
-        cell: coordinate(cell),
+        cell: coordinateOf(cell, cellIndex),
         sources: compactSources
-          ? compactSources.forCell(cell, scopeDependencies!)
+          ? compactSources.forCell(cell, cellIndex, scopeDependencies!)
           : uniqueSources([...leftSources, ...rightSources]),
-      });
+      };
+    };
+    const comparePasses = (relation: "less" | "equal" | "greater") =>
+      rule.kind === "compare" && !diagnosticPredicateMatches(rule.when.operator, relation);
+    const reconcilePasses = (relation: "less" | "equal" | "greater") => relation === "equal";
+    const layerPasses = (relation: "less" | "equal" | "greater") => relation !== "greater";
+    for (let index = 0; index < cells.length; index++) {
+      const cell = cells[index]!;
       if (rule.kind === "compare") {
-        const operand = (item: typeof rule.when.left, path: string) =>
-          item.op === "constant"
-            ? constant(item.value)
-            : evaluateExpression(cell, item, path);
-        const left = operand(rule.when.left, `${basePath}/when/left`);
-        const right = operand(rule.when.right, `${basePath}/when/right`);
+        const left =
+          rule.when.left.op === "constant"
+            ? constantOperand(rule.when.left.value)
+            : evaluateExpression(cell, index, rule.when.left, leftPath, 0);
+        const right =
+          rule.when.right.op === "constant"
+            ? constantOperand(rule.when.right.value)
+            : evaluateExpression(cell, index, rule.when.right, rightPath, 1);
         appendEvaluation(
-          evaluation(
-            prepared,
-            rule,
-            scopeFor(left.sources, right.sources),
-            left,
-            right,
-            (relation) =>
-              !diagnosticPredicateMatches(rule.when.operator, relation),
-          ),
+          evaluation(prepared, rule, scopeFor(cell, index, left.sources, right.sources), left, right, comparePasses, NO_REASONS, ownedEmpty, scratch),
         );
       } else if (rule.kind === "reconcile") {
-        const left = evaluateExpression(
-          cell,
-          rule.actual,
-          `${basePath}/actual`,
-        );
+        const left = evaluateExpression(cell, index, rule.actual, actualPath, 0);
         const right =
           rule.expected.op === "constant"
-            ? constant(rule.expected.value)
-            : evaluateExpression(cell, rule.expected, `${basePath}/expected`);
+            ? constantOperand(rule.expected.value)
+            : evaluateExpression(cell, index, rule.expected, expectedPath, 1);
         appendEvaluation(
-          evaluation(
-            prepared,
-            rule,
-            scopeFor(left.sources, right.sources),
-            left,
-            right,
-            (relation) => relation === "equal",
-          ),
+          evaluation(prepared, rule, scopeFor(cell, index, left.sources, right.sources), left, right, reconcilePasses, NO_REASONS, ownedEmpty, scratch),
         );
       } else {
-        const left = evaluateExpression(
-          cell,
-          rule.narrower,
-          `${basePath}/narrower`,
-        );
-        const right = evaluateExpression(
-          cell,
-          rule.broader,
-          `${basePath}/broader`,
-        );
+        const left = evaluateExpression(cell, index, rule.narrower, narrowerPath, 0);
+        const right = evaluateExpression(cell, index, rule.broader, broaderPath, 1);
         appendEvaluation(
-          evaluation(
-            prepared,
-            rule,
-            scopeFor(left.sources, right.sources),
-            left,
-            right,
-            (relation) => relation !== "greater",
-          ),
+          evaluation(prepared, rule, scopeFor(cell, index, left.sources, right.sources), left, right, layerPasses, NO_REASONS, ownedEmpty, scratch),
         );
       }
     }