@actuarial-ts/core 0.6.0 → 0.7.0

package/src/diagnosticPreparation.ts

@@ -1,20 +1,66 @@
 import { canonicalJson, fnv1a64 } from "./canonical.js";
+import {
+  createDiagnosticIdentityArray,
+  createDiagnosticIdentityObject,
+  createDiagnosticIdentityValue,
+  fingerprintDiagnosticIdentity,
+  type DiagnosticIdentityDocument,
+} from "./diagnosticIdentityStream.js";
+import {
+  normalizeDiagnosticsFilterIdentity,
+  projectDiagnosticIdentity,
+  type DiagnosticIdentityProjection,
+  type NormalizedDiagnosticsFilterIdentity,
+  type NormalizedDiagnosticSourceLocationIdentity,
+} from "./diagnosticIdentity.js";
+import {
+  compareDiagnosticBlockers,
+  compareDiagnosticContributions,
+  compareDiagnosticFindings,
+} from "./diagnosticOrdering.js";
 import {
   assertCompiledDiagnosticDefinition,
   getCompiledDiagnosticDefinitionInternals,
   type CompiledDiagnosticDefinition,
   type DiagnosticDeepReadonly,
+  type DiagnosticMeasureStats,
   type DiagnosticSourceLocation,
   type DiagnosticsFilter,
   type JsonValue,
 } from "./diagnosticDefinitions.js";
-import { auditedDiagnosticContribution, finalizeDiagnosticContributions, type DiagnosticMeasureContribution, type DiagnosticStructuralBlocker } from "./diagnosticAggregation.js";
-import { deriveDiagnosticClaimMeasures } from "./diagnosticDerivations.js";
-import { diagnosticDevelopmentAge, normalizeDiagnosticPeriod } from "./diagnosticPeriods.js";
-import { reconcileDiagnosticExposures, type DiagnosticAuditedNumericValue, type DiagnosticExposureObservation, type ReconciledDiagnosticExposure, auditDiagnosticNumber } from "./diagnosticExposure.js";
-import type { DiagnosticMeasureStats } from "./diagnosticDefinitions.js";
+import {
+  auditedDiagnosticContribution,
+  finalizeDiagnosticContributions,
+  type DiagnosticMeasureContribution,
+  type DiagnosticStructuralBlocker,
+} from "./diagnosticAggregation.js";
+import {
+  deriveDiagnosticClaimMeasuresWithAudit,
+  type DiagnosticDerivedValueAudit,
+} from "./diagnosticDerivations.js";
+import {
+  compareDiagnosticPeriods,
+  normalizeDiagnosticPeriod,
+  type DiagnosticNormalizedPeriod,
+} from "./diagnosticPeriods.js";
+import {
+  auditDiagnosticNumber,
+  reconcileDiagnosticExposures,
+  type DiagnosticAuditedNumericValue,
+  type DiagnosticExposureAuditObservation,
+  type DiagnosticExposureObservation,
+  type ReconciledDiagnosticExposure,
+} from "./diagnosticExposure.js";
 import type { DiagnosticMetricFinding } from "./diagnosticFormulas.js";
-import { DiagnosticValidationError, type DiagnosticValidationIssue } from "./types.js";
+import {
+  DiagnosticValidationError,
+  type DiagnosticValidationIssue,
+} from "./types.js";
+import { normalizeDiagnosticSourceLocations } from "./diagnosticSourceOrdering.js";
+import {
+  isDiagnosticPlainRecord,
+  isDiagnosticToken,
+} from "./diagnosticRuntime.js";
 
 export interface DiagnosticLossRecordBase {
   readonly recordId: string;
@@ -25,12 +71,32 @@ export interface DiagnosticLossRecordBase {
   readonly source?: DiagnosticSourceLocation;
   readonly measures: Readonly<Record<string, number | null>>;
 }
-export interface DiagnosticClaimObservation extends DiagnosticLossRecordBase { readonly rowType: "claim"; readonly claimId: string }
-export interface DiagnosticLossSnapshot extends DiagnosticLossRecordBase { readonly rowType: "aggregate" }
-export type DiagnosticLossInput = DiagnosticClaimObservation | DiagnosticLossSnapshot;
 
-export interface DiagnosticCompletePeriodCutoff { readonly sourceGroup: string; readonly originThrough: string | null; readonly valuationThrough: string | null }
-export interface DiagnosticExpectedCell { readonly sourceGroup: string; readonly origin: string; readonly valuation: string; readonly source?: DiagnosticSourceLocation }
+export interface DiagnosticClaimObservation extends DiagnosticLossRecordBase {
+  readonly rowType: "claim";
+  readonly claimId: string;
+}
+
+export interface DiagnosticLossSnapshot extends DiagnosticLossRecordBase {
+  readonly rowType: "aggregate";
+}
+
+export type DiagnosticLossInput =
+  DiagnosticClaimObservation | DiagnosticLossSnapshot;
+
+export interface DiagnosticCompletePeriodCutoff {
+  readonly sourceGroup: string;
+  readonly originThrough: string | null;
+  readonly valuationThrough: string | null;
+}
+
+export interface DiagnosticExpectedCell {
+  readonly sourceGroup: string;
+  readonly origin: string;
+  readonly valuation: string;
+  readonly source?: DiagnosticSourceLocation;
+}
+
 export interface PrepareDiagnosticDataInput {
   readonly definition: CompiledDiagnosticDefinition;
   readonly losses: readonly DiagnosticLossInput[];
@@ -40,11 +106,55 @@ export interface PrepareDiagnosticDataInput {
   readonly expectedCells?: readonly DiagnosticExpectedCell[];
 }
 
-export type DiagnosticInputDisposition = "invalid" | "complete-period-cutoff" | "filter" | "retained";
+export type DiagnosticInputDisposition =
+  "invalid" | "complete-period-cutoff" | "filter" | "retained";
+
+export interface DiagnosticLossInputAuditSnapshot {
+  readonly recordId: string;
+  readonly rowType: "claim" | "aggregate";
+  readonly claimId: string | null;
+  readonly sourceGroup: string;
+  readonly origin: string;
+  readonly valuation: string;
+  readonly complete: boolean;
+  readonly measures: Readonly<Record<string, DiagnosticAuditedNumericValue>>;
+  readonly source: DiagnosticSourceLocation | null;
+}
+
+export interface DiagnosticExposureInputAuditSnapshot {
+  readonly key: string;
+  readonly sourceGroup: string;
+  readonly origin: string;
+  readonly valuation: string | null;
+  readonly measureId: string;
+  readonly value: DiagnosticAuditedNumericValue;
+  readonly complete: boolean;
+  readonly source: DiagnosticSourceLocation | null;
+}
+
+export interface DiagnosticExpectedCellAuditSnapshot {
+  readonly sourceGroup: string;
+  readonly origin: string;
+  readonly valuation: string;
+  readonly source: DiagnosticSourceLocation | null;
+}
+
 export type DiagnosticInputAuditRecord =
-  | { readonly kind: "loss"; readonly disposition: DiagnosticInputDisposition; readonly record: DiagnosticDeepReadonly<DiagnosticLossInput> }
-  | { readonly kind: "exposure"; readonly disposition: DiagnosticInputDisposition; readonly record: DiagnosticDeepReadonly<DiagnosticExposureObservation> }
-  | { readonly kind: "expected-cell"; readonly disposition: Exclude<DiagnosticInputDisposition, "invalid">; readonly record: DiagnosticDeepReadonly<DiagnosticExpectedCell> };
+  | {
+      readonly kind: "loss";
+      readonly disposition: DiagnosticInputDisposition;
+      readonly record: DiagnosticLossInputAuditSnapshot;
+    }
+  | {
+      readonly kind: "exposure";
+      readonly disposition: DiagnosticInputDisposition;
+      readonly record: DiagnosticExposureInputAuditSnapshot;
+    }
+  | {
+      readonly kind: "expected-cell";
+      readonly disposition: Exclude<DiagnosticInputDisposition, "invalid">;
+      readonly record: DiagnosticExpectedCellAuditSnapshot;
+    };
 
 export interface PreparedDiagnosticSourceCell {
   readonly sourceGroup: string;
@@ -53,9 +163,13 @@ export interface PreparedDiagnosticSourceCell {
   readonly developmentAge: number;
   readonly ageUnit: string;
   readonly lossRecordIds: readonly string[];
-  readonly contributions: Readonly<Record<string, readonly DiagnosticMeasureContribution[]>>;
+  readonly contributions: Readonly<
+    Record<string, readonly DiagnosticMeasureContribution[]>
+  >;
   readonly components: Readonly<Record<string, DiagnosticMeasureStats>>;
-  readonly structuralBlockers: Readonly<Record<string, readonly DiagnosticStructuralBlocker[]>>;
+  readonly structuralBlockers: Readonly<
+    Record<string, readonly DiagnosticStructuralBlocker[]>
+  >;
   readonly findings: readonly DiagnosticMetricFinding[];
 }
 
@@ -74,160 +188,2472 @@ export interface PreparedDiagnosticData {
   readonly findings: readonly DiagnosticMetricFinding[];
 }
 
+/** Complete prepared content shared by the eager and compact execution paths. */
+export type PreparedDiagnosticDataContent = Omit<
+  PreparedDiagnosticData,
+  typeof preparedDiagnosticDataBrand | "preparationFingerprint"
+>;
+
+declare const compactPreparedDiagnosticDataBrand: unique symbol;
+/**
+ * Owned, frozen preparation without an eagerly materialized identity or hash.
+ * This is a distinct authenticated value, not an eager preparation with a
+ * missing or placeholder fingerprint.
+ */
+export interface CompactPreparedDiagnosticData extends PreparedDiagnosticDataContent {
+  readonly [compactPreparedDiagnosticDataBrand]: true;
+}
+
 export interface NormalizedDiagnosticPreparationIdentity {
   readonly definitionIntegrity: string;
-  readonly filter: DiagnosticDeepReadonly<DiagnosticsFilter> | null;
-  readonly completePeriodCutoffs: readonly DiagnosticCompletePeriodCutoff[];
-  readonly inputAudit: readonly DiagnosticInputAuditRecord[];
-  readonly cells: readonly PreparedDiagnosticSourceCell[];
-  readonly exposures: readonly ReconciledDiagnosticExposure[];
+  readonly filter: NormalizedDiagnosticsFilterIdentity | null;
+  readonly completePeriodCutoffs: readonly DiagnosticIdentityProjection<DiagnosticCompletePeriodCutoff>[];
+  readonly inputAudit: readonly DiagnosticIdentityProjection<DiagnosticInputAuditRecord>[];
+  readonly cells: readonly DiagnosticIdentityProjection<PreparedDiagnosticSourceCell>[];
+  readonly exposures: readonly DiagnosticIdentityProjection<ReconciledDiagnosticExposure>[];
   readonly expectedCellsProvided: boolean;
-  readonly expectedCells: readonly DiagnosticExpectedCell[];
-  readonly findings: readonly DiagnosticMetricFinding[];
+  readonly expectedCells: readonly NormalizedDiagnosticExpectedCellIdentity[];
+  readonly findings: readonly DiagnosticIdentityProjection<DiagnosticMetricFinding>[];
+}
+
+export interface NormalizedDiagnosticExpectedCellIdentity {
+  readonly sourceGroup: string;
+  readonly origin: string;
+  readonly valuation: string;
+  readonly source: NormalizedDiagnosticSourceLocationIdentity | null;
+}
+
+interface NormalizedCoordinate {
+  readonly origin: DiagnosticNormalizedPeriod;
+  readonly valuation: DiagnosticNormalizedPeriod;
+  readonly developmentAge: number;
+  readonly ageUnit: string;
+}
+
+interface LossCandidate {
+  row: DiagnosticLossInput;
+  snapshot: DiagnosticLossInputAuditSnapshot;
+  disposition: DiagnosticInputDisposition;
+  coordinate: NormalizedCoordinate | null;
+  invalid: boolean;
+}
+
+interface ExposureCandidate {
+  row: DiagnosticExposureObservation;
+  snapshot: DiagnosticExposureInputAuditSnapshot;
+  disposition: DiagnosticInputDisposition;
+  origin: DiagnosticNormalizedPeriod | null;
+  valuation: DiagnosticNormalizedPeriod | null;
+  developmentAge: number | null;
+  ageUnit: string | null;
+  timing: "origin-static" | "valuation-specific" | null;
+  invalid: boolean;
+}
+
+interface ExpectedCandidate {
+  readonly row: DiagnosticExpectedCell;
+  readonly snapshot: DiagnosticExpectedCellAuditSnapshot;
+  disposition: Exclude<DiagnosticInputDisposition, "invalid">;
+  readonly coordinate: NormalizedCoordinate;
+}
+
+interface NormalizedCutoff {
+  readonly value: DiagnosticCompletePeriodCutoff;
+  readonly originThrough: DiagnosticNormalizedPeriod | null;
+  readonly valuationThrough: DiagnosticNormalizedPeriod | null;
+}
+
+interface PendingBlocker {
+  readonly finding: DiagnosticMetricFinding;
+  readonly measureIds: readonly string[];
+  readonly cellKeys: readonly string[];
+  readonly sourceIds: readonly string[];
 }
 
 const authentic = new WeakSet<object>();
-const identities = new WeakMap<object, DiagnosticDeepReadonly<NormalizedDiagnosticPreparationIdentity>>();
+const authenticCompact = new WeakSet<object>();
+const compactIdentityDocuments = new WeakMap<
+  object,
+  DiagnosticIdentityDocument
+>();
+const compactFingerprints = new WeakMap<object, string>();
+const identities = new WeakMap<
+  object,
+  DiagnosticDeepReadonly<NormalizedDiagnosticPreparationIdentity>
+>();
+
+const STRUCTURAL = {
+  "duplicate-loss-record-id": ["Loss record identity is duplicated", "fail"],
+  "duplicate-claim-snapshot": ["Claim snapshot identity is duplicated", "fail"],
+  "claim-identity-conflict": [
+    "Claim identity has conflicting source group or origin",
+    "fail",
+  ],
+  "duplicate-aggregate-snapshot": [
+    "Aggregate source-cell identity is duplicated",
+    "fail",
+  ],
+  "duplicate-exposure-identity": ["Exposure identity is duplicated", "fail"],
+  "conflicting-exposure-identity": [
+    "Exposure identity has conflicting observations",
+    "fail",
+  ],
+  "unknown-origin-period": [
+    "Origin period is not declared by the period axis",
+    "fail",
+  ],
+  "unknown-valuation-period": [
+    "Valuation period is not declared by the period axis",
+    "fail",
+  ],
+  "valuation-before-origin": ["Valuation precedes origin", "fail"],
+  "unsafe-development-age": [
+    "Derived development age is not a nonnegative safe integer",
+    "fail",
+  ],
+  "undeclared-loss-measure": [
+    "Loss input contains an undeclared measure",
+    "fail",
+  ],
+  "wrong-source-loss-measure": [
+    "Loss input contains a measure that is not raw loss input",
+    "fail",
+  ],
+  "undeclared-exposure-measure": [
+    "Exposure input contains an undeclared measure",
+    "fail",
+  ],
+  "wrong-source-exposure-measure": [
+    "Exposure input names a measure that is not exposure input",
+    "fail",
+  ],
+  "incomplete-loss-record": ["Loss record is marked incomplete", "fail"],
+  "missing-exposure-value": [
+    "Exposure observation has a missing value",
+    "fail",
+  ],
+  "incomplete-exposure": ["Exposure observation is marked incomplete", "fail"],
+  "non-finite-exposure": ["Exposure observation is non-finite", "fail"],
+  "loss-without-exposure": [
+    "Loss source cell has no matching required exposure",
+    "warning",
+  ],
+  "exposure-without-loss": [
+    "Exposure has no matching retained loss source cell",
+    "warning",
+  ],
+  "missing-expected-cell": ["Expected source cell is absent", "fail"],
+} as const;
+
+type StructuralCode = keyof typeof STRUCTURAL;
+
+function codeUnit(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function own<T>(
+  record: Readonly<Record<string, T>>,
+  key: string,
+): T | undefined {
+  return Object.prototype.hasOwnProperty.call(record, key)
+    ? record[key]
+    : undefined;
+}
 
-function deepFreeze<T>(value: T, seen = new WeakSet<object>()): DiagnosticDeepReadonly<T> {
-  if (value === null || typeof value !== "object" || seen.has(value)) return value as DiagnosticDeepReadonly<T>;
+function deepFreeze<T>(
+  value: T,
+  seen = new WeakSet<object>(),
+): DiagnosticDeepReadonly<T> {
+  if (value === null || typeof value !== "object" || seen.has(value))
+    return value as DiagnosticDeepReadonly<T>;
   seen.add(value);
-  for (const child of Object.values(value as Record<string, unknown>)) deepFreeze(child, seen);
+  for (const child of Object.values(value as Record<string, unknown>))
+    deepFreeze(child, seen);
   return Object.freeze(value) as DiagnosticDeepReadonly<T>;
 }
 
-function codeUnit(left: string, right: string): number { return left < right ? -1 : left > right ? 1 : 0 }
-function own<T>(record: Readonly<Record<string, T>>, key: string): T | undefined { return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined }
+function uniqueSorted(values: readonly string[]): string[] {
+  return [...new Set(values)].sort(codeUnit);
+}
+
+function normalizeSources(
+  values: readonly (DiagnosticSourceLocation | undefined | null)[],
+): DiagnosticSourceLocation[] {
+  return normalizeDiagnosticSourceLocations(values);
+}
+
+function structuralFinding(
+  code: StructuralCode,
+  context: Omit<
+    DiagnosticMetricFinding,
+    "code" | "message" | "severity" | "category" | "sources"
+  > & {
+    readonly sources?: readonly DiagnosticSourceLocation[];
+  } = {},
+): DiagnosticMetricFinding {
+  const [message, severity] = STRUCTURAL[code];
+  return {
+    code,
+    message,
+    severity,
+    category: "structural",
+    ...context,
+    sources: normalizeSources(context.sources ?? []),
+  };
+}
+
+function aggregationFinding(
+  code:
+    | "diagnostic-measure-missing"
+    | "diagnostic-measure-imputed-zero"
+    | "diagnostic-measure-non-finite"
+    | "diagnostic-measure-overflow",
+  context: Omit<
+    DiagnosticMetricFinding,
+    "code" | "message" | "severity" | "category" | "sources"
+  > & { readonly sources?: readonly DiagnosticSourceLocation[] },
+): DiagnosticMetricFinding {
+  const catalog = {
+    "diagnostic-measure-missing": ["Measure input is missing", "warning"],
+    "diagnostic-measure-imputed-zero": [
+      "Missing measure input was imputed as zero",
+      "info",
+    ],
+    "diagnostic-measure-non-finite": ["Measure input is non-finite", "fail"],
+    "diagnostic-measure-overflow": ["Measure aggregation overflowed", "fail"],
+  } as const;
+  const [message, severity] = catalog[code];
+  return {
+    code,
+    message,
+    severity,
+    category: "aggregation",
+    ...context,
+    sources: normalizeSources(context.sources ?? []),
+  };
+}
+
+function mergeFindings(
+  values: readonly DiagnosticMetricFinding[],
+): DiagnosticMetricFinding[] {
+  const merged = new Map<string, DiagnosticMetricFinding>();
+  for (const value of values) {
+    const key = canonicalJson({ ...value, sources: [] });
+    const previous = merged.get(key);
+    merged.set(
+      key,
+      previous === undefined
+        ? { ...value, sources: normalizeSources(value.sources) }
+        : {
+            ...previous,
+            sources: normalizeSources([...previous.sources, ...value.sources]),
+          },
+    );
+  }
+  return [...merged.values()].sort(compareDiagnosticFindings);
+}
+
+function snapshotLoss(
+  row: DiagnosticLossInput,
+): DiagnosticLossInputAuditSnapshot {
+  const measures = Object.fromEntries(
+    Object.keys(row.measures)
+      .sort(codeUnit)
+      .map((measureId) => [
+        measureId,
+        auditDiagnosticNumber(row.measures[measureId] ?? null),
+      ]),
+  );
+  return {
+    recordId: row.recordId,
+    rowType: row.rowType,
+    claimId: row.rowType === "claim" ? row.claimId : null,
+    sourceGroup: row.sourceGroup,
+    origin: row.origin,
+    valuation: row.valuation,
+    complete: row.complete,
+    measures,
+    source: row.source === undefined ? null : { ...row.source },
+  };
+}
+
+function snapshotExposure(
+  row: DiagnosticExposureObservation,
+): DiagnosticExposureInputAuditSnapshot {
+  return {
+    key: row.key,
+    sourceGroup: row.sourceGroup,
+    origin: row.origin,
+    valuation: row.valuation ?? null,
+    measureId: row.measureId,
+    value: auditDiagnosticNumber(row.value),
+    complete: row.complete,
+    source: row.source === undefined ? null : { ...row.source },
+  };
+}
+
+function normalizeConfiguredPeriod(
+  definition: CompiledDiagnosticDefinition,
+  side: "origin" | "valuation",
+  label: string,
+  path: string,
+  issues: DiagnosticValidationIssue[],
+): DiagnosticNormalizedPeriod | null {
+  try {
+    return normalizeDiagnosticPeriod(definition, side, label);
+  } catch {
+    issues.push({
+      domain: "configuration",
+      code: "invalid-period",
+      path,
+      message: `Unknown ${side} period ${JSON.stringify(label)}`,
+    });
+    return null;
+  }
+}
+
+function normalizeFilter(
+  definition: CompiledDiagnosticDefinition,
+  input: DiagnosticsFilter | undefined,
+  knownSourceGroups: ReadonlySet<string>,
+  issues: DiagnosticValidationIssue[],
+): {
+  readonly value: DiagnosticsFilter | null;
+  readonly originCoordinates: ReadonlyMap<string, number>;
+  readonly valuationCoordinates: ReadonlyMap<string, number>;
+} {
+  if (input === undefined)
+    return {
+      value: null,
+      originCoordinates: new Map(),
+      valuationCoordinates: new Map(),
+    };
+  const checkTokens = (
+    values: readonly string[] | undefined,
+    path: string,
+  ): string[] | undefined => {
+    if (values === undefined) return undefined;
+    values.forEach((value, index) => {
+      if (typeof value !== "string" || value.length === 0)
+        issues.push({
+          domain: "configuration",
+          code: "invalid-string",
+          path: `${path}[${index}]`,
+          message: "Filter values must be nonempty strings",
+        });
+    });
+    return uniqueSorted(
+      values.filter((value) => typeof value === "string" && value.length > 0),
+    );
+  };
+  const normalizeList = (
+    values: readonly string[] | undefined,
+    side: "origin" | "valuation",
+    path: string,
+  ) => {
+    const checked = checkTokens(values, path);
+    if (checked === undefined)
+      return { labels: undefined, coordinates: new Map<string, number>() };
+    const normalized = checked
+      .map((label, index) =>
+        normalizeConfiguredPeriod(
+          definition,
+          side,
+          label,
+          `${path}[${index}]`,
+          issues,
+        ),
+      )
+      .filter((value): value is DiagnosticNormalizedPeriod => value !== null);
+    return {
+      labels: uniqueSorted(normalized.map((value) => value.label)),
+      coordinates: new Map(
+        normalized.map((value) => [value.label, value.coordinate]),
+      ),
+    };
+  };
+  const origins = normalizeList(input.origins, "origin", "$.filter.origins");
+  const valuations = normalizeList(
+    input.valuations,
+    "valuation",
+    "$.filter.valuations",
+  );
+  const originFrom =
+    input.originFrom === undefined
+      ? null
+      : normalizeConfiguredPeriod(
+          definition,
+          "origin",
+          input.originFrom,
+          "$.filter.originFrom",
+          issues,
+        );
+  const originThrough =
+    input.originThrough === undefined
+      ? null
+      : normalizeConfiguredPeriod(
+          definition,
+          "origin",
+          input.originThrough,
+          "$.filter.originThrough",
+          issues,
+        );
+  const valuationFrom =
+    input.valuationFrom === undefined
+      ? null
+      : normalizeConfiguredPeriod(
+          definition,
+          "valuation",
+          input.valuationFrom,
+          "$.filter.valuationFrom",
+          issues,
+        );
+  const valuationThrough =
+    input.valuationThrough === undefined
+      ? null
+      : normalizeConfiguredPeriod(
+          definition,
+          "valuation",
+          input.valuationThrough,
+          "$.filter.valuationThrough",
+          issues,
+        );
+  if (
+    originFrom &&
+    originThrough &&
+    compareDiagnosticPeriods(originFrom, originThrough) > 0
+  )
+    issues.push({
+      domain: "configuration",
+      code: "invalid-configuration",
+      path: "$.filter",
+      message: "Origin range start exceeds end",
+    });
+  if (
+    valuationFrom &&
+    valuationThrough &&
+    compareDiagnosticPeriods(valuationFrom, valuationThrough) > 0
+  )
+    issues.push({
+      domain: "configuration",
+      code: "invalid-configuration",
+      path: "$.filter",
+      message: "Valuation range start exceeds end",
+    });
+  for (const [name, bound] of [
+    ["minDevelopmentAge", input.minDevelopmentAge],
+    ["maxDevelopmentAge", input.maxDevelopmentAge],
+  ] as const) {
+    if (bound !== undefined && (!Number.isSafeInteger(bound) || bound < 0))
+      issues.push({
+        domain: "configuration",
+        code: "invalid-configuration",
+        path: `$.filter.${name}`,
+        message: "Development-age bounds must be nonnegative safe integers",
+      });
+  }
+  if (
+    input.minDevelopmentAge !== undefined &&
+    input.maxDevelopmentAge !== undefined &&
+    input.minDevelopmentAge > input.maxDevelopmentAge
+  )
+    issues.push({
+      domain: "configuration",
+      code: "invalid-configuration",
+      path: "$.filter",
+      message: "Minimum development age exceeds maximum",
+    });
+  const sourceGroups = checkTokens(input.sourceGroups, "$.filter.sourceGroups");
+  const outputGroups = checkTokens(input.outputGroups, "$.filter.outputGroups");
+  const instanceIds = checkTokens(input.instanceIds, "$.filter.instanceIds");
+  const validInstances = new Set(
+    definition.definition.instances.map((instance) => instance.id),
+  );
+  for (const [index, sourceGroup] of (sourceGroups ?? []).entries()) {
+    if (!knownSourceGroups.has(sourceGroup))
+      issues.push({
+        domain: "configuration",
+        code: "unknown-reference",
+        path: `$.filter.sourceGroups[${index}]`,
+        message: `Unknown source group ${sourceGroup}`,
+      });
+  }
+  for (const [index, instanceId] of (instanceIds ?? []).entries())
+    if (!validInstances.has(instanceId))
+      issues.push({
+        domain: "configuration",
+        code: "unknown-reference",
+        path: `$.filter.instanceIds[${index}]`,
+        message: `Unknown metric instance ${instanceId}`,
+      });
+  const value: DiagnosticsFilter = {
+    ...(sourceGroups === undefined ? {} : { sourceGroups }),
+    ...(outputGroups === undefined ? {} : { outputGroups }),
+    ...(origins.labels === undefined ? {} : { origins: origins.labels }),
+    ...(originFrom === null ? {} : { originFrom: originFrom.label }),
+    ...(originThrough === null ? {} : { originThrough: originThrough.label }),
+    ...(valuations.labels === undefined
+      ? {}
+      : { valuations: valuations.labels }),
+    ...(valuationFrom === null ? {} : { valuationFrom: valuationFrom.label }),
+    ...(valuationThrough === null
+      ? {}
+      : { valuationThrough: valuationThrough.label }),
+    ...(input.minDevelopmentAge === undefined
+      ? {}
+      : { minDevelopmentAge: input.minDevelopmentAge }),
+    ...(input.maxDevelopmentAge === undefined
+      ? {}
+      : { maxDevelopmentAge: input.maxDevelopmentAge }),
+    ...(instanceIds === undefined ? {} : { instanceIds }),
+  };
+  return {
+    value,
+    originCoordinates: new Map([
+      ...origins.coordinates,
+      ...(originFrom
+        ? [[originFrom.label, originFrom.coordinate] as const]
+        : []),
+      ...(originThrough
+        ? [[originThrough.label, originThrough.coordinate] as const]
+        : []),
+    ]),
+    valuationCoordinates: new Map([
+      ...valuations.coordinates,
+      ...(valuationFrom
+        ? [[valuationFrom.label, valuationFrom.coordinate] as const]
+        : []),
+      ...(valuationThrough
+        ? [[valuationThrough.label, valuationThrough.coordinate] as const]
+        : []),
+    ]),
+  };
+}
+
+function normalizeCutoffs(
+  definition: CompiledDiagnosticDefinition,
+  input: readonly DiagnosticCompletePeriodCutoff[],
+  knownSourceGroups: ReadonlySet<string>,
+  issues: DiagnosticValidationIssue[],
+): readonly NormalizedCutoff[] {
+  const groups = new Set<string>();
+  const normalized: NormalizedCutoff[] = [];
+  input.forEach((cutoff, index) => {
+    if (!knownSourceGroups.has(cutoff.sourceGroup))
+      issues.push({
+        domain: "configuration",
+        code: "unknown-reference",
+        path: `$.completePeriodCutoffs[${index}].sourceGroup`,
+        message: `Unknown source group ${cutoff.sourceGroup}`,
+      });
+    if (groups.has(cutoff.sourceGroup))
+      issues.push({
+        domain: "configuration",
+        code: "duplicate-id",
+        path: `$.completePeriodCutoffs[${index}].sourceGroup`,
+        message: "Complete-period cutoff source group is duplicated",
+      });
+    groups.add(cutoff.sourceGroup);
+    const origin =
+      cutoff.originThrough === null
+        ? null
+        : normalizeConfiguredPeriod(
+            definition,
+            "origin",
+            cutoff.originThrough,
+            `$.completePeriodCutoffs[${index}].originThrough`,
+            issues,
+          );
+    const valuation =
+      cutoff.valuationThrough === null
+        ? null
+        : normalizeConfiguredPeriod(
+            definition,
+            "valuation",
+            cutoff.valuationThrough,
+            `$.completePeriodCutoffs[${index}].valuationThrough`,
+            issues,
+          );
+    normalized.push({
+      value: {
+        sourceGroup: cutoff.sourceGroup,
+        originThrough: origin?.label ?? null,
+        valuationThrough: valuation?.label ?? null,
+      },
+      originThrough: origin,
+      valuationThrough: valuation,
+    });
+  });
+  return normalized.sort((left, right) =>
+    codeUnit(left.value.sourceGroup, right.value.sourceGroup),
+  );
+}
+
+function coordinateFor(
+  definition: CompiledDiagnosticDefinition,
+  originLabel: string,
+  valuationLabel: string,
+): {
+  readonly coordinate: NormalizedCoordinate | null;
+  readonly issue:
+    | "unknown-origin-period"
+    | "unknown-valuation-period"
+    | "valuation-before-origin"
+    | "unsafe-development-age"
+    | null;
+} {
+  let origin: DiagnosticNormalizedPeriod;
+  let valuation: DiagnosticNormalizedPeriod;
+  try {
+    origin = normalizeDiagnosticPeriod(definition, "origin", originLabel);
+  } catch {
+    return { coordinate: null, issue: "unknown-origin-period" };
+  }
+  try {
+    valuation = normalizeDiagnosticPeriod(
+      definition,
+      "valuation",
+      valuationLabel,
+    );
+  } catch {
+    return { coordinate: null, issue: "unknown-valuation-period" };
+  }
+  const developmentAge =
+    valuation.coordinate -
+    origin.coordinate +
+    definition.definition.periodAxis.ageOffset;
+  if (!Number.isSafeInteger(developmentAge))
+    return { coordinate: null, issue: "unsafe-development-age" };
+  if (developmentAge < 0)
+    return { coordinate: null, issue: "valuation-before-origin" };
+  return {
+    coordinate: {
+      origin,
+      valuation,
+      developmentAge,
+      ageUnit: definition.definition.periodAxis.ageUnit,
+    },
+    issue: null,
+  };
+}
+
+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];
+}
 
-function normalizeFilter(filter: DiagnosticsFilter | undefined): DiagnosticsFilter | null {
-  if (filter === undefined) return null;
-  const set = (values: readonly string[] | undefined) => values === undefined ? undefined : [...new Set(values)].sort(codeUnit);
+function coordinateContext(candidate: {
+  readonly row: { readonly sourceGroup: string };
+  readonly coordinate: NormalizedCoordinate | null;
+}): Partial<DiagnosticMetricFinding> {
+  if (candidate.coordinate === null) return {};
   return {
-    ...(filter.sourceGroups === undefined ? {} : { sourceGroups: set(filter.sourceGroups) }),
-    ...(filter.outputGroups === undefined ? {} : { outputGroups: set(filter.outputGroups) }),
-    ...(filter.origins === undefined ? {} : { origins: set(filter.origins) }),
-    ...(filter.originFrom === undefined ? {} : { originFrom: filter.originFrom }),
-    ...(filter.originThrough === undefined ? {} : { originThrough: filter.originThrough }),
-    ...(filter.valuations === undefined ? {} : { valuations: set(filter.valuations) }),
-    ...(filter.valuationFrom === undefined ? {} : { valuationFrom: filter.valuationFrom }),
-    ...(filter.valuationThrough === undefined ? {} : { valuationThrough: filter.valuationThrough }),
-    ...(filter.minDevelopmentAge === undefined ? {} : { minDevelopmentAge: filter.minDevelopmentAge }),
-    ...(filter.maxDevelopmentAge === undefined ? {} : { maxDevelopmentAge: filter.maxDevelopmentAge }),
-    ...(filter.instanceIds === undefined ? {} : { instanceIds: set(filter.instanceIds) }),
-  };
-}
-
-function selected(filter: DiagnosticsFilter | null, group: string, origin: string, valuation: string, age: number): boolean {
-  return (filter?.sourceGroups === undefined || filter.sourceGroups.includes(group)) &&
-    (filter?.origins === undefined || filter.origins.includes(origin)) &&
-    (filter?.valuations === undefined || filter.valuations.includes(valuation)) &&
-    (filter?.originFrom === undefined || origin >= filter.originFrom) &&
-    (filter?.originThrough === undefined || origin <= filter.originThrough) &&
-    (filter?.valuationFrom === undefined || valuation >= filter.valuationFrom) &&
-    (filter?.valuationThrough === undefined || valuation <= filter.valuationThrough) &&
-    (filter?.minDevelopmentAge === undefined || age >= filter.minDevelopmentAge) &&
-    (filter?.maxDevelopmentAge === undefined || age <= filter.maxDevelopmentAge);
-}
-
-export function prepareDiagnosticData(input: PrepareDiagnosticDataInput): PreparedDiagnosticData {
-  assertCompiledDiagnosticDefinition(input.definition);
+    sourceGroup: candidate.row.sourceGroup,
+    origin: candidate.coordinate.origin.label,
+    valuation: candidate.coordinate.valuation.label,
+    developmentAge: candidate.coordinate.developmentAge,
+    ageUnit: candidate.coordinate.ageUnit,
+  };
+}
+
+function selectedBySource(
+  filter: DiagnosticsFilter | null,
+  sourceGroup: string,
+): boolean {
+  return (
+    filter?.sourceGroups === undefined ||
+    filter.sourceGroups.includes(sourceGroup)
+  );
+}
+
+function selectedByOrigin(
+  filter: DiagnosticsFilter | null,
+  origin: DiagnosticNormalizedPeriod,
+  coordinates: ReadonlyMap<string, number>,
+): boolean {
+  const from =
+    filter?.originFrom === undefined
+      ? null
+      : coordinates.get(filter.originFrom)!;
+  const through =
+    filter?.originThrough === undefined
+      ? null
+      : coordinates.get(filter.originThrough)!;
+  return (
+    (filter?.origins === undefined || filter.origins.includes(origin.label)) &&
+    (from === null || origin.coordinate >= from) &&
+    (through === null || origin.coordinate <= through)
+  );
+}
+
+function selectedByValuation(
+  filter: DiagnosticsFilter | null,
+  valuation: DiagnosticNormalizedPeriod,
+  coordinates: ReadonlyMap<string, number>,
+): boolean {
+  const from =
+    filter?.valuationFrom === undefined
+      ? null
+      : coordinates.get(filter.valuationFrom)!;
+  const through =
+    filter?.valuationThrough === undefined
+      ? null
+      : coordinates.get(filter.valuationThrough)!;
+  return (
+    (filter?.valuations === undefined ||
+      filter.valuations.includes(valuation.label)) &&
+    (from === null || valuation.coordinate >= from) &&
+    (through === null || valuation.coordinate <= through)
+  );
+}
+
+function selectedByAge(filter: DiagnosticsFilter | null, age: number): boolean {
+  return (
+    (filter?.minDevelopmentAge === undefined ||
+      age >= filter.minDevelopmentAge) &&
+    (filter?.maxDevelopmentAge === undefined || age <= filter.maxDevelopmentAge)
+  );
+}
+
+function beyondCutoff(
+  candidate: {
+    readonly row: { readonly sourceGroup: string };
+    readonly coordinate: NormalizedCoordinate;
+  },
+  cutoffByGroup: ReadonlyMap<string, NormalizedCutoff>,
+): boolean {
+  const cutoff = cutoffByGroup.get(candidate.row.sourceGroup);
+  return (
+    cutoff !== undefined &&
+    ((cutoff.originThrough !== null &&
+      compareDiagnosticPeriods(
+        candidate.coordinate.origin,
+        cutoff.originThrough,
+      ) > 0) ||
+      (cutoff.valuationThrough !== null &&
+        compareDiagnosticPeriods(
+          candidate.coordinate.valuation,
+          cutoff.valuationThrough,
+        ) > 0))
+  );
+}
+
+function addToMap<K, V>(map: Map<K, V[]>, key: K, value: V): void {
+  const values = map.get(key) ?? [];
+  values.push(value);
+  map.set(key, values);
+}
+
+function commonCoordinate(
+  candidates: readonly LossCandidate[],
+): Partial<DiagnosticMetricFinding> {
+  const keys = uniqueSorted(
+    candidates.flatMap((candidate) =>
+      candidate.coordinate === null
+        ? []
+        : [
+            cellKey(
+              candidate.row.sourceGroup,
+              candidate.coordinate.origin.label,
+              candidate.coordinate.valuation.label,
+            ),
+          ],
+    ),
+  );
+  return keys.length === 1 ? coordinateContext(candidates[0]!) : {};
+}
+
+function exposureIdentity(candidate: ExposureCandidate): string {
+  return canonicalJson(
+    candidate.timing === "valuation-specific"
+      ? [
+          candidate.row.measureId,
+          candidate.row.key,
+          candidate.row.valuation ?? null,
+        ]
+      : [candidate.row.measureId, candidate.row.key],
+  );
+}
+
+function exposureCoordinateContext(
+  candidates: readonly ExposureCandidate[],
+): Partial<DiagnosticMetricFinding> {
+  const coherentSource = uniqueSorted(
+    candidates.map((candidate) => candidate.row.sourceGroup),
+  );
+  const coherentOrigin = uniqueSorted(
+    candidates.flatMap((candidate) =>
+      candidate.origin ? [candidate.origin.label] : [],
+    ),
+  );
+  const coherentValuation = uniqueSorted(
+    candidates.flatMap((candidate) =>
+      candidate.valuation ? [candidate.valuation.label] : [],
+    ),
+  );
+  if (coherentSource.length !== 1 || coherentOrigin.length !== 1) return {};
+  const first = candidates[0]!;
+  if (
+    first.timing === "valuation-specific" &&
+    coherentValuation.length === 1 &&
+    first.developmentAge !== null &&
+    first.ageUnit !== null
+  ) {
+    return {
+      sourceGroup: coherentSource[0],
+      origin: coherentOrigin[0],
+      valuation: coherentValuation[0],
+      developmentAge: first.developmentAge,
+      ageUnit: first.ageUnit,
+    };
+  }
+  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;
+  // 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>();
+  const key = (record: DiagnosticInputAuditRecord["record"]): string => {
+    const previous = keys.get(record);
+    if (previous !== undefined) return previous;
+    const text = canonicalJson(record);
+    keys.set(record, text);
+    return text;
+  };
+  return (left, right) =>
+    rank[left.kind] - rank[right.kind] ||
+    codeUnit(key(left.record), key(right.record)) ||
+    disposition[left.disposition] - disposition[right.disposition];
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return isDiagnosticPlainRecord(value);
+}
+
+function preparationBoundaryIssues(
+  value: unknown,
+): DiagnosticValidationIssue[] {
+  const issues: DiagnosticValidationIssue[] = [];
+  if (!isPlainRecord(value))
+    return [
+      {
+        domain: "input",
+        code: "invalid-type",
+        path: "$",
+        message: "Preparation input must be an object",
+      },
+    ];
+  const issue = (
+    domain: "input" | "configuration",
+    code: DiagnosticValidationIssue["code"],
+    path: string,
+    message: string,
+  ) => issues.push({ domain, code, path, message });
+  const token = (
+    item: unknown,
+    path: string,
+    domain: "input" | "configuration" = "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",
+      );
+  };
+  const exactKeys = (
+    item: Record<string, unknown>,
+    allowed: readonly 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}`);
+      else if (item[key] === undefined)
+        issue(
+          domain,
+          "invalid-type",
+          keyPath,
+          "Explicit undefined is not allowed",
+        );
+    }
+  };
+  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",
+    );
+    token(item.artifactId, `${path}.artifactId`);
+    for (const key of ["sourceFile", "sourceSheet", "sourceCell"] as const)
+      if (item[key] !== undefined) token(item[key], `${path}.${key}`);
+    if (
+      item.sourceRow !== undefined &&
+      (typeof item.sourceRow !== "number" ||
+        !Number.isSafeInteger(item.sourceRow) ||
+        item.sourceRow < 0)
+    )
+      issue(
+        "input",
+        "invalid-number",
+        `${path}.sourceRow`,
+        "Source row must be a nonnegative safe integer",
+      );
+  };
+  const array = (
+    item: unknown,
+    path: string,
+    domain: "input" | "configuration",
+  ): readonly unknown[] => {
+    if (!Array.isArray(item)) {
+      issue(domain, "invalid-type", path, "Expected an array");
+      return [];
+    }
+    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}]`;
+    if (!isPlainRecord(raw)) {
+      issue("input", "invalid-type", path, "Loss record must be an object");
+      continue;
+    }
+    exactKeys(
+      raw,
+      [
+        "rowType",
+        "recordId",
+        "claimId",
+        "sourceGroup",
+        "origin",
+        "valuation",
+        "complete",
+        "source",
+        "measures",
+      ],
+      path,
+      "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`);
+    if (raw.rowType === "claim") token(raw.claimId, `${path}.claimId`);
+    else if (raw.claimId !== undefined)
+      issue(
+        "input",
+        "unknown-key",
+        `${path}.claimId`,
+        "Aggregate loss rows cannot contain claimId",
+      );
+    if (typeof raw.complete !== "boolean")
+      issue(
+        "input",
+        "invalid-type",
+        `${path}.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",
+      );
+    else
+      for (const [measureId, amount] of Object.entries(raw.measures)) {
+        token(measureId, `${path}.measures`);
+        if (amount !== null && typeof amount !== "number")
+          issue(
+            "input",
+            "invalid-type",
+            `${path}.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}]`;
+    if (!isPlainRecord(raw)) {
+      issue(
+        "input",
+        "invalid-type",
+        path,
+        "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`);
+    if (raw.value !== null && typeof raw.value !== "number")
+      issue(
+        "input",
+        "invalid-type",
+        `${path}.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",
+      );
+    if (raw.source !== undefined) source(raw.source, `${path}.source`);
+  }
+  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",
+    ] as const;
+    exactKeys(filter, keys, "$.filter", "configuration");
+    for (const key of [
+      "sourceGroups",
+      "outputGroups",
+      "origins",
+      "valuations",
+      "instanceIds",
+    ] as const)
+      if (filter[key] !== undefined)
+        array(filter[key], `$.filter.${key}`, "configuration").forEach(
+          (item, index) =>
+            token(item, `$.filter.${key}[${index}]`, "configuration"),
+        );
+    for (const key of [
+      "originFrom",
+      "originThrough",
+      "valuationFrom",
+      "valuationThrough",
+    ] as const)
+      if (filter[key] !== undefined)
+        token(filter[key], `$.filter.${key}`, "configuration");
+  }
+  if (value.completePeriodCutoffs !== undefined)
+    for (const [index, raw] of array(
+      value.completePeriodCutoffs,
+      "$.completePeriodCutoffs",
+      "configuration",
+    ).entries()) {
+      const path = `$.completePeriodCutoffs[${index}]`;
+      if (!isPlainRecord(raw)) {
+        issue(
+          "configuration",
+          "invalid-type",
+          path,
+          "Cutoff must be an object",
+        );
+        continue;
+      }
+      exactKeys(
+        raw,
+        ["sourceGroup", "originThrough", "valuationThrough"],
+        path,
+        "configuration",
+      );
+      token(raw.sourceGroup, `${path}.sourceGroup`, "configuration");
+      for (const key of ["originThrough", "valuationThrough"] as const)
+        if (raw[key] !== null)
+          token(raw[key], `${path}.${key}`, "configuration");
+    }
+  if (value.expectedCells !== undefined)
+    for (const [index, raw] of array(
+      value.expectedCells,
+      "$.expectedCells",
+      "configuration",
+    ).entries()) {
+      const path = `$.expectedCells[${index}]`;
+      if (!isPlainRecord(raw)) {
+        issue(
+          "configuration",
+          "invalid-type",
+          path,
+          "Expected cell must be an object",
+        );
+        continue;
+      }
+      exactKeys(
+        raw,
+        ["sourceGroup", "origin", "valuation", "source"],
+        path,
+        "configuration",
+      );
+      token(raw.sourceGroup, `${path}.sourceGroup`, "configuration");
+      token(raw.origin, `${path}.origin`, "configuration");
+      token(raw.valuation, `${path}.valuation`, "configuration");
+      if (raw.source !== undefined) source(raw.source, `${path}.source`);
+    }
+  return issues;
+}
+
+export function prepareDiagnosticData(
+  input: PrepareDiagnosticDataInput,
+): PreparedDiagnosticData {
+  return prepareDiagnosticDataInMode(input, "eager") as PreparedDiagnosticData;
+}
+
+export function prepareDiagnosticDataCompact(
+  input: PrepareDiagnosticDataInput,
+): CompactPreparedDiagnosticData {
+  return prepareDiagnosticDataInMode(
+    input,
+    "compact",
+  ) as CompactPreparedDiagnosticData;
+}
+
+function prepareDiagnosticDataInMode(
+  input: PrepareDiagnosticDataInput,
+  mode: "eager" | "compact",
+): PreparedDiagnosticData | CompactPreparedDiagnosticData {
+  assertCompiledDiagnosticDefinition(
+    (input as unknown as { readonly definition?: unknown } | null)?.definition,
+  );
+  const boundaryIssues = preparationBoundaryIssues(input);
+  if (boundaryIssues.length > 0)
+    throw new DiagnosticValidationError(boundaryIssues);
   const definition = input.definition;
   const internals = getCompiledDiagnosticDefinitionInternals(definition);
   const issues: DiagnosticValidationIssue[] = [];
-  const filter = normalizeFilter(input.filter);
-  for (const bound of [filter?.minDevelopmentAge, filter?.maxDevelopmentAge]) if (bound !== undefined && (!Number.isSafeInteger(bound) || bound < 0)) issues.push({ domain: "configuration", code: "invalid-configuration", path: "$.filter", message: "Development-age bounds must be nonnegative safe integers" });
-  if (filter?.minDevelopmentAge !== undefined && filter.maxDevelopmentAge !== undefined && filter.minDevelopmentAge > filter.maxDevelopmentAge) issues.push({ domain: "configuration", code: "invalid-configuration", path: "$.filter", message: "Minimum development age exceeds maximum" });
+  const knownSourceGroups = new Set<string>([
+    ...input.losses.map((row) => row.sourceGroup),
+    ...input.exposures.map((row) => row.sourceGroup),
+    ...(input.expectedCells ?? []).map((row) => row.sourceGroup),
+  ]);
+  const normalizedFilter = normalizeFilter(
+    definition,
+    input.filter,
+    knownSourceGroups,
+    issues,
+  );
+  const normalizedCutoffs = normalizeCutoffs(
+    definition,
+    input.completePeriodCutoffs ?? [],
+    knownSourceGroups,
+    issues,
+  );
+  const cutoffByGroup = new Map(
+    normalizedCutoffs.map((cutoff) => [cutoff.value.sourceGroup, cutoff]),
+  );
+
   input.losses.forEach((row, index) => {
-    if (row.rowType !== definition.definition.lossRowGrain) issues.push({ domain: "input", code: "invalid-input-relationship", path: `$.losses[${index}].rowType`, message: "Loss row type does not match definition grain" });
+    if (row.rowType !== definition.definition.lossRowGrain)
+      issues.push({
+        domain: "input",
+        code: "invalid-input-relationship",
+        path: `$.losses[${index}].rowType`,
+        message: "Loss row type does not match definition grain",
+      });
   });
   input.exposures.forEach((row, index) => {
     const measure = internals.measuresById.get(row.measureId);
-    if (measure?.exposureTiming === "valuation-specific" && row.valuation === undefined) issues.push({ domain: "input", code: "missing-required", path: `$.exposures[${index}].valuation`, message: "Valuation-specific exposure requires valuation" });
+    if (
+      measure?.exposureTiming === "valuation-specific" &&
+      row.valuation === undefined
+    )
+      issues.push({
+        domain: "input",
+        code: "missing-required",
+        path: `$.exposures[${index}].valuation`,
+        message: "Valuation-specific exposure requires valuation",
+      });
+  });
+
+  const expectedCandidates: ExpectedCandidate[] = [];
+  const expectedKeys = new Set<string>();
+  (input.expectedCells ?? []).forEach((row, index) => {
+    const origin = normalizeConfiguredPeriod(
+      definition,
+      "origin",
+      row.origin,
+      `$.expectedCells[${index}].origin`,
+      issues,
+    );
+    const valuation = normalizeConfiguredPeriod(
+      definition,
+      "valuation",
+      row.valuation,
+      `$.expectedCells[${index}].valuation`,
+      issues,
+    );
+    if (!origin || !valuation) return;
+    const developmentAge =
+      valuation.coordinate -
+      origin.coordinate +
+      definition.definition.periodAxis.ageOffset;
+    if (!Number.isSafeInteger(developmentAge) || developmentAge < 0) {
+      issues.push({
+        domain: "configuration",
+        code: "invalid-period",
+        path: `$.expectedCells[${index}].valuation`,
+        message:
+          "Expected-cell valuation precedes origin or produces an unsafe development age",
+      });
+      return;
+    }
+    const normalized = {
+      ...row,
+      ...(row.source === undefined ? {} : { source: { ...row.source } }),
+      origin: origin.label,
+      valuation: valuation.label,
+    };
+    const key = cellKey(row.sourceGroup, origin.label, valuation.label);
+    if (expectedKeys.has(key))
+      issues.push({
+        domain: "configuration",
+        code: "duplicate-id",
+        path: `$.expectedCells[${index}]`,
+        message:
+          "Expected source cell is duplicated after period normalization",
+      });
+    expectedKeys.add(key);
+    expectedCandidates.push({
+      row: normalized,
+      snapshot: {
+        sourceGroup: row.sourceGroup,
+        origin: origin.label,
+        valuation: valuation.label,
+        source: row.source === undefined ? null : { ...row.source },
+      },
+      disposition: "retained",
+      coordinate: {
+        origin,
+        valuation,
+        developmentAge,
+        ageUnit: definition.definition.periodAxis.ageUnit,
+      },
+    });
   });
   if (issues.length > 0) throw new DiagnosticValidationError(issues);
 
-  const normalizedLosses: DiagnosticLossInput[] = [];
-  const audit: DiagnosticInputAuditRecord[] = [];
-  for (const row of input.losses) {
-    let disposition: DiagnosticInputDisposition = "retained";
+  const filter = normalizedFilter.value;
+  const findings: DiagnosticMetricFinding[] = [];
+  const pendingBlockers: PendingBlocker[] = [];
+  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]!]),
+      ),
+    } as DiagnosticLossInput,
+    snapshot: snapshotLoss(inputRow),
+    disposition: selectedBySource(filter, inputRow.sourceGroup)
+      ? "retained"
+      : "filter",
+    coordinate: null,
+    invalid: false,
+  }));
+
+  for (const candidate of lossCandidates) {
+    if (candidate.disposition !== "retained") continue;
+    let origin: DiagnosticNormalizedPeriod | null = null;
+    let valuation: DiagnosticNormalizedPeriod | null = null;
     try {
-      const period = diagnosticDevelopmentAge(definition, row.origin, row.valuation);
-      const normalized = { ...row, origin: period.origin.label, valuation: period.valuation.label } as DiagnosticLossInput;
-      if (!selected(filter, row.sourceGroup, normalized.origin, normalized.valuation, period.developmentAge)) disposition = "filter";
-      if (disposition === "retained") normalizedLosses.push(normalized);
-      audit.push({ kind: "loss", disposition, record: normalized });
-    } catch { audit.push({ kind: "loss", disposition: "invalid", record: row }); }
-  }
-  const derivedLosses = definition.definition.lossRowGrain === "claim"
-    ? deriveDiagnosticClaimMeasures(normalizedLosses as DiagnosticClaimObservation[], definition) as readonly DiagnosticLossInput[]
-    : normalizedLosses;
-  const cells = new Map<string, DiagnosticLossInput[]>();
-  for (const row of derivedLosses) {
-    const key = `${row.sourceGroup}\u0000${row.origin}\u0000${row.valuation}`;
-    const list = cells.get(key) ?? [];
-    list.push(row);
-    cells.set(key, list);
-  }
-
-  const normalizedExposureInputs: DiagnosticExposureObservation[] = [];
-  for (const row of input.exposures) {
+      origin = normalizeDiagnosticPeriod(
+        definition,
+        "origin",
+        candidate.row.origin,
+      );
+    } catch {
+      findings.push(
+        structuralFinding("unknown-origin-period", {
+          recordId: candidate.row.recordId,
+          sourceGroup: candidate.row.sourceGroup,
+          origin: candidate.row.origin,
+          valuation: candidate.row.valuation,
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+    }
+    if (origin !== null)
+      candidate.snapshot = { ...candidate.snapshot, origin: origin.label };
     try {
-      const origin = normalizeDiagnosticPeriod(definition, "origin", row.origin).label;
-      const valuation = row.valuation === undefined ? undefined : normalizeDiagnosticPeriod(definition, "valuation", row.valuation).label;
-      const normalized = { ...row, origin, ...(valuation === undefined ? {} : { valuation }) };
-      const timing = internals.measuresById.get(row.measureId)?.exposureTiming;
-      const age = valuation === undefined ? 0 : diagnosticDevelopmentAge(definition, origin, valuation).developmentAge;
-      const keep = timing === "origin-static"
-        ? (filter?.sourceGroups === undefined || filter.sourceGroups.includes(row.sourceGroup)) && (filter?.origins === undefined || filter.origins.includes(origin))
-        : selected(filter, row.sourceGroup, origin, valuation ?? "", age);
-      audit.push({ kind: "exposure", disposition: keep ? "retained" : "filter", record: normalized });
-      if (keep) normalizedExposureInputs.push(normalized);
-    } catch { audit.push({ kind: "exposure", disposition: "invalid", record: row }); }
-  }
-  const timingByMeasure = Object.fromEntries(definition.definition.measures.filter((measure) => measure.kind === "exposure").map((measure) => [measure.id, measure.exposureTiming!])) as Record<string, "origin-static" | "valuation-specific">;
-  const exposures = reconcileDiagnosticExposures(normalizedExposureInputs, timingByMeasure);
+      valuation = normalizeDiagnosticPeriod(
+        definition,
+        "valuation",
+        candidate.row.valuation,
+      );
+    } catch {
+      findings.push(
+        structuralFinding("unknown-valuation-period", {
+          recordId: candidate.row.recordId,
+          sourceGroup: candidate.row.sourceGroup,
+          origin: origin?.label ?? candidate.row.origin,
+          valuation: candidate.row.valuation,
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+    }
+    if (valuation !== null)
+      candidate.snapshot = {
+        ...candidate.snapshot,
+        valuation: valuation.label,
+      };
+    if (origin === null || valuation === null) {
+      candidate.disposition = "invalid";
+      candidate.invalid = true;
+      continue;
+    }
+    const developmentAge =
+      valuation.coordinate -
+      origin.coordinate +
+      definition.definition.periodAxis.ageOffset;
+    if (!Number.isSafeInteger(developmentAge) || developmentAge < 0) {
+      const code: StructuralCode = Number.isSafeInteger(developmentAge)
+        ? "valuation-before-origin"
+        : "unsafe-development-age";
+      findings.push(
+        structuralFinding(code, {
+          recordId: candidate.row.recordId,
+          sourceGroup: candidate.row.sourceGroup,
+          origin: origin.label,
+          valuation: valuation.label,
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+      candidate.disposition = "invalid";
+      candidate.invalid = true;
+      continue;
+    }
+    candidate.coordinate = {
+      origin,
+      valuation,
+      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,
+    };
+    if (
+      beyondCutoff(
+        candidate as LossCandidate & { coordinate: NormalizedCoordinate },
+        cutoffByGroup,
+      )
+    )
+      candidate.disposition = "complete-period-cutoff";
+    else if (
+      !selectedByOrigin(filter, origin, normalizedFilter.originCoordinates) ||
+      !selectedByValuation(
+        filter,
+        valuation,
+        normalizedFilter.valuationCoordinates,
+      ) ||
+      !selectedByAge(filter, developmentAge)
+    )
+      candidate.disposition = "filter";
+  }
+
+  const exposureCandidates: ExposureCandidate[] = input.exposures.map(
+    (inputRow) => ({
+      row: {
+        ...inputRow,
+        ...(inputRow.source === undefined
+          ? {}
+          : { source: { ...inputRow.source } }),
+      },
+      snapshot: snapshotExposure(inputRow),
+      disposition: selectedBySource(filter, inputRow.sourceGroup)
+        ? "retained"
+        : "filter",
+      origin: null,
+      valuation: null,
+      developmentAge: null,
+      ageUnit: null,
+      timing:
+        internals.measuresById.get(inputRow.measureId)?.exposureTiming ?? null,
+      invalid: false,
+    }),
+  );
+  for (const candidate of exposureCandidates) {
+    if (candidate.disposition !== "retained") continue;
+    try {
+      candidate.origin = normalizeDiagnosticPeriod(
+        definition,
+        "origin",
+        candidate.row.origin,
+      );
+    } catch {
+      findings.push(
+        structuralFinding("unknown-origin-period", {
+          measureId: candidate.row.measureId,
+          exposureKey: candidate.row.key,
+          sourceGroup: candidate.row.sourceGroup,
+          origin: candidate.row.origin,
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+    }
+    if (candidate.origin !== null)
+      candidate.snapshot = {
+        ...candidate.snapshot,
+        origin: candidate.origin.label,
+      };
+    if (candidate.row.valuation !== undefined) {
+      try {
+        candidate.valuation = normalizeDiagnosticPeriod(
+          definition,
+          "valuation",
+          candidate.row.valuation,
+        );
+      } catch {
+        findings.push(
+          structuralFinding("unknown-valuation-period", {
+            measureId: candidate.row.measureId,
+            exposureKey: candidate.row.key,
+            sourceGroup: candidate.row.sourceGroup,
+            origin: candidate.origin?.label ?? candidate.row.origin,
+            valuation: candidate.row.valuation,
+            sources: candidate.row.source ? [candidate.row.source] : [],
+          }),
+        );
+      }
+      if (candidate.valuation !== null)
+        candidate.snapshot = {
+          ...candidate.snapshot,
+          valuation: candidate.valuation.label,
+        };
+    }
+    if (
+      candidate.origin === null ||
+      (candidate.row.valuation !== undefined && candidate.valuation === null)
+    ) {
+      candidate.disposition = "invalid";
+      candidate.invalid = true;
+      continue;
+    }
+    if (candidate.valuation !== null) {
+      const age =
+        candidate.valuation.coordinate -
+        candidate.origin.coordinate +
+        definition.definition.periodAxis.ageOffset;
+      if (!Number.isSafeInteger(age) || age < 0) {
+        const code: StructuralCode = Number.isSafeInteger(age)
+          ? "valuation-before-origin"
+          : "unsafe-development-age";
+        findings.push(
+          structuralFinding(code, {
+            measureId: candidate.row.measureId,
+            exposureKey: candidate.row.key,
+            sourceGroup: candidate.row.sourceGroup,
+            origin: candidate.origin.label,
+            valuation: candidate.valuation.label,
+            sources: candidate.row.source ? [candidate.row.source] : [],
+          }),
+        );
+        candidate.disposition = "invalid";
+        candidate.invalid = true;
+        continue;
+      }
+      candidate.developmentAge = age;
+      candidate.ageUnit = definition.definition.periodAxis.ageUnit;
+    }
+    candidate.row = {
+      ...candidate.row,
+      origin: candidate.origin.label,
+      ...(candidate.valuation ? { valuation: candidate.valuation.label } : {}),
+    };
+    candidate.snapshot = {
+      ...candidate.snapshot,
+      origin: candidate.origin.label,
+      valuation: candidate.valuation?.label ?? null,
+    };
+    const cutoff = cutoffByGroup.get(candidate.row.sourceGroup);
+    const beyondOrigin =
+      cutoff?.originThrough !== null &&
+      cutoff?.originThrough !== undefined &&
+      compareDiagnosticPeriods(candidate.origin, cutoff.originThrough) > 0;
+    const beyondValuation =
+      candidate.timing === "valuation-specific" &&
+      cutoff?.valuationThrough !== null &&
+      cutoff?.valuationThrough !== undefined &&
+      candidate.valuation !== null &&
+      compareDiagnosticPeriods(candidate.valuation, cutoff.valuationThrough) >
+        0;
+    if (beyondOrigin || beyondValuation)
+      candidate.disposition = "complete-period-cutoff";
+    else {
+      const originSelected = selectedByOrigin(
+        filter,
+        candidate.origin,
+        normalizedFilter.originCoordinates,
+      );
+      const valuationSelected =
+        candidate.timing === "valuation-specific" &&
+        candidate.valuation !== null
+          ? selectedByValuation(
+              filter,
+              candidate.valuation,
+              normalizedFilter.valuationCoordinates,
+            ) && selectedByAge(filter, candidate.developmentAge!)
+          : true;
+      if (!originSelected || !valuationSelected)
+        candidate.disposition = "filter";
+    }
+  }
+
+  for (const candidate of expectedCandidates) {
+    if (!selectedBySource(filter, candidate.row.sourceGroup))
+      candidate.disposition = "filter";
+    else if (beyondCutoff(candidate, cutoffByGroup))
+      candidate.disposition = "complete-period-cutoff";
+    else if (
+      !selectedByOrigin(
+        filter,
+        candidate.coordinate.origin,
+        normalizedFilter.originCoordinates,
+      ) ||
+      !selectedByValuation(
+        filter,
+        candidate.coordinate.valuation,
+        normalizedFilter.valuationCoordinates,
+      ) ||
+      !selectedByAge(filter, candidate.coordinate.developmentAge)
+    )
+      candidate.disposition = "filter";
+  }
+
+  const provisionalLosses = lossCandidates.filter(
+    (candidate) => candidate.disposition === "retained",
+  );
+  const lossFindings = (
+    code: StructuralCode,
+    candidates: readonly LossCandidate[],
+    extra: Partial<DiagnosticMetricFinding> = {},
+  ) => {
+    const finding = structuralFinding(code, {
+      ...commonCoordinate(candidates),
+      ...extra,
+      sources: normalizeSources(
+        candidates.map((candidate) => candidate.row.source),
+      ),
+    });
+    findings.push(finding);
+    for (const candidate of candidates) candidate.invalid = true;
+    pendingBlockers.push({
+      finding,
+      measureIds: definition.definition.measures
+        .filter((measure) => measure.source !== "exposure")
+        .map((measure) => measure.id),
+      cellKeys: uniqueSorted(
+        candidates.flatMap((candidate) =>
+          candidate.coordinate
+            ? [
+                cellKey(
+                  candidate.row.sourceGroup,
+                  candidate.coordinate.origin.label,
+                  candidate.coordinate.valuation.label,
+                ),
+              ]
+            : [],
+        ),
+      ),
+      sourceIds: uniqueSorted(
+        candidates.map((candidate) => candidate.row.recordId),
+      ),
+    });
+  };
+
+  for (const candidate of provisionalLosses) {
+    const localCodes: {
+      code: StructuralCode;
+      measureId?: string;
+      offendingKey?: string;
+    }[] = [];
+    for (const measureId of Object.keys(candidate.row.measures).sort(
+      codeUnit,
+    )) {
+      const measure = internals.measuresById.get(measureId);
+      if (!measure)
+        localCodes.push({
+          code: "undeclared-loss-measure",
+          measureId,
+          offendingKey: measureId,
+        });
+      else if (measure.source !== "loss")
+        localCodes.push({
+          code: "wrong-source-loss-measure",
+          measureId,
+          offendingKey: measureId,
+        });
+    }
+    if (!candidate.row.complete)
+      localCodes.push({ code: "incomplete-loss-record" });
+    for (const item of localCodes)
+      lossFindings(item.code, [candidate], {
+        recordId: candidate.row.recordId,
+        ...(candidate.row.rowType === "claim"
+          ? { claimId: candidate.row.claimId }
+          : {}),
+        ...(item.measureId ? { measureId: item.measureId } : {}),
+        ...(item.offendingKey ? { offendingKey: item.offendingKey } : {}),
+      });
+  }
+
+  const byRecordId = new Map<string, LossCandidate[]>();
+  for (const candidate of provisionalLosses)
+    addToMap(byRecordId, candidate.row.recordId, candidate);
+  for (const [recordId, cohort] of byRecordId)
+    if (cohort.length > 1)
+      lossFindings("duplicate-loss-record-id", cohort, { recordId });
+  if (definition.definition.lossRowGrain === "aggregate") {
+    const byCell = new Map<string, LossCandidate[]>();
+    for (const candidate of provisionalLosses)
+      addToMap(
+        byCell,
+        cellKey(
+          candidate.row.sourceGroup,
+          candidate.row.origin,
+          candidate.row.valuation,
+        ),
+        candidate,
+      );
+    for (const cohort of byCell.values())
+      if (cohort.length > 1)
+        lossFindings("duplicate-aggregate-snapshot", cohort);
+  } else {
+    const bySnapshot = new Map<string, LossCandidate[]>();
+    const byClaim = new Map<string, LossCandidate[]>();
+    for (const candidate of provisionalLosses) {
+      const claimId = (candidate.row as DiagnosticClaimObservation).claimId;
+      addToMap(
+        bySnapshot,
+        canonicalJson([
+          claimId,
+          candidate.row.sourceGroup,
+          candidate.row.origin,
+          candidate.row.valuation,
+        ]),
+        candidate,
+      );
+      addToMap(byClaim, claimId, candidate);
+    }
+    for (const cohort of bySnapshot.values())
+      if (cohort.length > 1)
+        lossFindings("duplicate-claim-snapshot", cohort, {
+          claimId: (cohort[0]!.row as DiagnosticClaimObservation).claimId,
+        });
+    for (const [claimId, cohort] of byClaim)
+      if (
+        uniqueSorted(
+          cohort.map((candidate) =>
+            canonicalJson([candidate.row.sourceGroup, candidate.row.origin]),
+          ),
+        ).length > 1
+      )
+        lossFindings("claim-identity-conflict", cohort, { claimId });
+  }
+  for (const candidate of provisionalLosses)
+    if (candidate.invalid) candidate.disposition = "invalid";
+
+  const declaredExposureCandidates: ExposureCandidate[] = [];
+  for (const candidate of exposureCandidates.filter(
+    (item) => item.disposition === "retained",
+  )) {
+    const measure = internals.measuresById.get(candidate.row.measureId);
+    if (!measure) {
+      findings.push(
+        structuralFinding("undeclared-exposure-measure", {
+          measureId: candidate.row.measureId,
+          offendingKey: candidate.row.measureId,
+          exposureKey: candidate.row.key,
+          ...(candidate.origin ? { origin: candidate.origin.label } : {}),
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+      candidate.invalid = true;
+      candidate.disposition = "invalid";
+    } else if (measure.source !== "exposure") {
+      findings.push(
+        structuralFinding("wrong-source-exposure-measure", {
+          measureId: candidate.row.measureId,
+          offendingKey: candidate.row.measureId,
+          exposureKey: candidate.row.key,
+          ...(candidate.origin ? { origin: candidate.origin.label } : {}),
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+      candidate.invalid = true;
+      candidate.disposition = "invalid";
+    } else declaredExposureCandidates.push(candidate);
+  }
+
+  const reconciled = reconcileDiagnosticExposures(
+    declaredExposureCandidates.map((candidate) => candidate.row),
+    Object.fromEntries(
+      definition.definition.measures
+        .filter((measure) => measure.source === "exposure")
+        .map((measure) => [measure.id, measure.exposureTiming!]),
+    ),
+    definition.definition.periodAxis,
+  ) as ReconciledDiagnosticExposure[];
+  const exposureCohorts = new Map<string, ExposureCandidate[]>();
+  for (const candidate of declaredExposureCandidates)
+    addToMap(exposureCohorts, exposureIdentity(candidate), candidate);
+  const invalidExposureBlockers: {
+    finding: DiagnosticMetricFinding;
+    candidates: readonly ExposureCandidate[];
+  }[] = [];
+  for (const exposure of reconciled) {
+    const timing = internals.measuresById.get(
+      exposure.measureId,
+    )?.exposureTiming;
+    const identity = canonicalJson(
+      timing === "valuation-specific"
+        ? [
+            exposure.measureId,
+            exposure.key,
+            exposure.status === "valid"
+              ? (exposure.valuation ?? null)
+              : (exposure.observations[0]?.valuation ?? null),
+          ]
+        : [exposure.measureId, exposure.key],
+    );
+    const cohort = exposureCohorts.get(identity) ?? [];
+    if (exposure.status === "valid") continue;
+    for (const candidate of cohort) {
+      candidate.invalid = true;
+      candidate.disposition = "invalid";
+    }
+    const context = exposureCoordinateContext(cohort);
+    const issueCodes: Record<(typeof exposure.issues)[number], StructuralCode> =
+      {
+        missing: "missing-exposure-value",
+        incomplete: "incomplete-exposure",
+        "non-finite": "non-finite-exposure",
+        duplicate: "duplicate-exposure-identity",
+        conflict: "conflicting-exposure-identity",
+      };
+    for (const issue of exposure.issues) {
+      const finding = structuralFinding(issueCodes[issue], {
+        ...context,
+        measureId: exposure.measureId,
+        exposureKey: exposure.key,
+        sources: normalizeSources(
+          cohort.map((candidate) => candidate.row.source),
+        ),
+      });
+      findings.push(finding);
+      invalidExposureBlockers.push({ finding, candidates: cohort });
+    }
+  }
+
+  const retainedCandidates = lossCandidates.filter(
+    (candidate) => candidate.disposition === "retained",
+  );
+  const retainedRows = retainedCandidates.map((candidate) => candidate.row);
+  const derivedAudits =
+    definition.definition.lossRowGrain === "claim"
+      ? deriveDiagnosticClaimMeasuresWithAudit(
+          retainedRows as readonly DiagnosticClaimObservation[],
+          definition,
+        )
+      : [];
+  const derivedRows =
+    definition.definition.lossRowGrain === "claim"
+      ? derivedAudits.map((item) => item.row as DiagnosticLossInput)
+      : retainedRows;
+  const derivedByRecord = new Map(
+    derivedRows.map((row) => [row.recordId, row]),
+  );
+  const derivedAuditByRecord = new Map(
+    derivedAudits.map((item) => [
+      (item.row as DiagnosticClaimObservation).recordId,
+      item,
+    ]),
+  );
+  const cellRows = new Map<string, DiagnosticLossInput[]>();
+  for (const candidate of retainedCandidates)
+    addToMap(
+      cellRows,
+      cellKey(
+        candidate.row.sourceGroup,
+        candidate.row.origin,
+        candidate.row.valuation,
+      ),
+      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 allMeasureIds = definition.definition.measures
+    .map((measure) => measure.id)
+    .sort(codeUnit);
+  const nonExposureMeasures = definition.definition.measures
+    .filter((measure) => measure.source !== "exposure")
+    .sort((left, right) => codeUnit(left.id, right.id));
+  const exposureMeasures = definition.definition.measures
+    .filter((measure) => measure.source === "exposure")
+    .sort((left, right) => codeUnit(left.id, right.id));
   const preparedCells: PreparedDiagnosticSourceCell[] = [];
-  for (const [key, rows] of cells) {
-    const [sourceGroup, origin, valuation] = key.split("\u0000") as [string, string, string];
-    const period = diagnosticDevelopmentAge(definition, origin, valuation);
-    const contributions: Record<string, DiagnosticMeasureContribution[]> = Object.create(null);
-    const blockers: Record<string, DiagnosticStructuralBlocker[]> = Object.create(null);
-    for (const measure of definition.definition.measures) { contributions[measure.id] = []; blockers[measure.id] = []; }
-    for (const row of rows) {
-      for (const measure of definition.definition.measures.filter((item) => item.source !== "exposure")) {
-        contributions[measure.id]!.push(auditedDiagnosticContribution(row.recordId, own(row.measures, measure.id), measure.missing, row.source ? [row.source] : []));
+  const invalidExposureMeasuresByCell = new Map<string, Set<string>>();
+  for (const item of invalidExposureBlockers) {
+    const targets = new Set<string>();
+    for (const candidate of item.candidates) {
+      if (!candidate.origin) continue;
+      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]),
+        ) ?? [])
+          targets.add(key);
+    }
+    for (const key of targets) {
+      const measures =
+        invalidExposureMeasuresByCell.get(key) ?? new Set<string>();
+      measures.add(item.finding.measureId!);
+      invalidExposureMeasuresByCell.set(key, measures);
+    }
+    pendingBlockers.push({
+      finding: item.finding,
+      measureIds: [item.finding.measureId!],
+      cellKeys: [...targets],
+      sourceIds: item.finding.exposureKey ? [item.finding.exposureKey] : [],
+    });
+  }
+
+  const validExposuresByCell = new Map<
+    string,
+    Extract<ReconciledDiagnosticExposure, { status: "valid" }>[]
+  >();
+  for (const exposure of reconciled) {
+    if (exposure.status !== "valid") continue;
+    const timing = internals.measuresById.get(
+      exposure.measureId,
+    )!.exposureTiming;
+    const coordinateKey =
+      exposure.valuation === undefined
+        ? null
+        : cellKey(exposure.sourceGroup, exposure.origin, exposure.valuation);
+    const keys =
+      timing === "origin-static"
+        ? (cellKeysBySourceOrigin.get(
+            canonicalJson([exposure.sourceGroup, exposure.origin]),
+          ) ?? [])
+        : coordinateKey !== null && cellRows.has(coordinateKey)
+          ? [coordinateKey]
+          : [];
+    for (const key of keys) addToMap(validExposuresByCell, key, exposure);
+    if (keys.length === 0)
+      findings.push(
+        structuralFinding("exposure-without-loss", {
+          measureId: exposure.measureId,
+          exposureKey: exposure.key,
+          sourceGroup: exposure.sourceGroup,
+          origin: exposure.origin,
+          ...(exposure.valuation ? { valuation: exposure.valuation } : {}),
+          sources: exposure.sources,
+        }),
+      );
+  }
+
+  const pendingBlockersByCell = new Map<
+    string,
+    (typeof pendingBlockers)[number][]
+  >();
+  for (const pending of pendingBlockers)
+    for (const key of new Set(pending.cellKeys))
+      addToMap(pendingBlockersByCell, key, pending);
+
+  for (const [key, rows] of cellRows) {
+    const [sourceGroup, origin, valuation] = parseCellKey(key);
+    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 cellFindings: DiagnosticMetricFinding[] = [];
+    const derivedContribution = (
+      row: DiagnosticLossInput,
+      missingPolicy: "unknown" | "zero",
+      state: DiagnosticDerivedValueAudit,
+    ): DiagnosticMeasureContribution => {
+      const base = {
+        sourceId: row.recordId,
+        sources: row.source ? [row.source] : [],
+        deduplicated: 0,
+      } as const;
+      if (state.status === "observed")
+        return { ...base, status: "observed", value: state.value };
+      if (state.status === "non-finite")
+        return {
+          ...base,
+          status: "non-finite",
+          value: null,
+          nonFiniteKind: state.nonFiniteKind,
+        };
+      return missingPolicy === "zero"
+        ? { ...base, status: "imputed-zero", value: 0 }
+        : { ...base, status: "missing", value: null };
+    };
+    for (const row of rows)
+      for (const measure of nonExposureMeasures) {
+        if (measure.source === "derived") {
+          const state = derivedAuditByRecord.get(row.recordId)!.derived[
+            measure.id
+          ]!;
+          contributions[measure.id]!.push(
+            derivedContribution(row, measure.missing, state),
+          );
+          for (const overflow of derivedAuditByRecord.get(row.recordId)!
+            .expressionOverflows[measure.id] ?? []) {
+            cellFindings.push({
+              code: "diagnostic-expression-overflow",
+              message: "Measure expression overflowed",
+              severity: "fail",
+              category: "aggregation",
+              measureId: measure.id,
+              expressionPath: overflow.expressionPath,
+              recordId: row.recordId,
+              sourceGroup,
+              origin,
+              valuation,
+              developmentAge: coordinate.developmentAge,
+              ageUnit: coordinate.ageUnit,
+              sources: row.source ? [row.source] : [],
+            });
+          }
+        } else
+          contributions[measure.id]!.push(
+            auditedDiagnosticContribution(
+              row.recordId,
+              own(row.measures, measure.id),
+              measure.missing,
+              row.source ? [row.source] : [],
+            ),
+          );
       }
+    const attachedExposures = validExposuresByCell.get(key) ?? [];
+    for (const exposure of attachedExposures)
+      contributions[exposure.measureId]!.push(
+        auditedDiagnosticContribution(
+          exposure.key,
+          exposure.value,
+          "unknown",
+          exposure.sources,
+          exposure.deduplicated,
+        ),
+      );
+    for (const pending of pendingBlockersByCell.get(key) ?? []) {
+      cellFindings.push(pending.finding);
+      const blocker = {
+        code: pending.finding.code,
+        message: pending.finding.message,
+        sourceIds: uniqueSorted(pending.sourceIds),
+        sources: normalizeSources(pending.finding.sources),
+        finding: pending.finding,
+      };
+      for (const measureId of pending.measureIds)
+        blockers[measureId]!.push(blocker);
     }
-    for (const exposure of exposures) {
-      if (exposure.status !== "valid" || exposure.sourceGroup !== sourceGroup || exposure.origin !== origin || (exposure.valuation !== undefined && exposure.valuation !== valuation)) continue;
-      contributions[exposure.measureId]!.push(auditedDiagnosticContribution(exposure.key, exposure.value, "unknown", exposure.sources, exposure.deduplicated));
+    for (const measure of exposureMeasures) {
+      const attempted =
+        attachedExposures.some(
+          (exposure) => exposure.measureId === measure.id,
+        ) || invalidExposureMeasuresByCell.get(key)?.has(measure.id);
+      if (contributions[measure.id]!.length === 0 && !attempted) {
+        const sources = normalizeSources(rows.map((row) => row.source));
+        const finding = structuralFinding("loss-without-exposure", {
+          measureId: measure.id,
+          sourceGroup,
+          origin,
+          valuation,
+          developmentAge: coordinate.developmentAge,
+          ageUnit: coordinate.ageUnit,
+          sources,
+        });
+        findings.push(finding);
+        cellFindings.push(finding);
+        blockers[measure.id]!.push({
+          code: finding.code,
+          message: finding.message,
+          sourceIds: uniqueSorted(rows.map((row) => row.recordId)),
+          sources,
+          finding,
+        });
+      }
     }
-    for (const measure of definition.definition.measures.filter((item) => item.source === "exposure")) {
-      if (contributions[measure.id]!.length === 0) blockers[measure.id]!.push({ code: "loss-without-exposure", message: "Loss cell has no applicable exposure observation", sourceIds: rows.map((row) => row.recordId).sort(codeUnit), sources: [] });
+    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(definition.definition.measures.map((measure) => [measure.id, finalizeDiagnosticContributions(contributions[measure.id]!, measure.missing, blockers[measure.id])])) as Record<string, DiagnosticMeasureStats>;
-    preparedCells.push(deepFreeze({ sourceGroup, origin, valuation, developmentAge: period.developmentAge, ageUnit: period.ageUnit, lossRecordIds: rows.map((row) => row.recordId).sort(codeUnit), contributions, components, structuralBlockers: blockers, findings: [] }));
+    const components = Object.fromEntries(
+      allMeasureIds.map((measureId) => {
+        const measure = internals.measuresById.get(measureId)!;
+        return [
+          measureId,
+          finalizeDiagnosticContributions(
+            contributions[measureId]!,
+            measure.missing,
+            blockers[measureId],
+          ),
+        ];
+      }),
+    ) as Record<string, DiagnosticMeasureStats>;
+    for (const measureId of allMeasureIds) {
+      const measureContributions = contributions[measureId]!;
+      const context = {
+        measureId,
+        sourceGroup,
+        origin,
+        valuation,
+        developmentAge: coordinate.developmentAge,
+        ageUnit: coordinate.ageUnit,
+      };
+      const missing = measureContributions.filter(
+        (item) => item.status === "missing",
+      );
+      const imputed = measureContributions.filter(
+        (item) => item.status === "imputed-zero",
+      );
+      const nonFinite = measureContributions.filter(
+        (item) => item.status === "non-finite",
+      );
+      if (missing.length > 0)
+        cellFindings.push(
+          aggregationFinding("diagnostic-measure-missing", {
+            ...context,
+            sources: missing.flatMap((item) => item.sources),
+          }),
+        );
+      if (imputed.length > 0)
+        cellFindings.push(
+          aggregationFinding("diagnostic-measure-imputed-zero", {
+            ...context,
+            sources: imputed.flatMap((item) => item.sources),
+          }),
+        );
+      if (nonFinite.length > 0)
+        cellFindings.push(
+          aggregationFinding("diagnostic-measure-non-finite", {
+            ...context,
+            sources: nonFinite.flatMap((item) => item.sources),
+          }),
+        );
+      if (
+        components[measureId]!.sum === null &&
+        components[measureId]!.nonFinite === 0 &&
+        components[measureId]!.structural === 0
+      )
+        cellFindings.push(
+          aggregationFinding("diagnostic-measure-overflow", {
+            ...context,
+            sources: measureContributions.flatMap((item) => item.sources),
+          }),
+        );
+    }
+    findings.push(...cellFindings);
+    preparedCells.push({
+      sourceGroup,
+      origin,
+      valuation,
+      developmentAge: coordinate.developmentAge,
+      ageUnit: coordinate.ageUnit,
+      lossRecordIds: uniqueSorted(rows.map((row) => row.recordId)),
+      contributions,
+      components,
+      structuralBlockers: blockers,
+      findings: mergeFindings(cellFindings),
+    });
+  }
+
+  for (const candidate of expectedCandidates.filter(
+    (item) => item.disposition === "retained",
+  )) {
+    const key = cellKey(
+      candidate.row.sourceGroup,
+      candidate.row.origin,
+      candidate.row.valuation,
+    );
+    if (!cellRows.has(key))
+      findings.push(
+        structuralFinding("missing-expected-cell", {
+          sourceGroup: candidate.row.sourceGroup,
+          origin: candidate.row.origin,
+          valuation: candidate.row.valuation,
+          developmentAge: candidate.coordinate.developmentAge,
+          ageUnit: candidate.coordinate.ageUnit,
+          sources: candidate.row.source ? [candidate.row.source] : [],
+        }),
+      );
+  }
+
+  const originCoordinates = new Map<string, number>();
+  const valuationCoordinates = new Map<string, number>();
+  for (const cell of preparedCells) {
+    originCoordinates.set(
+      cell.origin,
+      normalizeDiagnosticPeriod(definition, "origin", cell.origin).coordinate,
+    );
+    valuationCoordinates.set(
+      cell.valuation,
+      normalizeDiagnosticPeriod(definition, "valuation", cell.valuation)
+        .coordinate,
+    );
+  }
+  preparedCells.sort(
+    (left, right) =>
+      codeUnit(left.sourceGroup, right.sourceGroup) ||
+      originCoordinates.get(left.origin)! -
+        originCoordinates.get(right.origin)! ||
+      valuationCoordinates.get(left.valuation)! -
+        valuationCoordinates.get(right.valuation)! ||
+      codeUnit(left.origin, right.origin) ||
+      codeUnit(left.valuation, right.valuation),
+  );
+  const expectedCells = expectedCandidates
+    .filter((candidate) => candidate.disposition === "retained")
+    .sort(
+      (left, right) =>
+        codeUnit(left.row.sourceGroup, right.row.sourceGroup) ||
+        compareDiagnosticPeriods(
+          left.coordinate.origin,
+          right.coordinate.origin,
+        ) ||
+        compareDiagnosticPeriods(
+          left.coordinate.valuation,
+          right.coordinate.valuation,
+        ),
+    )
+    .map((candidate) => candidate.row);
+  const audit: DiagnosticInputAuditRecord[] = [
+    ...lossCandidates.map((candidate): DiagnosticInputAuditRecord => ({
+      kind: "loss",
+      disposition: candidate.disposition,
+      record: candidate.snapshot,
+    })),
+    ...exposureCandidates.map((candidate): DiagnosticInputAuditRecord => ({
+      kind: "exposure",
+      disposition: candidate.disposition,
+      record: candidate.snapshot,
+    })),
+    ...expectedCandidates.map((candidate): DiagnosticInputAuditRecord => ({
+      kind: "expected-cell",
+      disposition: candidate.disposition,
+      record: candidate.snapshot,
+    })),
+  ].sort(createAuditComparator());
+  const normalizedFindings = mergeFindings(findings);
+  const frozenCells = preparedCells.map((cell) => deepFreeze(cell));
+  const cutoffValues = normalizedCutoffs.map((cutoff) => cutoff.value);
+  const ownedData = deepFreeze({
+    definitionIntegrity: definition.definitionIntegrity,
+    filter,
+    completePeriodCutoffs: cutoffValues,
+    inputAudit: audit,
+    cells: frozenCells,
+    exposures: reconciled,
+    expectedCellsProvided: input.expectedCells !== undefined,
+    expectedCells,
+    findings: normalizedFindings,
+  });
+  if (mode === "compact") {
+    // Every child was frozen above (the compiled definition owns its snapshot).
+    const prepared = Object.freeze({
+      definition,
+      ...ownedData,
+    }) as unknown as CompactPreparedDiagnosticData;
+    authenticCompact.add(prepared);
+    return prepared;
   }
-  preparedCells.sort((a, b) => codeUnit(a.sourceGroup, b.sourceGroup) || codeUnit(a.origin, b.origin) || codeUnit(a.valuation, b.valuation));
-  const expectedCells = (input.expectedCells ?? []).map((item) => ({ ...item }));
-  for (const item of expectedCells) audit.push({ kind: "expected-cell", disposition: "retained", record: item });
-  const identity = deepFreeze({ definitionIntegrity: definition.definitionIntegrity, filter, completePeriodCutoffs: [...(input.completePeriodCutoffs ?? [])], inputAudit: audit, cells: preparedCells, exposures, expectedCellsProvided: input.expectedCells !== undefined, expectedCells, findings: [] });
+  return createEagerPreparedDiagnosticData(definition, ownedData);
+}
+
+function createEagerPreparedDiagnosticData(
+  definition: CompiledDiagnosticDefinition,
+  ownedData: Omit<PreparedDiagnosticDataContent, "definition"> & {
+    readonly definitionIntegrity: string;
+  },
+): PreparedDiagnosticData {
+  const identity: NormalizedDiagnosticPreparationIdentity =
+    projectDiagnosticIdentity({
+      ...ownedData,
+      filter: normalizeDiagnosticsFilterIdentity(ownedData.filter),
+      expectedCells: ownedData.expectedCells.map((cell) => ({
+        ...cell,
+        source: cell.source ?? null,
+      })),
+    });
   const preparationFingerprint = `fnv1a64-jcs-v1:${fnv1a64(canonicalJson({ identityVersion: 1, kind: "diagnostic-preparation", preparation: identity }))}`;
-  const preparedBase = { definition, preparationFingerprint, filter, completePeriodCutoffs: input.completePeriodCutoffs ?? [], inputAudit: audit, cells: preparedCells, exposures, expectedCellsProvided: input.expectedCells !== undefined, expectedCells, findings: [] };
-  const prepared = deepFreeze(preparedBase) as unknown as PreparedDiagnosticData;
+  const prepared = deepFreeze({
+    definition,
+    preparationFingerprint,
+    ...ownedData,
+  }) as unknown as PreparedDiagnosticData;
   authentic.add(prepared);
   identities.set(prepared, identity);
   return prepared;
 }
 
-export function assertPreparedDiagnosticData(value: unknown): asserts value is PreparedDiagnosticData {
-  if (value === null || typeof value !== "object" || !authentic.has(value)) throw new DiagnosticValidationError([{ domain: "input", code: "invalid-input-relationship", path: "$.prepared", message: "Value is not authentic prepared diagnostic data" }]);
+export function assertCompactPreparedDiagnosticData(
+  value: unknown,
+): asserts value is CompactPreparedDiagnosticData {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    !authenticCompact.has(value)
+  )
+    throw new DiagnosticValidationError([
+      {
+        domain: "input",
+        code: "invalid-input-relationship",
+        path: "$.prepared",
+        message: "Compact prepared diagnostic data is not authentic",
+      },
+    ]);
+}
+
+/**
+ * Explicit eager bridge for callers that need the legacy complete JSON shape.
+ * This materializes and hashes the full identity; compact execution never calls
+ * it implicitly, and the compact value does not retain the resulting graph.
+ */
+export function materializePreparedDiagnosticData(
+  value: CompactPreparedDiagnosticData,
+): PreparedDiagnosticData {
+  assertCompactPreparedDiagnosticData(value);
+  return createEagerPreparedDiagnosticData(value.definition, {
+    definitionIntegrity: value.definition.definitionIntegrity,
+    filter: value.filter,
+    completePeriodCutoffs: value.completePeriodCutoffs,
+    inputAudit: value.inputAudit,
+    cells: value.cells,
+    exposures: value.exposures,
+    expectedCellsProvided: value.expectedCellsProvided,
+    expectedCells: value.expectedCells,
+    findings: value.findings,
+  });
+}
+
+/**
+ * Core-owned, complete identity projection, emitted without a second retained
+ * preparation graph. A structural document is not itself actuarial authority:
+ * this factory authenticates the frozen preparation before creating one.
+ */
+export function getCompactPreparedDiagnosticDataIdentityDocument(
+  value: CompactPreparedDiagnosticData,
+): DiagnosticIdentityDocument {
+  assertCompactPreparedDiagnosticData(value);
+  const previous = compactIdentityDocuments.get(value);
+  if (previous) return previous;
+  const document = createDiagnosticIdentityObject({
+    definitionIntegrity: createDiagnosticIdentityValue(
+      value.definition.definitionIntegrity,
+    ),
+    filter: createDiagnosticIdentityValue(
+      normalizeDiagnosticsFilterIdentity(value.filter),
+    ),
+    completePeriodCutoffs: createDiagnosticIdentityValue(
+      value.completePeriodCutoffs,
+    ),
+    inputAudit: createDiagnosticIdentityValue(value.inputAudit),
+    cells: createDiagnosticIdentityValue(value.cells),
+    exposures: createDiagnosticIdentityValue(value.exposures),
+    expectedCellsProvided: createDiagnosticIdentityValue(
+      value.expectedCellsProvided,
+    ),
+    expectedCells: createDiagnosticIdentityArray(
+      value.expectedCells.length,
+      (index) => {
+        const cell = value.expectedCells[index]!;
+        return createDiagnosticIdentityObject({
+          sourceGroup: createDiagnosticIdentityValue(cell.sourceGroup),
+          origin: createDiagnosticIdentityValue(cell.origin),
+          valuation: createDiagnosticIdentityValue(cell.valuation),
+          source: createDiagnosticIdentityValue(cell.source ?? null),
+        });
+      },
+    ),
+    findings: createDiagnosticIdentityValue(value.findings),
+  });
+  compactIdentityDocuments.set(value, document);
+  return document;
 }
-export function getPreparedDiagnosticDataIdentity(value: PreparedDiagnosticData): DiagnosticDeepReadonly<NormalizedDiagnosticPreparationIdentity> { assertPreparedDiagnosticData(value); return identities.get(value)! }
-export function verifyPreparedDiagnosticDataIntegrity(value: PreparedDiagnosticData): void {
+
+/** Compute the exact legacy preparation tag on explicit evidence access only. */
+export function getCompactPreparedDiagnosticDataFingerprint(
+  value: CompactPreparedDiagnosticData,
+): string {
+  assertCompactPreparedDiagnosticData(value);
+  const previous = compactFingerprints.get(value);
+  if (previous) return previous;
+  const tag = fingerprintDiagnosticIdentity(
+    getCompactPreparedDiagnosticDataIdentityDocument(value),
+    { kind: "diagnostic-preparation", property: "preparation" },
+  );
+  compactFingerprints.set(value, tag);
+  return tag;
+}
+
+export function assertPreparedDiagnosticData(
+  value: unknown,
+): asserts value is PreparedDiagnosticData {
+  if (value === null || typeof value !== "object" || !authentic.has(value))
+    throw new DiagnosticValidationError([
+      {
+        domain: "input",
+        code: "invalid-input-relationship",
+        path: "$.prepared",
+        message: "Prepared diagnostic data is not authentic",
+      },
+    ]);
+}
+
+export function getPreparedDiagnosticDataIdentity(
+  value: PreparedDiagnosticData,
+): DiagnosticDeepReadonly<NormalizedDiagnosticPreparationIdentity> {
+  assertPreparedDiagnosticData(value);
+  return identities.get(value)!;
+}
+
+export function verifyPreparedDiagnosticDataIntegrity(
+  value: PreparedDiagnosticData,
+): void {
   const identity = getPreparedDiagnosticDataIdentity(value);
   const tag = `fnv1a64-jcs-v1:${fnv1a64(canonicalJson({ identityVersion: 1, kind: "diagnostic-preparation", preparation: identity }))}`;
-  if (tag !== value.preparationFingerprint) throw new DiagnosticValidationError([{ domain: "input", code: "invalid-input-relationship", path: "$.prepared.preparationFingerprint", message: "Prepared diagnostic data integrity does not match its content" }]);
+  if (tag !== value.preparationFingerprint)
+    throw new DiagnosticValidationError([
+      {
+        domain: "input",
+        code: "invalid-input-relationship",
+        path: "$.prepared.preparationFingerprint",
+        message:
+          "Prepared diagnostic data integrity does not match its content",
+      },
+    ]);
 }
 
-export type { JsonValue, DiagnosticAuditedNumericValue };
+export type {
+  JsonValue,
+  DiagnosticAuditedNumericValue,
+  DiagnosticExposureAuditObservation,
+};