@actuarial-ts/core 0.7.0 → 0.8.0

package/src/diagnosticPreparation.ts

@@ -1,4 +1,6 @@
 import { canonicalJson, fnv1a64 } from "./canonical.js";
+import { freezeDiagnosticGraph as deepFreeze } from "./diagnosticFreeze.js";
+import { createDiagnosticEvidenceInterner } from "./diagnosticEvidenceIntern.js";
 import {
   createDiagnosticIdentityArray,
   createDiagnosticIdentityObject,
@@ -204,6 +206,163 @@ export interface CompactPreparedDiagnosticData extends PreparedDiagnosticDataCon
   readonly [compactPreparedDiagnosticDataBrand]: true;
 }
 
+/**
+ * Reuse immutable preparation when only metric selection changes. A different
+ * source scope returns undefined so callers can perform full preparation.
+ * Invalid filters and forged preparations still fail at the public boundary.
+ * Review and metric execution gates must still run for the returned handle.
+ */
+export function reselectCompactDiagnosticMetrics(
+  prepared: CompactPreparedDiagnosticData,
+  filter?: DiagnosticsFilter,
+): CompactPreparedDiagnosticData | undefined {
+  assertCompactPreparedDiagnosticData(prepared);
+  const boundaryIssues = preparationBoundaryIssues({
+    definition: prepared.definition, losses: [], exposures: [],
+    ...(filter === undefined ? {} : { filter }),
+  });
+  if (boundaryIssues.length) throw new DiagnosticValidationError(boundaryIssues);
+  const issues: DiagnosticValidationIssue[] = [];
+  const knownGroups = new Set(prepared.inputAudit.map((item) => item.record.sourceGroup));
+  const normalized = normalizeFilter(prepared.definition, filter, knownGroups, issues).value;
+  if (issues.length) throw new DiagnosticValidationError(issues);
+  const sourceScope = (value: DiagnosticsFilter | null) => {
+    const { instanceIds: _instances, ...scope } = value ?? {};
+    return canonicalJson(scope);
+  };
+  if (sourceScope(normalized) !== sourceScope(prepared.filter)) return undefined;
+  const selected = Object.freeze({ ...prepared, filter: deepFreeze(normalized) }) as CompactPreparedDiagnosticData;
+  authenticCompact.add(selected);
+  const parent = sourceSelectionParents.get(prepared);
+  const coordinateParent = coordinateSelectionParents.get(prepared);
+  if (coordinateParent) coordinateSelectionParents.set(selected, coordinateParent);
+  if (parent || sourceSelectionMetadata.has(prepared))
+    sourceSelectionParents.set(selected, parent ?? prepared);
+  return selected;
+}
+
+/**
+ * Project source-group subsets of a clean aggregate preparation. Other scope
+ * changes or preparations requiring structural reconciliation return undefined
+ * for full preparation. Excluded input audits retain their original raw periods.
+ */
+export function selectCompactDiagnosticSourceGroups(
+  prepared: CompactPreparedDiagnosticData,
+  filter?: DiagnosticsFilter,
+): CompactPreparedDiagnosticData | undefined {
+  return selectCompactSourceScope(prepared, filter, false);
+}
+
+/** Select whole origins and source groups from a clean preparation with all origins. */
+export function selectCompactDiagnosticOrigins(
+  prepared: CompactPreparedDiagnosticData,
+  filter?: DiagnosticsFilter,
+): CompactPreparedDiagnosticData | undefined {
+  return selectCompactSourceScope(prepared, filter, true);
+}
+
+/** Select date/age coordinates from a clean aggregate preparation covering the full input scope. */
+export function selectCompactDiagnosticCoordinates(
+  prepared: CompactPreparedDiagnosticData,
+  filter?: DiagnosticsFilter,
+): CompactPreparedDiagnosticData | undefined {
+  return selectCompactSourceScope(prepared, filter, true, true);
+}
+
+function selectCompactSourceScope(
+  prepared: CompactPreparedDiagnosticData,
+  filter: DiagnosticsFilter | undefined,
+  allowOrigins: boolean,
+  allowCoordinates = false,
+): CompactPreparedDiagnosticData | undefined {
+  assertCompactPreparedDiagnosticData(prepared);
+  const metadata = sourceSelectionMetadata.get(prepared);
+  const boundaryIssues = preparationBoundaryIssues({
+    definition: prepared.definition, losses: [], exposures: [],
+    ...(filter === undefined ? {} : { filter }),
+  });
+  if (boundaryIssues.length) throw new DiagnosticValidationError(boundaryIssues);
+  const issues: DiagnosticValidationIssue[] = [];
+  const normalizedFilter = normalizeFilter(prepared.definition, filter,
+    metadata?.groups ?? new Set(prepared.inputAudit.map((item) => item.record.sourceGroup)), issues);
+  const normalized = normalizedFilter.value;
+  if (issues.length) throw new DiagnosticValidationError(issues);
+  if (!metadata) return undefined;
+  if (allowOrigins && !metadata.allOriginsSelected) return undefined;
+  if (allowCoordinates && !metadata.allCoordinatesSelected) return undefined;
+  const remainingScope = (value: DiagnosticsFilter | null) => {
+    const { instanceIds: _instances, sourceGroups: _groups, ...scope } = value ?? {};
+    if (!allowOrigins) return canonicalJson(scope);
+    const { origins: _origins, originFrom: _from, originThrough: _through, ...rest } = scope;
+    if (!allowCoordinates) return canonicalJson(rest);
+    const { valuations: _valuations, valuationFrom: _vFrom, valuationThrough: _vThrough,
+      minDevelopmentAge: _min, maxDevelopmentAge: _max, ...other } = rest;
+    return canonicalJson(other);
+  };
+  // Source exclusion precedes every date/age/cutoff decision. With no selected
+  // sources, all audits have the same source-excluded snapshots regardless of
+  // those selectors; boundary validation above must still run.
+  if (normalized?.sourceGroups?.length !== 0 &&
+    remainingScope(normalized) !== remainingScope(prepared.filter)) return undefined;
+  const groups = normalized?.sourceGroups === undefined ? undefined : new Set(normalized.sourceGroups);
+  const includes = (group: string) => !groups || groups.has(group);
+  const includedOrigins = allowOrigins ? new Set([...metadata.origins].filter(([, origin]) =>
+    selectedByOrigin(normalized, origin, normalizedFilter.originCoordinates)).map(([label]) => label)) : undefined;
+  const includesOrigin = (origin: string) => !includedOrigins || includedOrigins.has(origin);
+  const includesDate = (origin: string, valuation: string | null | undefined) => {
+    if (!allowCoordinates || valuation === undefined || valuation === null) return true;
+    const at = metadata.valuations.get(valuation)!;
+    const age = at.coordinate - metadata.origins.get(origin)!.coordinate + prepared.definition.definition.periodAxis.ageOffset;
+    return selectedByValuation(normalized, at, normalizedFilter.valuationCoordinates) && selectedByAge(normalized, age);
+  };
+  const audit = prepared.inputAudit.map((item) => !includes(item.record.sourceGroup)
+    ? metadata.excluded.get(item.record)!
+    : item.disposition === "retained" && (!includesOrigin(item.record.origin) || !includesDate(item.record.origin, item.record.valuation))
+      ? metadata.originExcluded.get(item.record)! : item);
+  audit.sort((left, right) => metadata.auditRanks.get(left)! - metadata.auditRanks.get(right)!);
+  const cells = Object.freeze(prepared.cells.filter((cell) => includes(cell.sourceGroup) && includesOrigin(cell.origin) && includesDate(cell.origin, cell.valuation)));
+  const exposures = Object.freeze(prepared.exposures.filter((exposure) => exposure.status === "valid" && includes(exposure.sourceGroup) && includesOrigin(exposure.origin) && includesDate(exposure.origin, exposure.valuation)));
+  const coordinateKeys = allowCoordinates ? new Set(cells.map((cell) => cellKey(cell.sourceGroup, cell.origin, cell.valuation))) : undefined;
+  const sourceOrigins = allowCoordinates ? new Set(cells.map((cell) => canonicalJson([cell.sourceGroup, cell.origin]))) : undefined;
+  const internals = getCompiledDiagnosticDefinitionInternals(prepared.definition);
+  const orphanFindings = allowCoordinates ? exposures.flatMap((exposure) => {
+    if (exposure.status !== "valid") return [];
+    const matches = internals.measuresById.get(exposure.measureId)!.exposureTiming === "origin-static"
+      ? sourceOrigins!.has(canonicalJson([exposure.sourceGroup, exposure.origin]))
+      : exposure.valuation !== undefined && coordinateKeys!.has(cellKey(exposure.sourceGroup, exposure.origin, exposure.valuation));
+    return matches ? [] : [exposureWithoutLossFinding(exposure)];
+  }) : [];
+  const selected = Object.freeze({
+    ...prepared,
+    filter: deepFreeze(normalized),
+    inputAudit: Object.freeze(audit),
+    cells,
+    exposures,
+    findings: orphanFindings.length ? deepFreeze(mergeFindings([...prepared.findings, ...orphanFindings])) : prepared.findings,
+    expectedCells: Object.freeze(prepared.expectedCells.filter((cell) => includes(cell.sourceGroup) && includesOrigin(cell.origin) && includesDate(cell.origin, cell.valuation))),
+  }) as CompactPreparedDiagnosticData;
+  authenticCompact.add(selected);
+  if (allowCoordinates) coordinateSelectionParents.set(selected, prepared);
+  else sourceSelectionParents.set(selected, prepared);
+  return selected;
+}
+
+/** Private ownership proof: only whole-source projection can register a parent. */
+export function getCompactSourceSelectionParent(
+  prepared: CompactPreparedDiagnosticData,
+): CompactPreparedDiagnosticData | undefined {
+  assertCompactPreparedDiagnosticData(prepared);
+  return sourceSelectionParents.get(prepared);
+}
+
+/** Private proof of cell reuse; does not imply unchanged development-history checks. */
+export function getCompactCoordinateSelectionParent(
+  prepared: CompactPreparedDiagnosticData,
+): CompactPreparedDiagnosticData | undefined {
+  assertCompactPreparedDiagnosticData(prepared);
+  return coordinateSelectionParents.get(prepared);
+}
+
 export interface NormalizedDiagnosticPreparationIdentity {
   readonly definitionIntegrity: string;
   readonly filter: NormalizedDiagnosticsFilterIdentity | null;
@@ -272,6 +431,18 @@ interface PendingBlocker {
 
 const authentic = new WeakSet<object>();
 const authenticCompact = new WeakSet<object>();
+const sourceSelectionParents = new WeakMap<CompactPreparedDiagnosticData, CompactPreparedDiagnosticData>();
+const coordinateSelectionParents = new WeakMap<CompactPreparedDiagnosticData, CompactPreparedDiagnosticData>();
+const sourceSelectionMetadata = new WeakMap<CompactPreparedDiagnosticData, {
+  groups: ReadonlySet<string>;
+  excluded: ReadonlyMap<object, DiagnosticInputAuditRecord>;
+  originExcluded: ReadonlyMap<object, DiagnosticInputAuditRecord>;
+  origins: ReadonlyMap<string, DiagnosticNormalizedPeriod>;
+  valuations: ReadonlyMap<string, DiagnosticNormalizedPeriod>;
+  allOriginsSelected: boolean;
+  allCoordinatesSelected: boolean;
+  auditRanks: ReadonlyMap<DiagnosticInputAuditRecord, number>;
+}>();
 const compactIdentityDocuments = new WeakMap<
   object,
   DiagnosticIdentityDocument
@@ -360,18 +531,6 @@ function own<T>(
     : undefined;
 }
 
-function deepFreeze<T>(
-  value: T,
-  seen = new WeakSet<object>(),
-): DiagnosticDeepReadonly<T> {
-  if (value === null || typeof value !== "object" || seen.has(value))
-    return value as DiagnosticDeepReadonly<T>;
-  seen.add(value);
-  for (const child of Object.values(value as Record<string, unknown>))
-    deepFreeze(child, seen);
-  return Object.freeze(value) as DiagnosticDeepReadonly<T>;
-}
-
 function uniqueSorted(values: readonly string[]): string[] {
   return [...new Set(values)].sort(codeUnit);
 }
@@ -382,6 +541,17 @@ function normalizeSources(
   return normalizeDiagnosticSourceLocations(values);
 }
 
+function exposureWithoutLossFinding(exposure: Extract<ReconciledDiagnosticExposure, { status: "valid" }>): DiagnosticMetricFinding {
+  return structuralFinding("exposure-without-loss", {
+    measureId: exposure.measureId,
+    exposureKey: exposure.key,
+    sourceGroup: exposure.sourceGroup,
+    origin: exposure.origin,
+    ...(exposure.valuation ? { valuation: exposure.valuation } : {}),
+    sources: exposure.sources,
+  });
+}
+
 function structuralFinding(
   code: StructuralCode,
   context: Omit<
@@ -1041,7 +1211,7 @@ function createAuditComparator(): (
   };
   return (left, right) =>
     rank[left.kind] - rank[right.kind] ||
-    codeUnit(key(left.record), key(right.record)) ||
+    (left.record === right.record ? 0 : codeUnit(key(left.record), key(right.record))) ||
     disposition[left.disposition] - disposition[right.disposition];
 }
 
@@ -1538,6 +1708,7 @@ function prepareDiagnosticDataInMode(
     coordinate: null,
     invalid: false,
   }));
+  const rawLossSnapshots = lossCandidates.map((candidate) => candidate.snapshot);
 
   for (const candidate of lossCandidates) {
     if (candidate.disposition !== "retained") continue;
@@ -1666,6 +1837,7 @@ function prepareDiagnosticDataInMode(
       invalid: false,
     }),
   );
+  const rawExposureSnapshots = exposureCandidates.map((candidate) => candidate.snapshot);
   for (const candidate of exposureCandidates) {
     if (candidate.disposition !== "retained") continue;
     try {
@@ -2150,14 +2322,7 @@ function prepareDiagnosticDataInMode(
     for (const key of keys) addToMap(validExposuresByCell, key, exposure);
     if (keys.length === 0)
       findings.push(
-        structuralFinding("exposure-without-loss", {
-          measureId: exposure.measureId,
-          exposureKey: exposure.key,
-          sourceGroup: exposure.sourceGroup,
-          origin: exposure.origin,
-          ...(exposure.valuation ? { valuation: exposure.valuation } : {}),
-          sources: exposure.sources,
-        }),
+        exposureWithoutLossFinding(exposure),
       );
   }
 
@@ -2169,6 +2334,12 @@ function prepareDiagnosticDataInMode(
     for (const key of new Set(pending.cellKeys))
       addToMap(pendingBlockersByCell, key, pending);
 
+  // Statistics are immutable scalar records, often identical across measures
+  // and cells. Share only freshly computed owned values, never contributions,
+  // source identities, prepared-cell envelopes, or authenticated SDK handles.
+  // The invocation-scoped pool is bounded and released after preparation.
+  const componentSharing = createDiagnosticEvidenceInterner();
+
   for (const [key, rows] of cellRows) {
     const [sourceGroup, origin, valuation] = parseCellKey(key);
     const coordinate = coordinateFor(definition, origin, valuation).coordinate!;
@@ -2311,15 +2482,24 @@ function prepareDiagnosticDataInMode(
         const measure = internals.measuresById.get(measureId)!;
         return [
           measureId,
-          finalizeDiagnosticContributions(
-            contributions[measureId]!,
-            measure.missing,
-            blockers[measureId],
+          componentSharing.internOwned(
+            finalizeDiagnosticContributions(
+              contributions[measureId]!,
+              measure.missing,
+              blockers[measureId],
+            ),
+            "plain",
           ),
         ];
       }),
     ) as Record<string, DiagnosticMeasureStats>;
     for (const measureId of allMeasureIds) {
+      const stats = components[measureId]!;
+      // The finalized counts already prove whether any per-status finding is
+      // possible. Avoid allocating three empty partitions and a finding context
+      // for every clean observed measure in large aggregate datasets.
+      if (stats.missing === 0 && stats.nonFinite === 0 &&
+        !(stats.sum === null && stats.structural === 0)) continue;
       const measureContributions = contributions[measureId]!;
       const context = {
         measureId,
@@ -2445,6 +2625,7 @@ function prepareDiagnosticDataInMode(
         ),
     )
     .map((candidate) => candidate.row);
+  const compareAudits = createAuditComparator();
   const audit: DiagnosticInputAuditRecord[] = [
     ...lossCandidates.map((candidate): DiagnosticInputAuditRecord => ({
       kind: "loss",
@@ -2461,7 +2642,7 @@ function prepareDiagnosticDataInMode(
       disposition: candidate.disposition,
       record: candidate.snapshot,
     })),
-  ].sort(createAuditComparator());
+  ].sort(compareAudits);
   const normalizedFindings = mergeFindings(findings);
   const frozenCells = preparedCells.map((cell) => deepFreeze(cell));
   const cutoffValues = normalizedCutoffs.map((cutoff) => cutoff.value);
@@ -2483,6 +2664,58 @@ function prepareDiagnosticDataInMode(
       ...ownedData,
     }) as unknown as CompactPreparedDiagnosticData;
     authenticCompact.add(prepared);
+    if (definition.definition.lossRowGrain === "aggregate" && [...knownSourceGroups].every((group) => selectedBySource(filter, group)) &&
+      normalizedFindings.length === 0 && reconciled.every((exposure) => exposure.status === "valid")) {
+      const excluded = new Map<object, DiagnosticInputAuditRecord>();
+      lossCandidates.forEach((candidate, index) => {
+        const raw = rawLossSnapshots[index]!;
+        // Normalization changes only the coordinate labels in these snapshots.
+        // When those were canonical already, reuse the same complete record.
+        const record = raw.origin === candidate.snapshot.origin && raw.valuation === candidate.snapshot.valuation
+          ? candidate.snapshot : raw;
+        excluded.set(candidate.snapshot, deepFreeze({ kind: "loss", disposition: "filter", record }));
+      });
+      exposureCandidates.forEach((candidate, index) => {
+        const raw = rawExposureSnapshots[index]!;
+        const record = raw.origin === candidate.snapshot.origin && raw.valuation === candidate.snapshot.valuation
+          ? candidate.snapshot : raw;
+        excluded.set(candidate.snapshot, deepFreeze({ kind: "exposure", disposition: "filter", record }));
+      });
+      expectedCandidates.forEach((candidate) => excluded.set(candidate.snapshot, deepFreeze({
+        kind: "expected-cell", disposition: "filter", record: candidate.snapshot,
+      })));
+      // Rank every possible included/excluded audit variant once. Query sorts
+      // then use only numbers; canonical record strings live only in this
+      // preparation's comparator and are not retained by the context.
+      const originExcluded = new Map<object, DiagnosticInputAuditRecord>(audit.map((item) => [item.record,
+        deepFreeze({ ...item, disposition: "filter" as const })]));
+      const origins = new Map<string, DiagnosticNormalizedPeriod>();
+      for (const candidate of lossCandidates) if (candidate.coordinate)
+        origins.set(candidate.coordinate.origin.label, candidate.coordinate.origin);
+      for (const candidate of exposureCandidates) if (candidate.origin)
+        origins.set(candidate.origin.label, candidate.origin);
+      for (const candidate of expectedCandidates)
+        origins.set(candidate.coordinate.origin.label, candidate.coordinate.origin);
+      const orderedVariants = [...audit, ...excluded.values(), ...originExcluded.values()].sort(compareAudits);
+      const auditRanks = new Map(orderedVariants.map((item, index) => [item, index]));
+      const allOriginsSelected = [...origins.values()].every((origin) =>
+        selectedByOrigin(filter, origin, normalizedFilter.originCoordinates));
+      const valuations = new Map<string, DiagnosticNormalizedPeriod>();
+      let allCoordinatesSelected = true;
+      const rememberCoordinate = (valuation: DiagnosticNormalizedPeriod, age: number) => {
+        valuations.set(valuation.label, valuation);
+        if (!selectedByValuation(filter, valuation, normalizedFilter.valuationCoordinates) || !selectedByAge(filter, age))
+          allCoordinatesSelected = false;
+      };
+      for (const candidate of lossCandidates) if (candidate.coordinate)
+        rememberCoordinate(candidate.coordinate.valuation, candidate.coordinate.developmentAge);
+      for (const candidate of expectedCandidates)
+        rememberCoordinate(candidate.coordinate.valuation, candidate.coordinate.developmentAge);
+      for (const candidate of exposureCandidates) if (candidate.valuation !== null)
+        rememberCoordinate(candidate.valuation, candidate.developmentAge!);
+      sourceSelectionMetadata.set(prepared, { groups: knownSourceGroups, excluded, originExcluded,
+        origins, valuations, allOriginsSelected, allCoordinatesSelected, auditRanks });
+    }
     return prepared;
   }
   return createEagerPreparedDiagnosticData(definition, ownedData);

package/src/diagnosticReview.ts

@@ -18,12 +18,15 @@ import {
 import {
   assertPreparedDiagnosticData,
   assertCompactPreparedDiagnosticData,
+  getCompactSourceSelectionParent,
+  getCompactCoordinateSelectionParent,
   type CompactPreparedDiagnosticData,
   type PreparedDiagnosticDataContent,
   type PreparedDiagnosticData,
 } from "./diagnosticPreparation.js";
 import {
   createCompactReviewBuilder,
+  selectCompactReviewSources,
   type CompactDiagnosticReviewEvaluations,
 } from "./diagnosticReviewStore.js";
 import {
@@ -704,18 +707,32 @@ export function evaluateDiagnosticReviewRules(
   return Object.freeze(results);
 }
 
+const compactEvaluationCache = new WeakMap<CompactPreparedDiagnosticData, CompactDiagnosticReviewEvaluations>();
+
 /** Keeps every evaluation in compact owned storage; no identity is computed. */
 export function evaluateDiagnosticReviewRulesCompact(
   prepared: CompactPreparedDiagnosticData,
 ): CompactDiagnosticReviewEvaluations {
   assertCompactPreparedDiagnosticData(prepared);
+  const coordinateParent = getCompactCoordinateSelectionParent(prepared);
+  const parent = prepared.cells.length === 0 && prepared.expectedCells.length === 0
+    ? undefined : coordinateParent ?? getCompactSourceSelectionParent(prepared);
+  const invariant = parent
+    ? compactEvaluationCache.get(parent) ?? evaluateDiagnosticReviewRulesCompact(parent)
+    : undefined;
   const compactSources = createCompactCellSourceReader();
   const builder = createCompactReviewBuilder(
     prepared.definition.definition.reviewRules,
     compactSources,
   );
-  visitDiagnosticReviewRules(prepared, builder.append, compactSources);
-  return builder.finish();
+  visitDiagnosticReviewRules(prepared, builder.append, compactSources, invariant !== undefined, coordinateParent !== undefined);
+  const evaluated = builder.finish();
+  const result = invariant ? selectCompactReviewSources(invariant, evaluated,
+    prepared.filter?.sourceGroups === undefined ? undefined : new Set(prepared.filter.sourceGroups),
+    new Set([...prepared.cells.map((cell) => cell.origin), ...prepared.expectedCells.map((cell) => cell.origin)]),
+    coordinateParent ? new Set(prepared.cells.map((cell) => JSON.stringify([cell.sourceGroup, cell.origin, cell.valuation]))) : undefined) : evaluated;
+  compactEvaluationCache.set(prepared, result);
+  return result;
 }
 
 /** One traversal and one formula implementation serve both storage contracts. */
@@ -723,6 +740,8 @@ function visitDiagnosticReviewRules(
   prepared: PreparedDiagnosticDataContent,
   appendEvaluation: (value: DiagnosticReviewRuleEvaluation) => void,
   compactSources?: ReturnType<typeof createCompactCellSourceReader>,
+  controlsOnly = false,
+  includeMonotonic = false,
 ): void {
   const evaluateExpression = createCellExpressionEvaluator(
     prepared,
@@ -741,10 +760,11 @@ function visitDiagnosticReviewRules(
     origin: string,
     valuation: string,
   ) => canonicalJson([sourceGroup, origin, valuation]);
+  const monotonicGroups: Array<{ sourceGroup: string; origin: string; valuations: string[] }> = [];
   // Keep the original traversal and source order; only replace repeated searches.
   // Other rule families do not need these indices.
   if (
-    prepared.definition.definition.reviewRules.some(
+    (!controlsOnly || includeMonotonic) && prepared.definition.definition.reviewRules.some(
       (rule) => rule.kind === "monotonic",
     )
   ) {
@@ -759,11 +779,36 @@ function visitDiagnosticReviewRules(
       sources.push(cell.source);
       expectedSourcesByCoordinate.set(key, sources);
     }
+    // Grouping and valuation ordering depend on the selected preparation, not
+    // 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 values = groups.get(key) ?? new Set<string>();
+      values.add(cell.valuation);
+      groups.set(key, values);
+    }
+    const valuationCoordinates = new Map<string, number>();
+    const valuationCoordinate = (label: string) => {
+      let value = valuationCoordinates.get(label);
+      if (value === undefined) {
+        value = normalizeDiagnosticPeriod(prepared.definition, "valuation", label).coordinate;
+        valuationCoordinates.set(label, value);
+      }
+      return value;
+    };
+    for (const [key, values] of [...groups.entries()].sort(([left], [right]) => codeUnit(left, right))) {
+      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 });
+    }
   }
   for (const [ruleIndex, rule] of (
     prepared.definition.definition
       .reviewRules as unknown as readonly DiagnosticReviewRule[]
   ).entries()) {
+    if (controlsOnly && rule.kind !== "control-total" && !(includeMonotonic && rule.kind === "monotonic")) continue;
     const basePath = `/reviewRules/${ruleIndex}`;
     if (rule.kind === "control-total") {
       const cells = projectedCells(prepared, rule);
@@ -907,30 +952,7 @@ function visitDiagnosticReviewRules(
       continue;
     }
     if (rule.kind === "monotonic") {
-      const groups = new Map<string, Set<string>>();
-      for (const cell of prepared.cells) {
-        const key = canonicalJson([cell.sourceGroup, cell.origin]);
-        const values = groups.get(key) ?? new Set<string>();
-        values.add(cell.valuation);
-        groups.set(key, values);
-      }
-      for (const expected of prepared.expectedCells) {
-        const key = canonicalJson([expected.sourceGroup, expected.origin]);
-        const values = groups.get(key) ?? new Set<string>();
-        values.add(expected.valuation);
-        groups.set(key, values);
-      }
-      for (const [key, valuations] of [...groups.entries()].sort(
-        ([left], [right]) => codeUnit(left, right),
-      )) {
-        const [sourceGroup, origin] = JSON.parse(key) as [string, string];
-        const sorted = [...valuations].sort(
-          (left, right) =>
-            normalizeDiagnosticPeriod(prepared.definition, "valuation", left)
-              .coordinate -
-              normalizeDiagnosticPeriod(prepared.definition, "valuation", right)
-                .coordinate || codeUnit(left, right),
-        );
+      for (const { sourceGroup, origin, valuations: sorted } of monotonicGroups) {
         for (let index = 1; index < sorted.length; index++) {
           const previousValuation = sorted[index - 1]!;
           const currentValuation = sorted[index]!;

package/src/diagnosticReviewSources.ts

@@ -40,18 +40,28 @@ export function createDiagnosticReviewSourcePool() {
     return entry;
   };
   const collection = () => {
-    const entries = new Map<string, DiagnosticSourceLocation>();
+    // Most cell expressions cite one source row repeatedly across measures.
+    // Defer the union map and sorting until a second distinct source exists.
+    let first: SourceEntry | undefined;
+    let entries: Map<string, DiagnosticSourceLocation> | undefined;
     let owned = true;
     return {
       /** `fromPrepared` is private evaluator authority, not an input option. */
       add(value: DiagnosticSourceLocation, fromPrepared: boolean): void {
         const entry = sourceEntry(value, fromPrepared);
         owned &&= ownedSources.has(entry.value);
-        if (!entries.has(entry.key)) entries.set(entry.key, entry.value);
+        if (!first) first = entry;
+        else if (entries) {
+          if (!entries.has(entry.key)) entries.set(entry.key, entry.value);
+        } else if (entry.key !== first.key) {
+          entries = new Map([[first.key, first.value], [entry.key, entry.value]]);
+        }
       },
       finish(): readonly DiagnosticSourceLocation[] {
         const values = Object.freeze(
-          [...entries.values()].sort(compareDiagnosticSourceLocations),
+          entries
+            ? [...entries.values()].sort(compareDiagnosticSourceLocations)
+            : first ? [first.value] : [],
         );
         if (owned) ownedLists.add(values);
         return values;
@@ -61,6 +71,15 @@ export function createDiagnosticReviewSourcePool() {
   const union = (
     lists: readonly (readonly DiagnosticSourceLocation[])[],
   ): readonly DiagnosticSourceLocation[] => {
+    const first = lists[0];
+    // Repeated cell expressions often resolve to exactly the same owned source
+    // sequence. Reuse it without rebuilding a union or its builder list ID.
+    // Reference equality preserves full values and first representatives; no
+    // caller-frozen array or merely equal canonical fingerprint is trusted.
+    if (first && lists.every((values) => ownedLists.has(values) &&
+      values.length === first.length && values.every((value, index) => value === first[index]))) {
+      return first;
+    }
     const target = collection();
     for (const values of lists)
       for (const source of values) target.add(source, false);