@actuarial-ts/core 0.10.0 → 0.11.0

package/dist/diagnosticReview.js

@@ -1,14 +1,21 @@
 import { getCompiledDiagnosticDefinitionInternals, } from "./diagnosticDefinitions.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";
 import { evaluateDiagnosticMeasureExpression, } from "./diagnosticFormulas.js";
+import { hasDiagnosticOwn } from "./diagnosticRuntime.js";
 import { assertPreparedDiagnosticData, assertCompactPreparedDiagnosticData, getCompactSourceSelectionParent, getCompactCoordinateSelectionParent, } from "./diagnosticPreparation.js";
 import { createCompactReviewBuilder, selectCompactReviewSources, } from "./diagnosticReviewStore.js";
 import { classifyDiagnosticComparison, diagnosticPredicateMatches, } from "./diagnosticRules.js";
 import { finalizeDiagnosticContributions } from "./diagnosticAggregation.js";
 import { compareDiagnosticSourceLocations, normalizeDiagnosticSourceLocations, } from "./diagnosticSourceOrdering.js";
+// 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 = Object.freeze([]);
+const NO_REVIEW_OVERFLOWS = Object.freeze([]);
+const NO_SOURCES = Object.freeze([]);
 const REASON_ORDER = [
     "missing",
     "imputed",
@@ -46,41 +53,62 @@ function expressionLeafPaths(expression, path) {
         ...expressionLeafPaths(expression.right, `${path}/right`),
     ];
 }
-function states(prepared, cell) {
+// 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;
+function states(prepared, cell, cache) {
     const internals = getCompiledDiagnosticDefinitionInternals(prepared.definition);
-    return Object.fromEntries(Object.entries(cell.components).map(([id, stats]) => {
-        const measure = internals.measuresById.get(id);
-        const readiness = [];
-        if (stats.missing)
-            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,
-                },
+    const result = {};
+    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);
+            let readiness;
+            if (stats.missing)
+                (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");
+            const quantity = {
+                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,
                 stats,
-                readiness,
+                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(cell) {
     return {
@@ -118,16 +146,31 @@ function cellSourcesForSelection(cells, measureId) {
     ]));
 }
 /** Compact-only, invocation-owned caches. Never retain these on a prepared cell. */
-function createCompactCellSourceReader() {
+function createCompactCellSourceReader(cellCount) {
     const pool = createDiagnosticReviewSourcePool();
     const addCellSources = (target, cell, ids) => {
-        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;
+        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 = (cells, measureId) => {
@@ -138,8 +181,30 @@ function createCompactCellSourceReader() {
         return target.finish();
     };
     const dependencies = new WeakMap();
-    const dependencyKeys = new WeakMap();
-    const byCell = new WeakMap();
+    // 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();
+    const subsetIndexByIds = new Map();
+    // 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 = [];
+    const subsetIndex = (ids) => {
+        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 = new Array(cellCount);
     const measureIds = (expression) => {
         let ids = dependencies.get(expression);
         if (!ids) {
@@ -148,23 +213,50 @@ function createCompactCellSourceReader() {
         }
         return ids;
     };
-    const forCell = (cell, ids) => {
-        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 forCell = (cell, cellIndex, ids) => {
+        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;
+            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;
     };
@@ -179,34 +271,97 @@ function createCellExpressionEvaluator(prepared, compactSources) {
     // 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();
-    return (cell, expression, path) => {
-        let measures = statesByCell.get(cell);
+    const statesByCell = new Array(prepared.cells.length);
+    const 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 = 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, value, reasons, overflows, sources) => {
+        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, cellIndex, expression, path, slot = -1) => {
+        let measures = statesByCell[cellIndex];
         if (!measures) {
-            measures = states(prepared, cell);
-            statesByCell.set(cell, measures);
+            measures = states(prepared, cell, stateCache);
+            statesByCell[cellIndex] = measures;
         }
-        const result = evaluateDiagnosticMeasureExpression(expression, measures, path);
         const sources = compactSources
-            ? compactSources.forCell(cell, compactSources.measureIds(expression))
+            ? compactSources.forCell(cell, cellIndex, compactSources.measureIds(expression))
             : cellSources(cell, expressionMeasureIds(expression));
-        return {
-            value: result.value,
-            reasons: result.reasons,
-            overflows: result.overflows.map((overflow) => ({
+        // 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);
+        return operand(slot, result.value, result.reasons, result.overflows.length === 0
+            ? NO_REVIEW_OVERFLOWS
+            : result.overflows.map((overflow) => ({
                 ...overflow,
                 coordinate: coordinate(cell),
                 sources,
-            })),
-            sources,
-        };
+            })), sources);
     };
 }
 function constant(value) {
     return { value, reasons: [], overflows: [], sources: [] };
 }
-function evaluation(prepared, rule, scope, left, right, passes, extraReasons = []) {
-    const expressionOverflows = [
+function createEvaluationScratch() {
+    const placeholder = {
+        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(),
+    };
+}
+// 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 = () => {
+    const empty = Object.freeze([]);
+    return { reasons: empty, overflows: empty };
+};
+function evaluation(prepared, rule, scope, left, right, passes, extraReasons = NO_REASONS, empty = freshEmptyLists(), scratch) {
+    const expressionOverflows = left.overflows.length === 0 && right.overflows.length === 0 ? [] : [
         ...new Map([...left.overflows, ...right.overflows].map((item) => [
             canonicalJson(item),
             item,
@@ -235,74 +390,86 @@ function evaluation(prepared, rule, scope, left, right, passes, extraReasons = [
         }
         return a.sources.length - b.sources.length;
     });
-    const reasons = uniqueReasons([
-        ...left.reasons,
-        ...right.reasons,
-        ...extraReasons,
-        ...(expressionOverflows.length > 0 ? ["expression-overflow"] : []),
-        ...((left.value === null || right.value === null) &&
-            left.reasons.length === 0 &&
-            right.reasons.length === 0 &&
-            expressionOverflows.length === 0
-            ? ["missing"]
-            : []),
-    ]);
-    const missingReason = () => {
-        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";
+    // Clean evaluated operands carry no reasons; skip the spread/filter round trip.
+    const reasons = left.reasons.length === 0 &&
+        right.reasons.length === 0 &&
+        extraReasons.length === 0 &&
+        expressionOverflows.length === 0 &&
+        left.value !== null &&
+        right.value !== null
+        ? []
+        : uniqueReasons([
+            ...left.reasons,
+            ...right.reasons,
+            ...extraReasons,
+            ...(expressionOverflows.length > 0 ? ["expression-overflow"] : []),
+            ...((left.value === null || right.value === null) &&
+                left.reasons.length === 0 &&
+                right.reasons.length === 0 &&
+                expressionOverflows.length === 0
+                ? ["missing"]
+                : []),
+        ]);
+    if (reasons.length > 0)
+        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 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 evaluationRecord(rule, scope, left, right, pass ? "pass" : "triggered", pass ? null : "predicate", compared.relation, empty.reasons, empty.overflows, scratch);
+}
+function missingTriggerReason(reasons) {
+    if (reasons.some((reason) => ["missing", "imputed", "non-finite", "structural-ambiguity"].includes(reason)))
         return "missing-input";
-    };
-    const result = (value) => ({
+    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, scope, left, right, status, triggerReason, relation, notEvaluatedReasons, overflows, scratch) {
+    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;
+    }
+    const value = {
         ruleId: rule.id,
         ruleKind: rule.kind,
         severity: rule.severity,
         scope,
-        ...value,
-        ...(rule.kind === "layer-order"
-            ? { comparability: rule.comparability }
-            : {}),
-    });
-    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,
-            expressionOverflows,
-        });
-    const compared = classifyDiagnosticComparison(left.value, right.value, rule.tolerance);
-    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: [],
-        });
-    const pass = passes(compared.relation);
-    return result({
-        status: pass ? "pass" : "triggered",
-        triggerReason: pass ? null : "predicate",
+        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);
 }
 function filterCells(prepared, filter) {
     if (!filter)
@@ -407,7 +574,7 @@ export function evaluateDiagnosticReviewRulesCompact(prepared) {
     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);
     visitDiagnosticReviewRules(prepared, builder.append, compactSources, invariant !== undefined, coordinateParent !== undefined);
     const evaluated = builder.finish();
@@ -418,17 +585,45 @@ export function evaluateDiagnosticReviewRulesCompact(prepared) {
 /** One traversal and one formula implementation serve both storage contracts. */
 function visitDiagnosticReviewRules(prepared, appendEvaluation, compactSources, controlsOnly = false, includeMonotonic = false) {
     const evaluateExpression = createCellExpressionEvaluator(prepared, compactSources);
-    const cellByCoordinate = new Map();
+    const ownedEmpty = freshEmptyLists();
+    // Only the compact builder, which copies what it keeps, receives reused records.
+    const scratch = compactSources === undefined ? undefined : createEvaluationScratch();
+    const constantOperand = (value) => {
+        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();
     const expectedSourcesByCoordinate = new Map();
-    const coordinateKey = (sourceGroup, origin, valuation) => canonicalJson([sourceGroup, origin, valuation]);
+    const coordinateKey = (sourceGroup, origin, valuation) => canonicalScalarArrayJson([sourceGroup, origin, valuation]);
+    // One review coordinate per cell; every rule's scope for that cell cites it.
+    const coordinates = new Array(cells.length);
+    const coordinateOf = (cell, cellIndex) => {
+        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 = [];
     // Keep the original traversal and source order; only replace repeated searches.
     // Other rule families do not need these indices.
     if ((!controlsOnly || includeMonotonic) && prepared.definition.definition.reviewRules.some((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)
@@ -442,7 +637,7 @@ function visitDiagnosticReviewRules(prepared, appendEvaluation, compactSources,
         // the rule expression. Build them once for all monotonic rules in this run.
         const groups = new Map();
         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();
             values.add(cell.valuation);
             groups.set(key, values);
@@ -459,7 +654,13 @@ function visitDiagnosticReviewRules(prepared, appendEvaluation, compactSources,
         for (const [key, values] of [...groups.entries()].sort(([left], [right]) => codeUnit(left, right))) {
             const [sourceGroup, origin] = JSON.parse(key);
             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 prepared.definition.definition
@@ -563,52 +764,64 @@ function visitDiagnosticReviewRules(prepared, appendEvaluation, compactSources,
                     measureIds.reduce((count, measureId) => count + (cell.contributions[measureId]?.length ?? 0), 0), 0),
                 sources,
             };
-            appendEvaluation(evaluation(prepared, rule, scope, left, constant(rule.expected), (relation) => relation === "equal"));
+            appendEvaluation(evaluation(prepared, rule, scope, 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) => 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) => 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"],
                             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"],
                             overflows: [],
                             sources: compactSources
-                                ? compactSources.forPreparedSources(expectedSources(currentValuation))
-                                : uniqueSources(expectedSources(currentValuation)),
+                                ? compactSources.forPreparedSources(expected[index])
+                                : uniqueSources(expected[index]),
                         };
-                    const scope = {
-                        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]),
-                    };
-                    appendEvaluation(evaluation(prepared, rule, scope, left, right, (relation) => rule.direction === "nondecreasing"
-                        ? relation !== "greater"
-                        : relation !== "less"));
+                    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;
+                    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, monotonicPasses, NO_REASONS, ownedEmpty, scratch));
                 }
             }
             continue;
@@ -626,33 +839,53 @@ function visitDiagnosticReviewRules(prepared, appendEvaluation, compactSources,
                     : compactSources.measureIds(expression))),
             ].sort(codeUnit))
             : undefined;
-        for (const cell of prepared.cells) {
-            const scopeFor = (leftSources, rightSources) => ({
+        // 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, cellIndex, leftSources, rightSources) => {
+            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) => rule.kind === "compare" && !diagnosticPredicateMatches(rule.when.operator, relation);
+        const reconcilePasses = (relation) => relation === "equal";
+        const layerPasses = (relation) => relation !== "greater";
+        for (let index = 0; index < cells.length; index++) {
+            const cell = cells[index];
             if (rule.kind === "compare") {
-                const operand = (item, path) => 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`);
-                appendEvaluation(evaluation(prepared, rule, scopeFor(left.sources, right.sources), left, right, (relation) => !diagnosticPredicateMatches(rule.when.operator, relation)));
+                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(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`);
-                appendEvaluation(evaluation(prepared, rule, scopeFor(left.sources, right.sources), left, right, (relation) => relation === "equal"));
+                    ? constantOperand(rule.expected.value)
+                    : evaluateExpression(cell, index, rule.expected, expectedPath, 1);
+                appendEvaluation(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`);
-                appendEvaluation(evaluation(prepared, rule, scopeFor(left.sources, right.sources), left, right, (relation) => relation !== "greater"));
+                const left = evaluateExpression(cell, index, rule.narrower, narrowerPath, 0);
+                const right = evaluateExpression(cell, index, rule.broader, broaderPath, 1);
+                appendEvaluation(evaluation(prepared, rule, scopeFor(cell, index, left.sources, right.sources), left, right, layerPasses, NO_REASONS, ownedEmpty, scratch));
             }
         }
     }