@actuarial-ts/core 0.10.0 → 0.11.0

package/src/diagnosticPreparation.ts

@@ -1,6 +1,10 @@
 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,
@@ -32,7 +36,9 @@ import {
 } from "./diagnosticDefinitions.js";
 import {
   auditedDiagnosticContribution,
-  finalizeDiagnosticContributions,
+  createDiagnosticStatsInterner,
+  finalizeDiagnosticContributionsInterned,
+  ownedDiagnosticContribution,
   type DiagnosticMeasureContribution,
   type DiagnosticStructuralBlocker,
 } from "./diagnosticAggregation.js";
@@ -233,6 +239,8 @@ export function reselectCompactDiagnosticMetrics(
   if (sourceScope(normalized) !== sourceScope(prepared.filter)) return undefined;
   const selected = Object.freeze({ ...prepared, filter: deepFreeze(normalized) }) as CompactPreparedDiagnosticData;
   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) coordinateSelectionParents.set(selected, coordinateParent);
@@ -276,7 +284,7 @@ function selectCompactSourceScope(
   allowCoordinates = false,
 ): CompactPreparedDiagnosticData | undefined {
   assertCompactPreparedDiagnosticData(prepared);
-  const metadata = sourceSelectionMetadata.get(prepared);
+  const selection = sourceSelectionMetadata.get(prepared);
   const boundaryIssues = preparationBoundaryIssues({
     definition: prepared.definition, losses: [], exposures: [],
     ...(filter === undefined ? {} : { filter }),
@@ -284,10 +292,11 @@ function selectCompactSourceScope(
   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);
+    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) return undefined;
+  if (!selection) return undefined;
+  const metadata = selection.load();
   if (allowOrigins && !metadata.allOriginsSelected) return undefined;
   if (allowCoordinates && !metadata.allCoordinatesSelected) return undefined;
   const remainingScope = (value: DiagnosticsFilter | null) => {
@@ -323,12 +332,12 @@ function selectCompactSourceScope(
   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)];
   }) : [];
@@ -342,6 +351,8 @@ function selectCompactSourceScope(
     expectedCells: Object.freeze(prepared.expectedCells.filter((cell) => includes(cell.sourceGroup) && includesOrigin(cell.origin) && includesDate(cell.origin, cell.valuation))),
   }) as CompactPreparedDiagnosticData;
   authenticCompact.add(selected);
+  const knownGroups = preparedSourceGroups.get(prepared);
+  if (knownGroups !== undefined) preparedSourceGroups.set(selected, knownGroups);
   if (allowCoordinates) coordinateSelectionParents.set(selected, prepared);
   else sourceSelectionParents.set(selected, prepared);
   return selected;
@@ -433,16 +444,46 @@ 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>;
-}>();
+interface CompactSelectionMetadata {
+  readonly excluded: ReadonlyMap<object, DiagnosticInputAuditRecord>;
+  readonly originExcluded: ReadonlyMap<object, DiagnosticInputAuditRecord>;
+  readonly origins: ReadonlyMap<string, DiagnosticNormalizedPeriod>;
+  readonly valuations: ReadonlyMap<string, DiagnosticNormalizedPeriod>;
+  readonly allOriginsSelected: boolean;
+  readonly allCoordinatesSelected: boolean;
+  readonly auditRanks: ReadonlyMap<DiagnosticInputAuditRecord, number>;
+}
+/**
+ * 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 {
+  #compute: (() => CompactSelectionMetadata) | null;
+  #value: CompactSelectionMetadata | undefined;
+  constructor(
+    readonly groups: ReadonlySet<string>,
+    compute: () => CompactSelectionMetadata,
+  ) {
+    this.#compute = compute;
+  }
+  load(): CompactSelectionMetadata {
+    if (this.#value === undefined) {
+      this.#value = this.#compute!();
+      this.#compute = null;
+    }
+    return this.#value;
+  }
+}
+const sourceSelectionMetadata = new WeakMap<CompactPreparedDiagnosticData, LazySelectionMetadata>();
+// 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<object, ReadonlySet<string>>();
+/** Source groups audited by an authentic preparation, when it recorded them. */
+export function getPreparedSourceGroups(prepared: object): ReadonlySet<string> | undefined {
+  return preparedSourceGroups.get(prepared);
+}
 const compactIdentityDocuments = new WeakMap<
   object,
   DiagnosticIdentityDocument
@@ -535,6 +576,80 @@ function uniqueSorted(values: readonly string[]): string[] {
   return [...new Set(values)].sort(codeUnit);
 }
 
+/** Own keys in code-unit order; skips the sort when insertion order already is. */
+function sortedKeys(record: object): string[] {
+  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<T, U>(
+  record: Readonly<Record<string, T>>,
+  map: (value: T) => U,
+): Record<string, U> {
+  const keys = sortedKeys(record);
+  const out: Record<string, U> = {};
+  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<T>(record: Record<string, T>, id: string, value: T): void {
+  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<T>(measureIds: readonly string[]): Record<string, T[]> {
+  const out: Record<string, T[]> = {};
+  for (let index = 0; index < measureIds.length; index++)
+    setMeasureEntry(out, measureIds[index]!, [] as T[]);
+  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<T>(
+  measureIds: readonly string[],
+  empty: readonly T[],
+): Record<string, readonly T[]> {
+  const out: Record<string, readonly T[]> = {};
+  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: string, origin: string): string {
+  return `${sourceGroup}${origin}`;
+}
+
 function normalizeSources(
   values: readonly (DiagnosticSourceLocation | undefined | null)[],
 ): DiagnosticSourceLocation[] {
@@ -625,15 +740,9 @@ function mergeFindings(
 
 function snapshotLoss(
   row: DiagnosticLossInput,
+  audited: (value: number | null) => DiagnosticAuditedNumericValue = auditDiagnosticNumber,
 ): DiagnosticLossInputAuditSnapshot {
-  const measures = Object.fromEntries(
-    Object.keys(row.measures)
-      .sort(codeUnit)
-      .map((measureId) => [
-        measureId,
-        auditDiagnosticNumber(row.measures[measureId] ?? null),
-      ]),
-  );
+  const measures = sortedRecordCopy(row.measures, (value) => audited(value ?? null));
   return {
     recordId: row.recordId,
     rowType: row.rowType,
@@ -649,6 +758,7 @@ function snapshotLoss(
 
 function snapshotExposure(
   row: DiagnosticExposureObservation,
+  audited: (value: number | null) => DiagnosticAuditedNumericValue = auditDiagnosticNumber,
 ): DiagnosticExposureInputAuditSnapshot {
   return {
     key: row.key,
@@ -656,7 +766,7 @@ function snapshotExposure(
     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 },
   };
@@ -1007,16 +1117,13 @@ function coordinateFor(
   };
 }
 
+/** Internal cell key: validated tokens and period labels never contain U+0000. */
 function cellKey(
   sourceGroup: string,
   origin: string,
   valuation: string,
 ): string {
-  return canonicalJson([sourceGroup, origin, valuation]);
-}
-
-function parseCellKey(key: string): readonly [string, string, string] {
-  return JSON.parse(key) as [string, string, string];
+  return `${sourceGroup}${origin}${valuation}`;
 }
 
 function coordinateContext(candidate: {
@@ -1141,7 +1248,7 @@ function commonCoordinate(
 }
 
 function exposureIdentity(candidate: ExposureCandidate): string {
-  return canonicalJson(
+  return canonicalScalarArrayJson(
     candidate.timing === "valuation-specific"
       ? [
           candidate.row.measureId,
@@ -1187,38 +1294,212 @@ function exposureCoordinateContext(
   return { sourceGroup: coherentSource[0], origin: coherentOrigin[0] };
 }
 
-function createAuditComparator(): (
-  left: DiagnosticInputAuditRecord,
-  right: DiagnosticInputAuditRecord,
-) => number {
-  const rank = { loss: 0, exposure: 1, "expected-cell": 2 } as const;
-  const disposition = {
-    invalid: 0,
-    "complete-period-cutoff": 1,
-    filter: 2,
-    retained: 3,
-  } as const;
+const AUDIT_KIND_RANK = { loss: 0, exposure: 1, "expected-cell": 2 } as const;
+const AUDIT_DISPOSITION_RANK = {
+  invalid: 0,
+  "complete-period-cutoff": 1,
+  filter: 2,
+  retained: 3,
+} as const;
+
+export interface DiagnosticAuditOrder {
+  readonly compare: (
+    left: DiagnosticInputAuditRecord,
+    right: DiagnosticInputAuditRecord,
+  ) => number;
+  /** Canonical text of a record, serialized once per record for this order. */
+  readonly key: (record: DiagnosticInputAuditRecord["record"]) => string;
+}
+
+function createAuditComparator(): DiagnosticAuditOrder {
   // 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<DiagnosticInputAuditRecord["record"], string>();
+  // 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<DiagnosticInputAuditRecord["record"], string>();
   const key = (record: DiagnosticInputAuditRecord["record"]): string => {
     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: DiagnosticInputAuditRecord[],
+  order: DiagnosticAuditOrder,
+): void {
+  interface Row {
+    readonly item: DiagnosticInputAuditRecord;
+    readonly kind: number;
+    readonly disposition: number;
+    /** Canonical text, resolved the first time a comparison needs it. */
+    key: string | undefined;
+  }
+  const decorated: Row[] = audit.map((item) => ({
+    item,
+    kind: AUDIT_KIND_RANK[item.kind],
+    disposition: AUDIT_DISPOSITION_RANK[item.disposition],
+    key: undefined,
+  }));
+  const keyOf = (row: Row): string => 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: readonly DiagnosticInputAuditRecord[],
+  excluded: ReadonlyMap<object, DiagnosticInputAuditRecord>,
+  originExcluded: ReadonlyMap<object, DiagnosticInputAuditRecord>,
+  order: DiagnosticAuditOrder,
+): DiagnosticInputAuditRecord[] {
+  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<object>();
+  for (const item of audit) auditRecords.add(item.record);
+  const excludedByRecord = new Map<object, DiagnosticInputAuditRecord>();
+  const detached: DiagnosticInputAuditRecord[] = [];
+  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: DiagnosticInputAuditRecord[] = [];
+  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: unknown): value is Record<string, unknown> {
   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: ReadonlySet<string> = new Set([
+  "definition",
+  "losses",
+  "exposures",
+  "filter",
+  "completePeriodCutoffs",
+  "expectedCells",
+]);
+const LOSS_ROW_KEYS: ReadonlySet<string> = new Set([
+  "rowType",
+  "recordId",
+  "claimId",
+  "sourceGroup",
+  "origin",
+  "valuation",
+  "complete",
+  "source",
+  "measures",
+]);
+const EXPOSURE_ROW_KEYS: ReadonlySet<string> = new Set([
+  "key",
+  "sourceGroup",
+  "origin",
+  "valuation",
+  "measureId",
+  "value",
+  "complete",
+  "source",
+]);
+const SOURCE_LOCATION_KEYS: ReadonlySet<string> = new Set([
+  "artifactId",
+  "sourceFile",
+  "sourceSheet",
+  "sourceRow",
+  "sourceCell",
+]);
+const FILTER_KEYS: ReadonlySet<string> = new Set([
+  "sourceGroups",
+  "outputGroups",
+  "origins",
+  "originFrom",
+  "originThrough",
+  "valuations",
+  "valuationFrom",
+  "valuationThrough",
+  "minDevelopmentAge",
+  "maxDevelopmentAge",
+  "instanceIds",
+]);
+const CUTOFF_KEYS: ReadonlySet<string> = new Set([
+  "sourceGroup",
+  "originThrough",
+  "valuationThrough",
+]);
+const EXPECTED_CELL_KEYS: ReadonlySet<string> = new Set([
+  "sourceGroup",
+  "origin",
+  "valuation",
+  "source",
+]);
+
 function preparationBoundaryIssues(
   value: unknown,
 ): DiagnosticValidationIssue[] {
@@ -1238,6 +1519,9 @@ function preparationBoundaryIssues(
     path: string,
     message: string,
   ) => issues.push({ domain, code, path, message });
+  /** Row path with a constant suffix, built only when an issue cites it. */
+  const at = (prefix: string, index: number, suffix: string) =>
+    `${prefix}[${index}]${suffix}`;
   const token = (
     item: unknown,
     path: string,
@@ -1253,36 +1537,100 @@ function preparationBoundaryIssues(
         "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: unknown,
+    prefix: string,
+    index: number,
+    suffix: string,
+    domain: "input" | "configuration" = "input",
+  ) => {
+    if (typeof item === "string" && isDiagnosticToken(item)) return;
+    token(item, at(prefix, index, suffix), domain);
+  };
   const exactKeys = (
     item: Record<string, unknown>,
-    allowed: readonly string[],
+    allowed: ReadonlySet<string>,
     path: string,
     domain: "input" | "configuration",
   ) => {
     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,
+          `${path}.${key}`,
           "Explicit undefined is not allowed",
         );
     }
   };
+  /** `exactKeys` for a row, keeping the same own-key order and messages. */
+  const exactKeysAt = (
+    item: Record<string, unknown>,
+    allowed: ReadonlySet<string>,
+    prefix: string,
+    index: number,
+    suffix: string,
+    domain: "input" | "configuration",
+  ) => {
+    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: unknown, prefix: string, index: number) => {
+    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: unknown, path: string) => {
     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"] as const)
       if (item[key] !== undefined) token(item[key], `${path}.${key}`);
@@ -1310,141 +1658,104 @@ function preparationBoundaryIssues(
     }
     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: unknown = 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`,
+        at("$.losses", index, ".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`);
-    if (raw.rowType === "claim") token(raw.claimId, `${path}.claimId`);
+    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")
+      tokenAt(raw.claimId, "$.losses", index, ".claimId");
     else if (raw.claimId !== undefined)
       issue(
         "input",
         "unknown-key",
-        `${path}.claimId`,
+        at("$.losses", index, ".claimId"),
         "Aggregate loss rows cannot contain claimId",
       );
     if (typeof raw.complete !== "boolean")
       issue(
         "input",
         "invalid-type",
-        `${path}.complete`,
+        at("$.losses", index, ".complete"),
         "Loss completeness must be boolean",
       );
-    if (raw.source !== undefined) source(raw.source, `${path}.source`);
-    if (!isPlainRecord(raw.measures))
+    if (raw.source !== undefined) sourceAt(raw.source, "$.losses", index);
+    const measures: unknown = raw.measures;
+    if (!isPlainRecord(measures))
       issue(
         "input",
         "invalid-type",
-        `${path}.measures`,
+        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: unknown = measures[measureId];
         if (amount !== null && typeof amount !== "number")
           issue(
             "input",
             "invalid-type",
-            `${path}.measures.${measureId}`,
+            `${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: unknown = exposures[index];
     if (!isPlainRecord(raw)) {
       issue(
         "input",
         "invalid-type",
-        path,
+        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`);
-    if (raw.valuation !== undefined) token(raw.valuation, `${path}.valuation`);
+    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)
+      tokenAt(raw.valuation, "$.exposures", index, ".valuation");
     if (raw.value !== null && typeof raw.value !== "number")
       issue(
         "input",
         "invalid-type",
-        `${path}.value`,
+        at("$.exposures", index, ".value"),
         "Exposure value must be a number or null",
       );
     if (typeof raw.complete !== "boolean")
       issue(
         "input",
         "invalid-type",
-        `${path}.complete`,
+        at("$.exposures", index, ".complete"),
         "Exposure completeness must be boolean",
       );
-    if (raw.source !== undefined) source(raw.source, `${path}.source`);
+    if (raw.source !== undefined) sourceAt(raw.source, "$.exposures", index);
   }
   if (value.filter !== undefined && !isPlainRecord(value.filter))
     issue(
@@ -1455,20 +1766,7 @@ function preparationBoundaryIssues(
     );
   if (isPlainRecord(value.filter)) {
     const filter = value.filter;
-    const keys = [
-      "sourceGroups",
-      "outputGroups",
-      "origins",
-      "originFrom",
-      "originThrough",
-      "valuations",
-      "valuationFrom",
-      "valuationThrough",
-      "minDevelopmentAge",
-      "maxDevelopmentAge",
-      "instanceIds",
-    ] as const;
-    exactKeys(filter, keys, "$.filter", "configuration");
+    exactKeys(filter, FILTER_KEYS, "$.filter", "configuration");
     for (const key of [
       "sourceGroups",
       "outputGroups",
@@ -1506,12 +1804,7 @@ function preparationBoundaryIssues(
         );
         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"] as const)
         if (raw[key] !== null)
@@ -1533,12 +1826,7 @@ function preparationBoundaryIssues(
         );
         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");
@@ -1689,19 +1977,28 @@ function prepareDiagnosticDataInMode(
   const filter = normalizedFilter.value;
   const findings: DiagnosticMetricFinding[] = [];
   const pendingBlockers: PendingBlocker[] = [];
+  // 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<number | null, DiagnosticAuditedNumericValue>();
+  const auditedNumber = (value: number | null): DiagnosticAuditedNumericValue => {
+    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: LossCandidate[] = 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),
     } as DiagnosticLossInput,
-    snapshot: snapshotLoss(inputRow),
+    snapshot: snapshotLoss(inputRow, auditedNumber),
     disposition: selectedBySource(filter, inputRow.sourceGroup)
       ? "retained"
       : "filter",
@@ -1731,8 +2028,6 @@ function prepareDiagnosticDataInMode(
         }),
       );
     }
-    if (origin !== null)
-      candidate.snapshot = { ...candidate.snapshot, origin: origin.label };
     try {
       valuation = normalizeDiagnosticPeriod(
         definition,
@@ -1750,10 +2045,24 @@ function prepareDiagnosticDataInMode(
         }),
       );
     }
-    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,
-        valuation: valuation.label,
+        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,
       };
     if (origin === null || valuation === null) {
       candidate.disposition = "invalid";
@@ -1787,16 +2096,13 @@ function prepareDiagnosticDataInMode(
       developmentAge,
       ageUnit: definition.definition.periodAxis.ageUnit,
     };
-    candidate.row = {
-      ...candidate.row,
-      origin: origin.label,
-      valuation: valuation.label,
-    } as DiagnosticLossInput;
-    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,
+      } as DiagnosticLossInput;
     if (
       beyondCutoff(
         candidate as LossCandidate & { coordinate: NormalizedCoordinate },
@@ -1824,7 +2130,7 @@ function prepareDiagnosticDataInMode(
           ? {}
           : { source: { ...inputRow.source } }),
       },
-      snapshot: snapshotExposure(inputRow),
+      snapshot: snapshotExposure(inputRow, auditedNumber),
       disposition: selectedBySource(filter, inputRow.sourceGroup)
         ? "retained"
         : "filter",
@@ -2091,7 +2397,7 @@ function prepareDiagnosticDataInMode(
       const claimId = (candidate.row as DiagnosticClaimObservation).claimId;
       addToMap(
         bySnapshot,
-        canonicalJson([
+        canonicalScalarArrayJson([
           claimId,
           candidate.row.sourceGroup,
           candidate.row.origin,
@@ -2110,7 +2416,7 @@ function prepareDiagnosticDataInMode(
       if (
         uniqueSorted(
           cohort.map((candidate) =>
-            canonicalJson([candidate.row.sourceGroup, candidate.row.origin]),
+            canonicalScalarArrayJson([candidate.row.sourceGroup, candidate.row.origin]),
           ),
         ).length > 1
       )
@@ -2171,7 +2477,7 @@ function prepareDiagnosticDataInMode(
     const timing = internals.measuresById.get(
       exposure.measureId,
     )?.exposureTiming;
-    const identity = canonicalJson(
+    const identity = canonicalScalarArrayJson(
       timing === "valuation-specific"
         ? [
             exposure.measureId,
@@ -2236,23 +2542,29 @@ function prepareDiagnosticDataInMode(
     ]),
   );
   const cellRows = new Map<string, DiagnosticLossInput[]>();
-  for (const candidate of retainedCandidates)
-    addToMap(
-      cellRows,
-      cellKey(
+  // The coordinate behind each cell key, so it is never parsed back from text.
+  const cellCoordinates = new Map<string, readonly [string, string, string]>();
+  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,
-      ),
-      derivedByRecord.get(candidate.row.recordId)!,
-    );
+      ]);
+    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<string, string[]>();
   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
@@ -2280,7 +2592,7 @@ function prepareDiagnosticDataInMode(
         );
       else
         for (const key of cellKeysBySourceOrigin.get(
-          canonicalJson([candidate.row.sourceGroup, candidate.origin.label]),
+          sourceOriginKey(candidate.row.sourceGroup, candidate.origin.label),
         ) ?? [])
           targets.add(key);
     }
@@ -2314,7 +2626,7 @@ function prepareDiagnosticDataInMode(
     const keys =
       timing === "origin-static"
         ? (cellKeysBySourceOrigin.get(
-            canonicalJson([exposure.sourceGroup, exposure.origin]),
+            sourceOriginKey(exposure.sourceGroup, exposure.origin),
           ) ?? [])
         : coordinateKey !== null && cellRows.has(coordinateKey)
           ? [coordinateKey]
@@ -2338,23 +2650,32 @@ function prepareDiagnosticDataInMode(
   // 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: readonly DiagnosticStructuralBlocker[] = Object.freeze([]);
+  const noFindings = Object.freeze([]) as unknown as DiagnosticMetricFinding[];
 
   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,
-        [] as DiagnosticMeasureContribution[],
-      ]),
-    ) as Record<string, DiagnosticMeasureContribution[]>;
-    const blockers = Object.fromEntries(
-      allMeasureIds.map((measureId) => [
-        measureId,
-        [] as DiagnosticStructuralBlocker[],
-      ]),
-    ) as Record<string, DiagnosticStructuralBlocker[]>;
+    const contributions = emptyListsByMeasure<DiagnosticMeasureContribution>(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<DiagnosticStructuralBlocker>(
+      allMeasureIds,
+      noBlockers,
+    );
+    const addBlocker = (
+      measureId: string,
+      blocker: DiagnosticStructuralBlocker,
+    ): void => {
+      const existing = blockers[measureId]!;
+      if (existing === noBlockers) setMeasureEntry(blockers, measureId, [blocker]);
+      else (existing as DiagnosticStructuralBlocker[]).push(blocker);
+    };
     const cellFindings: DiagnosticMetricFinding[] = [];
     const derivedContribution = (
       row: DiagnosticLossInput,
@@ -2379,8 +2700,14 @@ function prepareDiagnosticDataInMode(
         ? { ...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: readonly DiagnosticSourceLocation[] = 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
@@ -2408,14 +2735,15 @@ function prepareDiagnosticDataInMode(
           }
         } else
           contributions[measure.id]!.push(
-            auditedDiagnosticContribution(
+            ownedDiagnosticContribution(
               row.recordId,
               own(row.measures, measure.id),
               measure.missing,
-              row.source ? [row.source] : [],
+              rowSources,
             ),
           );
       }
+    }
     const attachedExposures = validExposuresByCell.get(key) ?? [];
     for (const exposure of attachedExposures)
       contributions[exposure.measureId]!.push(
@@ -2436,8 +2764,7 @@ function prepareDiagnosticDataInMode(
         sources: normalizeSources(pending.finding.sources),
         finding: pending.finding,
       };
-      for (const measureId of pending.measureIds)
-        blockers[measureId]!.push(blocker);
+      for (const measureId of pending.measureIds) addBlocker(measureId, blocker);
     }
     for (const measure of exposureMeasures) {
       const attempted =
@@ -2457,7 +2784,7 @@ function prepareDiagnosticDataInMode(
         });
         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)),
@@ -2467,32 +2794,39 @@ function prepareDiagnosticDataInMode(
       }
     }
     for (const measureId of allMeasureIds) {
-      blockers[measureId] = [
-        ...new Map(
-          blockers[measureId]!.map((blocker) => [
-            canonicalJson(blocker),
-            blocker,
-          ]),
-        ).values(),
-      ].sort(compareDiagnosticBlockers);
-      contributions[measureId]!.sort(compareDiagnosticContributions);
-    }
-    const components = Object.fromEntries(
-      allMeasureIds.map((measureId) => {
-        const measure = internals.measuresById.get(measureId)!;
-        return [
+      const measureBlockers = blockers[measureId]!;
+      if (measureBlockers.length > 0)
+        setMeasureEntry(
+          blockers,
           measureId,
-          componentSharing.internOwned(
-            finalizeDiagnosticContributions(
-              contributions[measureId]!,
-              measure.missing,
-              blockers[measureId],
-            ),
-            "plain",
-          ),
-        ];
-      }),
-    ) as Record<string, DiagnosticMeasureStats>;
+          [
+            ...new Map(
+              measureBlockers.map((blocker) => [canonicalJson(blocker), blocker]),
+            ).values(),
+          ].sort(compareDiagnosticBlockers),
+        );
+      if (contributions[measureId]!.length > 1)
+        contributions[measureId]!.sort(compareDiagnosticContributions);
+    }
+    const components: Record<string, DiagnosticMeasureStats> = {};
+    for (let at = 0; at < allMeasureIds.length; at++) {
+      const measureId = allMeasureIds[at]!;
+      const measure = internals.measuresById.get(measureId)!;
+      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
@@ -2558,11 +2892,14 @@ function prepareDiagnosticDataInMode(
       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),
     });
   }
 
@@ -2625,7 +2962,7 @@ function prepareDiagnosticDataInMode(
         ),
     )
     .map((candidate) => candidate.row);
-  const compareAudits = createAuditComparator();
+  const auditOrder = createAuditComparator();
   const audit: DiagnosticInputAuditRecord[] = [
     ...lossCandidates.map((candidate): DiagnosticInputAuditRecord => ({
       kind: "loss",
@@ -2642,20 +2979,26 @@ function prepareDiagnosticDataInMode(
       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).
@@ -2664,31 +3007,35 @@ function prepareDiagnosticDataInMode(
       ...ownedData,
     }) as unknown as CompactPreparedDiagnosticData;
     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 computeSelectionMetadata = (): CompactSelectionMetadata => {
       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.
+        // 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 : raw;
-        excluded.set(candidate.snapshot, deepFreeze({ kind: "loss", disposition: "filter", record }));
+          ? 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 : raw;
-        excluded.set(candidate.snapshot, deepFreeze({ kind: "exposure", disposition: "filter", record }));
+          ? candidate.snapshot : deepFreeze(raw);
+        excluded.set(candidate.snapshot, Object.freeze({ kind: "exposure", disposition: "filter", record }));
       });
-      expectedCandidates.forEach((candidate) => excluded.set(candidate.snapshot, deepFreeze({
+      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.
+      // preparation's comparator and are not retained by the context. Every
+      // audit record was deeply frozen with the envelope above.
       const originExcluded = new Map<object, DiagnosticInputAuditRecord>(audit.map((item) => [item.record,
-        deepFreeze({ ...item, disposition: "filter" as const })]));
+        Object.freeze({ ...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);
@@ -2696,7 +3043,7 @@ function prepareDiagnosticDataInMode(
         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 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));
@@ -2713,12 +3060,17 @@ function prepareDiagnosticDataInMode(
         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 { 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(