@actuarial-ts/core 0.10.0 → 0.11.0

package/dist/diagnosticPreparation.js

@@ -1,11 +1,12 @@
 import { canonicalJson, fnv1a64 } from "./canonical.js";
-import { freezeDiagnosticGraph as deepFreeze } from "./diagnosticFreeze.js";
-import { createDiagnosticEvidenceInterner } from "./diagnosticEvidenceIntern.js";
+import { freezeDiagnosticGraph as deepFreeze, freezeOwnedDiagnosticGraph as deepFreezeOwned, } from "./diagnosticFreeze.js";
+import { auditRecordCanonicalJson } from "./diagnosticAuditText.js";
+import { canonicalScalarArrayJson } from "./diagnosticKeys.js";
 import { createDiagnosticIdentityArray, createDiagnosticIdentityObject, createDiagnosticIdentityValue, fingerprintDiagnosticIdentity, } from "./diagnosticIdentityStream.js";
 import { normalizeDiagnosticsFilterIdentity, projectDiagnosticIdentity, } from "./diagnosticIdentity.js";
 import { compareDiagnosticBlockers, compareDiagnosticContributions, compareDiagnosticFindings, } from "./diagnosticOrdering.js";
 import { assertCompiledDiagnosticDefinition, getCompiledDiagnosticDefinitionInternals, } from "./diagnosticDefinitions.js";
-import { auditedDiagnosticContribution, finalizeDiagnosticContributions, } from "./diagnosticAggregation.js";
+import { auditedDiagnosticContribution, createDiagnosticStatsInterner, finalizeDiagnosticContributionsInterned, ownedDiagnosticContribution, } from "./diagnosticAggregation.js";
 import { deriveDiagnosticClaimMeasuresWithAudit, } from "./diagnosticDerivations.js";
 import { compareDiagnosticPeriods, normalizeDiagnosticPeriod, } from "./diagnosticPeriods.js";
 import { auditDiagnosticNumber, reconcileDiagnosticExposures, } from "./diagnosticExposure.js";
@@ -39,6 +40,9 @@ export function reselectCompactDiagnosticMetrics(prepared, filter) {
         return undefined;
     const selected = Object.freeze({ ...prepared, filter: deepFreeze(normalized) });
     authenticCompact.add(selected);
+    const recordedGroups = preparedSourceGroups.get(prepared);
+    if (recordedGroups !== undefined)
+        preparedSourceGroups.set(selected, recordedGroups);
     const parent = sourceSelectionParents.get(prepared);
     const coordinateParent = coordinateSelectionParents.get(prepared);
     if (coordinateParent)
@@ -65,7 +69,7 @@ export function selectCompactDiagnosticCoordinates(prepared, filter) {
 }
 function selectCompactSourceScope(prepared, filter, allowOrigins, allowCoordinates = false) {
     assertCompactPreparedDiagnosticData(prepared);
-    const metadata = sourceSelectionMetadata.get(prepared);
+    const selection = sourceSelectionMetadata.get(prepared);
     const boundaryIssues = preparationBoundaryIssues({
         definition: prepared.definition, losses: [], exposures: [],
         ...(filter === undefined ? {} : { filter }),
@@ -73,12 +77,13 @@ function selectCompactSourceScope(prepared, filter, allowOrigins, allowCoordinat
     if (boundaryIssues.length)
         throw new DiagnosticValidationError(boundaryIssues);
     const issues = [];
-    const normalizedFilter = normalizeFilter(prepared.definition, filter, metadata?.groups ?? new Set(prepared.inputAudit.map((item) => item.record.sourceGroup)), issues);
+    const normalizedFilter = normalizeFilter(prepared.definition, filter, selection?.groups ?? new Set(prepared.inputAudit.map((item) => item.record.sourceGroup)), issues);
     const normalized = normalizedFilter.value;
     if (issues.length)
         throw new DiagnosticValidationError(issues);
-    if (!metadata)
+    if (!selection)
         return undefined;
+    const metadata = selection.load();
     if (allowOrigins && !metadata.allOriginsSelected)
         return undefined;
     if (allowCoordinates && !metadata.allCoordinatesSelected)
@@ -118,13 +123,13 @@ function selectCompactSourceScope(prepared, filter, allowOrigins, allowCoordinat
     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 sourceOrigins = allowCoordinates ? new Set(cells.map((cell) => sourceOriginKey(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]))
+            ? sourceOrigins.has(sourceOriginKey(exposure.sourceGroup, exposure.origin))
             : exposure.valuation !== undefined && coordinateKeys.has(cellKey(exposure.sourceGroup, exposure.origin, exposure.valuation));
         return matches ? [] : [exposureWithoutLossFinding(exposure)];
     }) : [];
@@ -138,6 +143,9 @@ function selectCompactSourceScope(prepared, filter, allowOrigins, allowCoordinat
         expectedCells: Object.freeze(prepared.expectedCells.filter((cell) => includes(cell.sourceGroup) && includesOrigin(cell.origin) && includesDate(cell.origin, cell.valuation))),
     });
     authenticCompact.add(selected);
+    const knownGroups = preparedSourceGroups.get(prepared);
+    if (knownGroups !== undefined)
+        preparedSourceGroups.set(selected, knownGroups);
     if (allowCoordinates)
         coordinateSelectionParents.set(selected, prepared);
     else
@@ -158,7 +166,36 @@ const authentic = new WeakSet();
 const authenticCompact = new WeakSet();
 const sourceSelectionParents = new WeakMap();
 const coordinateSelectionParents = new WeakMap();
+/**
+ * Selection ranks for every included/excluded audit variant are derived only
+ * from the preparation's own owned snapshots, so they are computed on the
+ * first source/origin/date query rather than for every preparation. The
+ * captured preparation state is released once the ranks exist.
+ */
+class LazySelectionMetadata {
+    groups;
+    #compute;
+    #value;
+    constructor(groups, compute) {
+        this.groups = groups;
+        this.#compute = compute;
+    }
+    load() {
+        if (this.#value === undefined) {
+            this.#value = this.#compute();
+            this.#compute = null;
+        }
+        return this.#value;
+    }
+}
 const sourceSelectionMetadata = new WeakMap();
+// Every source group present in a preparation's input rows, hence in its audit.
+// Selections keep the same audit records, so they share their parent's set.
+const preparedSourceGroups = new WeakMap();
+/** Source groups audited by an authentic preparation, when it recorded them. */
+export function getPreparedSourceGroups(prepared) {
+    return preparedSourceGroups.get(prepared);
+}
 const compactIdentityDocuments = new WeakMap();
 const compactFingerprints = new WeakMap();
 const identities = new WeakMap();
@@ -235,6 +272,71 @@ function own(record, key) {
 function uniqueSorted(values) {
     return [...new Set(values)].sort(codeUnit);
 }
+/** Own keys in code-unit order; skips the sort when insertion order already is. */
+function sortedKeys(record) {
+    const keys = Object.keys(record);
+    for (let index = 1; index < keys.length; index++)
+        if (keys[index - 1] > keys[index])
+            return keys.sort(codeUnit);
+    return keys;
+}
+/**
+ * Own-key copy in code-unit key order with each value mapped, built without
+ * entry pairs. A literal "__proto__" key stays own data, as Object.fromEntries
+ * would keep it.
+ */
+function sortedRecordCopy(record, map) {
+    const keys = sortedKeys(record);
+    const out = {};
+    for (let index = 0; index < keys.length; index++) {
+        const key = keys[index];
+        const value = map(record[key]);
+        if (key === "__proto__")
+            Object.defineProperty(out, key, {
+                value,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        else
+            out[key] = value;
+    }
+    return out;
+}
+/** Assigns own data even for a literal "__proto__" measure id. */
+function setMeasureEntry(record, id, value) {
+    if (id === "__proto__")
+        Object.defineProperty(record, id, {
+            value,
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    else
+        record[id] = value;
+}
+/** A fresh empty list per measure id, in id order; a literal "__proto__" id stays own data. */
+function emptyListsByMeasure(measureIds) {
+    const out = {};
+    for (let index = 0; index < measureIds.length; index++)
+        setMeasureEntry(out, measureIds[index], []);
+    return out;
+}
+/**
+ * One shared immutable empty list per measure id. A caller that needs to append
+ * must first replace the entry, so the shared list is never mutated; most cells
+ * never append at all and keep every entry pointing at it.
+ */
+function sharedEmptyListsByMeasure(measureIds, empty) {
+    const out = {};
+    for (let index = 0; index < measureIds.length; index++)
+        setMeasureEntry(out, measureIds[index], empty);
+    return out;
+}
+/** Internal coordinate keys: validated tokens never contain U+0000. */
+function sourceOriginKey(sourceGroup, origin) {
+    return `${sourceGroup}${origin}`;
+}
 function normalizeSources(values) {
     return normalizeDiagnosticSourceLocations(values);
 }
@@ -293,13 +395,8 @@ function mergeFindings(values) {
     }
     return [...merged.values()].sort(compareDiagnosticFindings);
 }
-function snapshotLoss(row) {
-    const measures = Object.fromEntries(Object.keys(row.measures)
-        .sort(codeUnit)
-        .map((measureId) => [
-        measureId,
-        auditDiagnosticNumber(row.measures[measureId] ?? null),
-    ]));
+function snapshotLoss(row, audited = auditDiagnosticNumber) {
+    const measures = sortedRecordCopy(row.measures, (value) => audited(value ?? null));
     return {
         recordId: row.recordId,
         rowType: row.rowType,
@@ -312,14 +409,14 @@ function snapshotLoss(row) {
         source: row.source === undefined ? null : { ...row.source },
     };
 }
-function snapshotExposure(row) {
+function snapshotExposure(row, audited = auditDiagnosticNumber) {
     return {
         key: row.key,
         sourceGroup: row.sourceGroup,
         origin: row.origin,
         valuation: row.valuation ?? null,
         measureId: row.measureId,
-        value: auditDiagnosticNumber(row.value),
+        value: audited(row.value),
         complete: row.complete,
         source: row.source === undefined ? null : { ...row.source },
     };
@@ -557,11 +654,9 @@ function coordinateFor(definition, originLabel, valuationLabel) {
         issue: null,
     };
 }
+/** Internal cell key: validated tokens and period labels never contain U+0000. */
 function cellKey(sourceGroup, origin, valuation) {
-    return canonicalJson([sourceGroup, origin, valuation]);
-}
-function parseCellKey(key) {
-    return JSON.parse(key);
+    return `${sourceGroup}${origin}${valuation}`;
 }
 function coordinateContext(candidate) {
     if (candidate.coordinate === null)
@@ -628,7 +723,7 @@ function commonCoordinate(candidates) {
     return keys.length === 1 ? coordinateContext(candidates[0]) : {};
 }
 function exposureIdentity(candidate) {
-    return canonicalJson(candidate.timing === "valuation-specific"
+    return canonicalScalarArrayJson(candidate.timing === "valuation-specific"
         ? [
             candidate.row.measureId,
             candidate.row.key,
@@ -657,33 +752,179 @@ function exposureCoordinateContext(candidates) {
     }
     return { sourceGroup: coherentSource[0], origin: coherentOrigin[0] };
 }
+const AUDIT_KIND_RANK = { loss: 0, exposure: 1, "expected-cell": 2 };
+const AUDIT_DISPOSITION_RANK = {
+    invalid: 0,
+    "complete-period-cutoff": 1,
+    filter: 2,
+    retained: 3,
+};
 function createAuditComparator() {
-    const rank = { loss: 0, exposure: 1, "expected-cell": 2 };
-    const disposition = {
-        invalid: 0,
-        "complete-period-cutoff": 1,
-        filter: 2,
-        retained: 3,
-    };
     // Audit snapshots are already owned and complete before sorting. Preserve the
     // exact canonical-text ordering, but serialize each compared record once.
     // Keep this memo local to the sort; it must not retain keys with the result.
-    const keys = new WeakMap();
+    // A strong table is released with the comparator and looks up faster than a
+    // weak one for the millions of comparisons a large audit sort performs.
+    const keys = new Map();
     const key = (record) => {
         const previous = keys.get(record);
         if (previous !== undefined)
             return previous;
-        const text = canonicalJson(record);
+        const text = auditRecordCanonicalJson(record);
         keys.set(record, text);
         return text;
     };
-    return (left, right) => rank[left.kind] - rank[right.kind] ||
-        (left.record === right.record ? 0 : codeUnit(key(left.record), key(right.record))) ||
-        disposition[left.disposition] - disposition[right.disposition];
+    return {
+        key,
+        compare: (left, right) => AUDIT_KIND_RANK[left.kind] - AUDIT_KIND_RANK[right.kind] ||
+            (left.record === right.record ? 0 : codeUnit(key(left.record), key(right.record))) ||
+            AUDIT_DISPOSITION_RANK[left.disposition] - AUDIT_DISPOSITION_RANK[right.disposition],
+    };
+}
+/**
+ * Sorts audit records in place by the comparator's order, comparing texts that
+ * were resolved once per record instead of looking each up on every comparison.
+ * The stable sort over the decorated rows yields exactly `audit.sort(compare)`.
+ */
+function sortAuditRecords(audit, order) {
+    const decorated = audit.map((item) => ({
+        item,
+        kind: AUDIT_KIND_RANK[item.kind],
+        disposition: AUDIT_DISPOSITION_RANK[item.disposition],
+        key: undefined,
+    }));
+    const keyOf = (row) => row.key ?? (row.key = order.key(row.item.record));
+    decorated.sort((left, right) => left.kind - right.kind ||
+        (left.item.record === right.item.record ? 0 : codeUnit(keyOf(left), keyOf(right))) ||
+        left.disposition - right.disposition);
+    for (let index = 0; index < decorated.length; index++)
+        audit[index] = decorated[index].item;
+}
+/**
+ * Every included/excluded audit variant in the comparator's order, built from
+ * the already sorted audit instead of re-sorting three copies of it. The audit
+ * holds each record once in comparator order, so when no two distinct records
+ * of one kind share a canonical text, the sorted variants are exactly: each
+ * audit record's variants in disposition order (stable for equal dispositions:
+ * the audit item, then its source-excluded, then its origin-excluded variant),
+ * with variants whose record is a re-labelled raw snapshot merged in by the
+ * same comparator. Any canonical-text tie falls back to the full stable sort.
+ * Exported for the equivalence test only.
+ */
+export function orderAuditVariants(audit, excluded, originExcluded, order) {
+    const everything = () => [...audit, ...excluded.values(), ...originExcluded.values()].sort(order.compare);
+    for (let index = 1; index < audit.length; index++) {
+        const previous = audit[index - 1];
+        const current = audit[index];
+        if (previous.kind === current.kind &&
+            previous.record !== current.record &&
+            order.key(previous.record) === order.key(current.record))
+            return everything();
+    }
+    const auditRecords = new Set();
+    for (const item of audit)
+        auditRecords.add(item.record);
+    const excludedByRecord = new Map();
+    const detached = [];
+    for (const variant of excluded.values()) {
+        if (auditRecords.has(variant.record))
+            excludedByRecord.set(variant.record, variant);
+        else
+            detached.push(variant);
+    }
+    if (detached.length > 0) {
+        const auditKeys = new Set(audit.map((item) => `${AUDIT_KIND_RANK[item.kind]}:${order.key(item.record)}`));
+        for (const variant of detached)
+            if (auditKeys.has(`${AUDIT_KIND_RANK[variant.kind]}:${order.key(variant.record)}`))
+                return everything();
+        detached.sort(order.compare);
+    }
+    const ordered = [];
+    let next = 0;
+    for (const item of audit) {
+        while (next < detached.length && order.compare(detached[next], item) < 0)
+            ordered.push(detached[next++]);
+        const variants = [item];
+        const excludedVariant = excludedByRecord.get(item.record);
+        if (excludedVariant !== undefined)
+            variants.push(excludedVariant);
+        const originVariant = originExcluded.get(item.record);
+        if (originVariant !== undefined)
+            variants.push(originVariant);
+        variants.sort((left, right) => AUDIT_DISPOSITION_RANK[left.disposition] - AUDIT_DISPOSITION_RANK[right.disposition]);
+        for (const variant of variants)
+            ordered.push(variant);
+    }
+    while (next < detached.length)
+        ordered.push(detached[next++]);
+    return ordered;
 }
 function isPlainRecord(value) {
     return isDiagnosticPlainRecord(value);
 }
+// Allowed-key sets and the exact path suffixes each row check reports under.
+// Both are constants, so a clean row allocates no path text at all: every
+// string below is built inside the branch that reports an issue.
+const PREPARATION_INPUT_KEYS = new Set([
+    "definition",
+    "losses",
+    "exposures",
+    "filter",
+    "completePeriodCutoffs",
+    "expectedCells",
+]);
+const LOSS_ROW_KEYS = new Set([
+    "rowType",
+    "recordId",
+    "claimId",
+    "sourceGroup",
+    "origin",
+    "valuation",
+    "complete",
+    "source",
+    "measures",
+]);
+const EXPOSURE_ROW_KEYS = new Set([
+    "key",
+    "sourceGroup",
+    "origin",
+    "valuation",
+    "measureId",
+    "value",
+    "complete",
+    "source",
+]);
+const SOURCE_LOCATION_KEYS = new Set([
+    "artifactId",
+    "sourceFile",
+    "sourceSheet",
+    "sourceRow",
+    "sourceCell",
+]);
+const FILTER_KEYS = new Set([
+    "sourceGroups",
+    "outputGroups",
+    "origins",
+    "originFrom",
+    "originThrough",
+    "valuations",
+    "valuationFrom",
+    "valuationThrough",
+    "minDevelopmentAge",
+    "maxDevelopmentAge",
+    "instanceIds",
+]);
+const CUTOFF_KEYS = new Set([
+    "sourceGroup",
+    "originThrough",
+    "valuationThrough",
+]);
+const EXPECTED_CELL_KEYS = new Set([
+    "sourceGroup",
+    "origin",
+    "valuation",
+    "source",
+]);
 function preparationBoundaryIssues(value) {
     const issues = [];
     if (!isPlainRecord(value))
@@ -696,27 +937,65 @@ function preparationBoundaryIssues(value) {
             },
         ];
     const issue = (domain, code, path, message) => issues.push({ domain, code, path, message });
+    /** Row path with a constant suffix, built only when an issue cites it. */
+    const at = (prefix, index, suffix) => `${prefix}[${index}]${suffix}`;
     const token = (item, path, domain = "input") => {
         if (typeof item !== "string")
             issue(domain, "invalid-type", path, "Expected a string");
         else if (!isDiagnosticToken(item))
             issue(domain, "invalid-string", path, "Expected a nonempty token with valid Unicode and no U+0000");
     };
+    /** `token` for a row field; the path text exists only for a reported issue. */
+    const tokenAt = (item, prefix, index, suffix, domain = "input") => {
+        if (typeof item === "string" && isDiagnosticToken(item))
+            return;
+        token(item, at(prefix, index, suffix), domain);
+    };
     const exactKeys = (item, allowed, path, domain) => {
         for (const key of Object.keys(item)) {
-            const keyPath = `${path}.${key}`;
-            if (!allowed.includes(key))
-                issue(domain, "unknown-key", keyPath, `Unknown key ${key}`);
+            if (!allowed.has(key))
+                issue(domain, "unknown-key", `${path}.${key}`, `Unknown key ${key}`);
             else if (item[key] === undefined)
-                issue(domain, "invalid-type", keyPath, "Explicit undefined is not allowed");
+                issue(domain, "invalid-type", `${path}.${key}`, "Explicit undefined is not allowed");
         }
     };
+    /** `exactKeys` for a row, keeping the same own-key order and messages. */
+    const exactKeysAt = (item, allowed, prefix, index, suffix, domain) => {
+        for (const key in item) {
+            if (!Object.hasOwn(item, key))
+                continue;
+            if (!allowed.has(key))
+                issue(domain, "unknown-key", `${at(prefix, index, suffix)}.${key}`, `Unknown key ${key}`);
+            else if (item[key] === undefined)
+                issue(domain, "invalid-type", `${at(prefix, index, suffix)}.${key}`, "Explicit undefined is not allowed");
+        }
+    };
+    /** Source of a row; every reported path lies under the row's `.source`. */
+    const sourceAt = (item, prefix, index) => {
+        if (!isPlainRecord(item)) {
+            issue("input", "invalid-type", at(prefix, index, ".source"), "Source location must be an object");
+            return;
+        }
+        exactKeysAt(item, SOURCE_LOCATION_KEYS, prefix, index, ".source", "input");
+        tokenAt(item.artifactId, prefix, index, ".source.artifactId");
+        if (item.sourceFile !== undefined)
+            tokenAt(item.sourceFile, prefix, index, ".source.sourceFile");
+        if (item.sourceSheet !== undefined)
+            tokenAt(item.sourceSheet, prefix, index, ".source.sourceSheet");
+        if (item.sourceCell !== undefined)
+            tokenAt(item.sourceCell, prefix, index, ".source.sourceCell");
+        if (item.sourceRow !== undefined &&
+            (typeof item.sourceRow !== "number" ||
+                !Number.isSafeInteger(item.sourceRow) ||
+                item.sourceRow < 0))
+            issue("input", "invalid-number", at(prefix, index, ".source.sourceRow"), "Source row must be a nonnegative safe integer");
+    };
     const source = (item, path) => {
         if (!isPlainRecord(item)) {
             issue("input", "invalid-type", path, "Source location must be an object");
             return;
         }
-        exactKeys(item, ["artifactId", "sourceFile", "sourceSheet", "sourceRow", "sourceCell"], path, "input");
+        exactKeys(item, SOURCE_LOCATION_KEYS, path, "input");
         token(item.artifactId, `${path}.artifactId`);
         for (const key of ["sourceFile", "sourceSheet", "sourceCell"])
             if (item[key] !== undefined)
@@ -734,101 +1013,68 @@ function preparationBoundaryIssues(value) {
         }
         return item;
     };
-    exactKeys(value, [
-        "definition",
-        "losses",
-        "exposures",
-        "filter",
-        "completePeriodCutoffs",
-        "expectedCells",
-    ], "$", "configuration");
-    for (const [index, raw] of array(value.losses, "$.losses", "input").entries()) {
-        const path = `$.losses[${index}]`;
+    exactKeys(value, PREPARATION_INPUT_KEYS, "$", "configuration");
+    const losses = array(value.losses, "$.losses", "input");
+    for (let index = 0; index < losses.length; index++) {
+        const raw = losses[index];
         if (!isPlainRecord(raw)) {
-            issue("input", "invalid-type", path, "Loss record must be an object");
+            issue("input", "invalid-type", at("$.losses", index, ""), "Loss record must be an object");
             continue;
         }
-        exactKeys(raw, [
-            "rowType",
-            "recordId",
-            "claimId",
-            "sourceGroup",
-            "origin",
-            "valuation",
-            "complete",
-            "source",
-            "measures",
-        ], path, "input");
+        exactKeysAt(raw, LOSS_ROW_KEYS, "$.losses", index, "", "input");
         if (raw.rowType !== "claim" && raw.rowType !== "aggregate")
-            issue("input", "invalid-type", `${path}.rowType`, "Loss row type must be claim or aggregate");
-        token(raw.recordId, `${path}.recordId`);
-        token(raw.sourceGroup, `${path}.sourceGroup`);
-        token(raw.origin, `${path}.origin`);
-        token(raw.valuation, `${path}.valuation`);
+            issue("input", "invalid-type", at("$.losses", index, ".rowType"), "Loss row type must be claim or aggregate");
+        tokenAt(raw.recordId, "$.losses", index, ".recordId");
+        tokenAt(raw.sourceGroup, "$.losses", index, ".sourceGroup");
+        tokenAt(raw.origin, "$.losses", index, ".origin");
+        tokenAt(raw.valuation, "$.losses", index, ".valuation");
         if (raw.rowType === "claim")
-            token(raw.claimId, `${path}.claimId`);
+            tokenAt(raw.claimId, "$.losses", index, ".claimId");
         else if (raw.claimId !== undefined)
-            issue("input", "unknown-key", `${path}.claimId`, "Aggregate loss rows cannot contain claimId");
+            issue("input", "unknown-key", at("$.losses", index, ".claimId"), "Aggregate loss rows cannot contain claimId");
         if (typeof raw.complete !== "boolean")
-            issue("input", "invalid-type", `${path}.complete`, "Loss completeness must be boolean");
+            issue("input", "invalid-type", at("$.losses", index, ".complete"), "Loss completeness must be boolean");
         if (raw.source !== undefined)
-            source(raw.source, `${path}.source`);
-        if (!isPlainRecord(raw.measures))
-            issue("input", "invalid-type", `${path}.measures`, "Measures must be an object");
+            sourceAt(raw.source, "$.losses", index);
+        const measures = raw.measures;
+        if (!isPlainRecord(measures))
+            issue("input", "invalid-type", at("$.losses", index, ".measures"), "Measures must be an object");
         else
-            for (const [measureId, amount] of Object.entries(raw.measures)) {
-                token(measureId, `${path}.measures`);
+            for (const measureId in measures) {
+                if (!Object.hasOwn(measures, measureId))
+                    continue;
+                tokenAt(measureId, "$.losses", index, ".measures");
+                const amount = measures[measureId];
                 if (amount !== null && typeof amount !== "number")
-                    issue("input", "invalid-type", `${path}.measures.${measureId}`, "Measure value must be a number or null");
+                    issue("input", "invalid-type", `${at("$.losses", index, ".measures")}.${measureId}`, "Measure value must be a number or null");
             }
     }
-    for (const [index, raw] of array(value.exposures, "$.exposures", "input").entries()) {
-        const path = `$.exposures[${index}]`;
+    const exposures = array(value.exposures, "$.exposures", "input");
+    for (let index = 0; index < exposures.length; index++) {
+        const raw = exposures[index];
         if (!isPlainRecord(raw)) {
-            issue("input", "invalid-type", path, "Exposure observation must be an object");
+            issue("input", "invalid-type", at("$.exposures", index, ""), "Exposure observation must be an object");
             continue;
         }
-        exactKeys(raw, [
-            "key",
-            "sourceGroup",
-            "origin",
-            "valuation",
-            "measureId",
-            "value",
-            "complete",
-            "source",
-        ], path, "input");
-        token(raw.key, `${path}.key`);
-        token(raw.sourceGroup, `${path}.sourceGroup`);
-        token(raw.origin, `${path}.origin`);
-        token(raw.measureId, `${path}.measureId`);
+        exactKeysAt(raw, EXPOSURE_ROW_KEYS, "$.exposures", index, "", "input");
+        tokenAt(raw.key, "$.exposures", index, ".key");
+        tokenAt(raw.sourceGroup, "$.exposures", index, ".sourceGroup");
+        tokenAt(raw.origin, "$.exposures", index, ".origin");
+        tokenAt(raw.measureId, "$.exposures", index, ".measureId");
         if (raw.valuation !== undefined)
-            token(raw.valuation, `${path}.valuation`);
+            tokenAt(raw.valuation, "$.exposures", index, ".valuation");
         if (raw.value !== null && typeof raw.value !== "number")
-            issue("input", "invalid-type", `${path}.value`, "Exposure value must be a number or null");
+            issue("input", "invalid-type", at("$.exposures", index, ".value"), "Exposure value must be a number or null");
         if (typeof raw.complete !== "boolean")
-            issue("input", "invalid-type", `${path}.complete`, "Exposure completeness must be boolean");
+            issue("input", "invalid-type", at("$.exposures", index, ".complete"), "Exposure completeness must be boolean");
         if (raw.source !== undefined)
-            source(raw.source, `${path}.source`);
+            sourceAt(raw.source, "$.exposures", index);
     }
     if (value.filter !== undefined && !isPlainRecord(value.filter))
         issue("configuration", "invalid-type", "$.filter", "Filter must be an object");
     if (isPlainRecord(value.filter)) {
         const filter = value.filter;
-        const keys = [
-            "sourceGroups",
-            "outputGroups",
-            "origins",
-            "originFrom",
-            "originThrough",
-            "valuations",
-            "valuationFrom",
-            "valuationThrough",
-            "minDevelopmentAge",
-            "maxDevelopmentAge",
-            "instanceIds",
-        ];
-        exactKeys(filter, keys, "$.filter", "configuration");
+        exactKeys(filter, FILTER_KEYS, "$.filter", "configuration");
         for (const key of [
             "sourceGroups",
             "outputGroups",
@@ -854,7 +1100,7 @@ function preparationBoundaryIssues(value) {
                 issue("configuration", "invalid-type", path, "Cutoff must be an object");
                 continue;
             }
-            exactKeys(raw, ["sourceGroup", "originThrough", "valuationThrough"], path, "configuration");
+            exactKeys(raw, CUTOFF_KEYS, path, "configuration");
             token(raw.sourceGroup, `${path}.sourceGroup`, "configuration");
             for (const key of ["originThrough", "valuationThrough"])
                 if (raw[key] !== null)
@@ -867,7 +1113,7 @@ function preparationBoundaryIssues(value) {
                 issue("configuration", "invalid-type", path, "Expected cell must be an object");
                 continue;
             }
-            exactKeys(raw, ["sourceGroup", "origin", "valuation", "source"], path, "configuration");
+            exactKeys(raw, EXPECTED_CELL_KEYS, path, "configuration");
             token(raw.sourceGroup, `${path}.sourceGroup`, "configuration");
             token(raw.origin, `${path}.origin`, "configuration");
             token(raw.valuation, `${path}.valuation`, "configuration");
@@ -974,17 +1220,28 @@ function prepareDiagnosticDataInMode(input, mode) {
     const filter = normalizedFilter.value;
     const findings = [];
     const pendingBlockers = [];
+    // Audited numbers are immutable scalar records repeated across rows; one
+    // owned instance per distinct value serves every snapshot of this preparation.
+    const auditedNumbers = new Map();
+    const auditedNumber = (value) => {
+        let audited = auditedNumbers.get(value);
+        if (audited === undefined) {
+            audited = auditDiagnosticNumber(value);
+            auditedNumbers.set(value, audited);
+        }
+        return audited;
+    };
+    // Source clones are complete once copied; freezing them here lets the owned
+    // freeze walk treat every citation list attached below as finished.
     const lossCandidates = input.losses.map((inputRow) => ({
         row: {
             ...inputRow,
             ...(inputRow.source === undefined
                 ? {}
-                : { source: { ...inputRow.source } }),
-            measures: Object.fromEntries(Object.keys(inputRow.measures)
-                .sort(codeUnit)
-                .map((key) => [key, inputRow.measures[key]])),
+                : { source: Object.freeze({ ...inputRow.source }) }),
+            measures: sortedRecordCopy(inputRow.measures, (value) => value),
         },
-        snapshot: snapshotLoss(inputRow),
+        snapshot: snapshotLoss(inputRow, auditedNumber),
         disposition: selectedBySource(filter, inputRow.sourceGroup)
             ? "retained"
             : "filter",
@@ -1009,8 +1266,6 @@ function prepareDiagnosticDataInMode(input, mode) {
                 sources: candidate.row.source ? [candidate.row.source] : [],
             }));
         }
-        if (origin !== null)
-            candidate.snapshot = { ...candidate.snapshot, origin: origin.label };
         try {
             valuation = normalizeDiagnosticPeriod(definition, "valuation", candidate.row.valuation);
         }
@@ -1023,7 +1278,20 @@ function prepareDiagnosticDataInMode(input, mode) {
                 sources: candidate.row.source ? [candidate.row.source] : [],
             }));
         }
-        if (valuation !== null)
+        // One snapshot copy carries every normalized label; overriding existing
+        // keys keeps the original key order exactly as successive copies did, and
+        // a snapshot whose labels were canonical already stays the same record.
+        const originChanged = origin !== null && candidate.snapshot.origin !== origin.label;
+        const valuationChanged = valuation !== null && candidate.snapshot.valuation !== valuation.label;
+        if (originChanged && valuationChanged)
+            candidate.snapshot = {
+                ...candidate.snapshot,
+                origin: origin.label,
+                valuation: valuation.label,
+            };
+        else if (originChanged)
+            candidate.snapshot = { ...candidate.snapshot, origin: origin.label };
+        else if (valuationChanged)
             candidate.snapshot = {
                 ...candidate.snapshot,
                 valuation: valuation.label,
@@ -1057,16 +1325,13 @@ function prepareDiagnosticDataInMode(input, mode) {
             developmentAge,
             ageUnit: definition.definition.periodAxis.ageUnit,
         };
-        candidate.row = {
-            ...candidate.row,
-            origin: origin.label,
-            valuation: valuation.label,
-        };
-        candidate.snapshot = {
-            ...candidate.snapshot,
-            origin: candidate.row.origin,
-            valuation: candidate.row.valuation,
-        };
+        // Canonical labels are the common case; copy only when a label changes.
+        if (candidate.row.origin !== origin.label || candidate.row.valuation !== valuation.label)
+            candidate.row = {
+                ...candidate.row,
+                origin: origin.label,
+                valuation: valuation.label,
+            };
         if (beyondCutoff(candidate, cutoffByGroup))
             candidate.disposition = "complete-period-cutoff";
         else if (!selectedByOrigin(filter, origin, normalizedFilter.originCoordinates) ||
@@ -1081,7 +1346,7 @@ function prepareDiagnosticDataInMode(input, mode) {
                 ? {}
                 : { source: { ...inputRow.source } }),
         },
-        snapshot: snapshotExposure(inputRow),
+        snapshot: snapshotExposure(inputRow, auditedNumber),
         disposition: selectedBySource(filter, inputRow.sourceGroup)
             ? "retained"
             : "filter",
@@ -1275,7 +1540,7 @@ function prepareDiagnosticDataInMode(input, mode) {
         const byClaim = new Map();
         for (const candidate of provisionalLosses) {
             const claimId = candidate.row.claimId;
-            addToMap(bySnapshot, canonicalJson([
+            addToMap(bySnapshot, canonicalScalarArrayJson([
                 claimId,
                 candidate.row.sourceGroup,
                 candidate.row.origin,
@@ -1289,7 +1554,7 @@ function prepareDiagnosticDataInMode(input, mode) {
                     claimId: cohort[0].row.claimId,
                 });
         for (const [claimId, cohort] of byClaim)
-            if (uniqueSorted(cohort.map((candidate) => canonicalJson([candidate.row.sourceGroup, candidate.row.origin]))).length > 1)
+            if (uniqueSorted(cohort.map((candidate) => canonicalScalarArrayJson([candidate.row.sourceGroup, candidate.row.origin]))).length > 1)
                 lossFindings("claim-identity-conflict", cohort, { claimId });
     }
     for (const candidate of provisionalLosses)
@@ -1332,7 +1597,7 @@ function prepareDiagnosticDataInMode(input, mode) {
     const invalidExposureBlockers = [];
     for (const exposure of reconciled) {
         const timing = internals.measuresById.get(exposure.measureId)?.exposureTiming;
-        const identity = canonicalJson(timing === "valuation-specific"
+        const identity = canonicalScalarArrayJson(timing === "valuation-specific"
             ? [
                 exposure.measureId,
                 exposure.key,
@@ -1381,14 +1646,24 @@ function prepareDiagnosticDataInMode(input, mode) {
         item,
     ]));
     const cellRows = new Map();
-    for (const candidate of retainedCandidates)
-        addToMap(cellRows, cellKey(candidate.row.sourceGroup, candidate.row.origin, candidate.row.valuation), derivedByRecord.get(candidate.row.recordId));
+    // The coordinate behind each cell key, so it is never parsed back from text.
+    const cellCoordinates = new Map();
+    for (const candidate of retainedCandidates) {
+        const key = cellKey(candidate.row.sourceGroup, candidate.row.origin, candidate.row.valuation);
+        if (!cellCoordinates.has(key))
+            cellCoordinates.set(key, [
+                candidate.row.sourceGroup,
+                candidate.row.origin,
+                candidate.row.valuation,
+            ]);
+        addToMap(cellRows, key, derivedByRecord.get(candidate.row.recordId));
+    }
     // Exposure attachment is a coordinate join. Index the established cell order
     // once; scanning every cell for each origin-static exposure is quadratic.
     const cellKeysBySourceOrigin = new Map();
     for (const key of cellRows.keys()) {
-        const [sourceGroup, origin] = parseCellKey(key);
-        addToMap(cellKeysBySourceOrigin, canonicalJson([sourceGroup, origin]), key);
+        const [sourceGroup, origin] = cellCoordinates.get(key);
+        addToMap(cellKeysBySourceOrigin, sourceOriginKey(sourceGroup, origin), key);
     }
     const allMeasureIds = definition.definition.measures
         .map((measure) => measure.id)
@@ -1409,7 +1684,7 @@ function prepareDiagnosticDataInMode(input, mode) {
             if (candidate.timing === "valuation-specific" && candidate.valuation)
                 targets.add(cellKey(candidate.row.sourceGroup, candidate.origin.label, candidate.valuation.label));
             else
-                for (const key of cellKeysBySourceOrigin.get(canonicalJson([candidate.row.sourceGroup, candidate.origin.label])) ?? [])
+                for (const key of cellKeysBySourceOrigin.get(sourceOriginKey(candidate.row.sourceGroup, candidate.origin.label)) ?? [])
                     targets.add(key);
         }
         for (const key of targets) {
@@ -1433,7 +1708,7 @@ function prepareDiagnosticDataInMode(input, mode) {
             ? null
             : cellKey(exposure.sourceGroup, exposure.origin, exposure.valuation);
         const keys = timing === "origin-static"
-            ? (cellKeysBySourceOrigin.get(canonicalJson([exposure.sourceGroup, exposure.origin])) ?? [])
+            ? (cellKeysBySourceOrigin.get(sourceOriginKey(exposure.sourceGroup, exposure.origin)) ?? [])
             : coordinateKey !== null && cellRows.has(coordinateKey)
                 ? [coordinateKey]
                 : [];
@@ -1450,18 +1725,27 @@ function prepareDiagnosticDataInMode(input, mode) {
     // 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();
+    const componentSharing = createDiagnosticStatsInterner();
+    // Clean cells share immutable empties; readers only iterate these lists.
+    const noBlockers = Object.freeze([]);
+    const noFindings = Object.freeze([]);
     for (const [key, rows] of cellRows) {
-        const [sourceGroup, origin, valuation] = parseCellKey(key);
+        const coordinates = cellCoordinates.get(key);
+        const sourceGroup = coordinates[0];
+        const origin = coordinates[1];
+        const valuation = coordinates[2];
         const coordinate = coordinateFor(definition, origin, valuation).coordinate;
-        const contributions = Object.fromEntries(allMeasureIds.map((measureId) => [
-            measureId,
-            [],
-        ]));
-        const blockers = Object.fromEntries(allMeasureIds.map((measureId) => [
-            measureId,
-            [],
-        ]));
+        const contributions = emptyListsByMeasure(allMeasureIds);
+        // Structural blockers are rare; every measure starts on the shared empty
+        // list and only a measure that actually gets one allocates its own.
+        const blockers = sharedEmptyListsByMeasure(allMeasureIds, noBlockers);
+        const addBlocker = (measureId, blocker) => {
+            const existing = blockers[measureId];
+            if (existing === noBlockers)
+                setMeasureEntry(blockers, measureId, [blocker]);
+            else
+                existing.push(blocker);
+        };
         const cellFindings = [];
         const derivedContribution = (row, missingPolicy, state) => {
             const base = {
@@ -1482,8 +1766,12 @@ function prepareDiagnosticDataInMode(input, mode) {
                 ? { ...base, status: "imputed-zero", value: 0 }
                 : { ...base, status: "missing", value: null };
         };
-        for (const row of rows)
-            for (const measure of nonExposureMeasures) {
+        for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+            const row = rows[rowIndex];
+            // One frozen citation list per row serves every measure it contributes to.
+            const rowSources = Object.freeze(row.source ? [row.source] : []);
+            for (let at = 0; at < nonExposureMeasures.length; at++) {
+                const measure = nonExposureMeasures[at];
                 if (measure.source === "derived") {
                     const state = derivedAuditByRecord.get(row.recordId).derived[measure.id];
                     contributions[measure.id].push(derivedContribution(row, measure.missing, state));
@@ -1507,8 +1795,9 @@ function prepareDiagnosticDataInMode(input, mode) {
                     }
                 }
                 else
-                    contributions[measure.id].push(auditedDiagnosticContribution(row.recordId, own(row.measures, measure.id), measure.missing, row.source ? [row.source] : []));
+                    contributions[measure.id].push(ownedDiagnosticContribution(row.recordId, own(row.measures, measure.id), measure.missing, rowSources));
             }
+        }
         const attachedExposures = validExposuresByCell.get(key) ?? [];
         for (const exposure of attachedExposures)
             contributions[exposure.measureId].push(auditedDiagnosticContribution(exposure.key, exposure.value, "unknown", exposure.sources, exposure.deduplicated));
@@ -1522,7 +1811,7 @@ function prepareDiagnosticDataInMode(input, mode) {
                 finding: pending.finding,
             };
             for (const measureId of pending.measureIds)
-                blockers[measureId].push(blocker);
+                addBlocker(measureId, blocker);
         }
         for (const measure of exposureMeasures) {
             const attempted = attachedExposures.some((exposure) => exposure.measureId === measure.id) || invalidExposureMeasuresByCell.get(key)?.has(measure.id);
@@ -1539,7 +1828,7 @@ function prepareDiagnosticDataInMode(input, mode) {
                 });
                 findings.push(finding);
                 cellFindings.push(finding);
-                blockers[measure.id].push({
+                addBlocker(measure.id, {
                     code: finding.code,
                     message: finding.message,
                     sourceIds: uniqueSorted(rows.map((row) => row.recordId)),
@@ -1549,21 +1838,29 @@ function prepareDiagnosticDataInMode(input, mode) {
             }
         }
         for (const measureId of allMeasureIds) {
-            blockers[measureId] = [
-                ...new Map(blockers[measureId].map((blocker) => [
-                    canonicalJson(blocker),
-                    blocker,
-                ])).values(),
-            ].sort(compareDiagnosticBlockers);
-            contributions[measureId].sort(compareDiagnosticContributions);
+            const measureBlockers = blockers[measureId];
+            if (measureBlockers.length > 0)
+                setMeasureEntry(blockers, measureId, [
+                    ...new Map(measureBlockers.map((blocker) => [canonicalJson(blocker), blocker])).values(),
+                ].sort(compareDiagnosticBlockers));
+            if (contributions[measureId].length > 1)
+                contributions[measureId].sort(compareDiagnosticContributions);
         }
-        const components = Object.fromEntries(allMeasureIds.map((measureId) => {
+        const components = {};
+        for (let at = 0; at < allMeasureIds.length; at++) {
+            const measureId = allMeasureIds[at];
             const measure = internals.measuresById.get(measureId);
-            return [
-                measureId,
-                componentSharing.internOwned(finalizeDiagnosticContributions(contributions[measureId], measure.missing, blockers[measureId]), "plain"),
-            ];
-        }));
+            const stats = finalizeDiagnosticContributionsInterned(contributions[measureId], measure.missing, blockers[measureId], componentSharing);
+            if (measureId === "__proto__")
+                Object.defineProperty(components, measureId, {
+                    value: stats,
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            else
+                components[measureId] = stats;
+        }
         for (const measureId of allMeasureIds) {
             const stats = components[measureId];
             // The finalized counts already prove whether any per-status finding is
@@ -1614,11 +1911,13 @@ function prepareDiagnosticDataInMode(input, mode) {
             valuation,
             developmentAge: coordinate.developmentAge,
             ageUnit: coordinate.ageUnit,
-            lossRecordIds: uniqueSorted(rows.map((row) => row.recordId)),
+            lossRecordIds: rows.length === 1
+                ? [rows[0].recordId]
+                : uniqueSorted(rows.map((row) => row.recordId)),
             contributions,
             components,
             structuralBlockers: blockers,
-            findings: mergeFindings(cellFindings),
+            findings: cellFindings.length === 0 ? noFindings : mergeFindings(cellFindings),
         });
     }
     for (const candidate of expectedCandidates.filter((item) => item.disposition === "retained")) {
@@ -1653,7 +1952,7 @@ function prepareDiagnosticDataInMode(input, mode) {
         compareDiagnosticPeriods(left.coordinate.origin, right.coordinate.origin) ||
         compareDiagnosticPeriods(left.coordinate.valuation, right.coordinate.valuation))
         .map((candidate) => candidate.row);
-    const compareAudits = createAuditComparator();
+    const auditOrder = createAuditComparator();
     const audit = [
         ...lossCandidates.map((candidate) => ({
             kind: "loss",
@@ -1670,20 +1969,26 @@ function prepareDiagnosticDataInMode(input, mode) {
             disposition: candidate.disposition,
             record: candidate.snapshot,
         })),
-    ].sort(compareAudits);
+    ];
+    sortAuditRecords(audit, auditOrder);
     const normalizedFindings = mergeFindings(findings);
-    const frozenCells = preparedCells.map((cell) => deepFreeze(cell));
+    // Freeze each owned graph exactly once. Cells dominate large preparations;
+    // walking them a second time from the envelope would double the cost, and
+    // their shared children (contributions, statistics, citation lists, audited
+    // numbers, empty records) were attached frozen and complete, so the owned
+    // walk skips them instead of re-visiting each per reference.
+    const frozenCells = Object.freeze(preparedCells.map((cell) => deepFreezeOwned(cell)));
     const cutoffValues = normalizedCutoffs.map((cutoff) => cutoff.value);
-    const ownedData = deepFreeze({
+    const ownedData = Object.freeze({
         definitionIntegrity: definition.definitionIntegrity,
-        filter,
-        completePeriodCutoffs: cutoffValues,
-        inputAudit: audit,
+        filter: deepFreeze(filter),
+        completePeriodCutoffs: deepFreeze(cutoffValues),
+        inputAudit: deepFreezeOwned(audit),
         cells: frozenCells,
-        exposures: reconciled,
+        exposures: deepFreeze(reconciled),
         expectedCellsProvided: input.expectedCells !== undefined,
-        expectedCells,
-        findings: normalizedFindings,
+        expectedCells: deepFreeze(expectedCells),
+        findings: deepFreeze(normalizedFindings),
     });
     if (mode === "compact") {
         // Every child was frozen above (the compiled definition owns its snapshot).
@@ -1692,64 +1997,72 @@ function prepareDiagnosticDataInMode(input, mode) {
             ...ownedData,
         });
         authenticCompact.add(prepared);
+        preparedSourceGroups.set(prepared, knownSourceGroups);
         if (definition.definition.lossRowGrain === "aggregate" && [...knownSourceGroups].every((group) => selectedBySource(filter, group)) &&
             normalizedFindings.length === 0 && reconciled.every((exposure) => exposure.status === "valid")) {
-            const excluded = new Map();
-            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(audit.map((item) => [item.record,
-                deepFreeze({ ...item, disposition: "filter" })]));
-            const origins = new Map();
-            for (const candidate of lossCandidates)
-                if (candidate.coordinate)
+            const computeSelectionMetadata = () => {
+                const excluded = new Map();
+                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.
+                    // Raw snapshots were never attached to the audit, so freeze them here.
+                    const record = raw.origin === candidate.snapshot.origin && raw.valuation === candidate.snapshot.valuation
+                        ? candidate.snapshot : deepFreeze(raw);
+                    excluded.set(candidate.snapshot, Object.freeze({ 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 : deepFreeze(raw);
+                    excluded.set(candidate.snapshot, Object.freeze({ kind: "exposure", disposition: "filter", record }));
+                });
+                expectedCandidates.forEach((candidate) => excluded.set(candidate.snapshot, Object.freeze({
+                    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. Every
+                // audit record was deeply frozen with the envelope above.
+                const originExcluded = new Map(audit.map((item) => [item.record,
+                    Object.freeze({ ...item, disposition: "filter" })]));
+                const origins = new Map();
+                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);
-            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();
-            let allCoordinatesSelected = true;
-            const rememberCoordinate = (valuation, age) => {
-                valuations.set(valuation.label, valuation);
-                if (!selectedByValuation(filter, valuation, normalizedFilter.valuationCoordinates) || !selectedByAge(filter, age))
-                    allCoordinatesSelected = false;
-            };
-            for (const candidate of lossCandidates)
-                if (candidate.coordinate)
+                const orderedVariants = orderAuditVariants(audit, excluded, originExcluded, auditOrder);
+                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();
+                let allCoordinatesSelected = true;
+                const rememberCoordinate = (valuation, age) => {
+                    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 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 });
+                for (const candidate of exposureCandidates)
+                    if (candidate.valuation !== null)
+                        rememberCoordinate(candidate.valuation, candidate.developmentAge);
+                return { excluded, originExcluded, origins, valuations, allOriginsSelected,
+                    allCoordinatesSelected, auditRanks };
+            };
+            sourceSelectionMetadata.set(prepared, new LazySelectionMetadata(knownSourceGroups, computeSelectionMetadata));
         }
         return prepared;
     }
-    return createEagerPreparedDiagnosticData(definition, ownedData);
+    const eager = createEagerPreparedDiagnosticData(definition, ownedData);
+    preparedSourceGroups.set(eager, knownSourceGroups);
+    return eager;
 }
 function createEagerPreparedDiagnosticData(definition, ownedData) {
     const identity = projectDiagnosticIdentity({