@actuarial-ts/core 0.7.0 → 0.8.0

package/src/diagnosticReviewStore.ts

@@ -20,6 +20,7 @@ import { DiagnosticValidationError } from "./types.js";
 import {
   createDiagnosticIdentityArray,
   createDiagnosticIdentityObject,
+  createDiagnosticIdentityMixedObject,
   createDiagnosticIdentityValue,
   type DiagnosticIdentityDocument,
 } from "./diagnosticIdentityStream.js";
@@ -140,8 +141,82 @@ interface State {
   sourceLists: readonly Uint32Array[];
   overflows: ReadonlyMap<number, readonly EncodedOverflow[]>;
   controls: ReadonlyMap<number, Omit<Control, "sources">>;
+  selection?: {
+    readonly owners: readonly State[];
+    readonly ownerIds: Uint8Array;
+    readonly indices: Uint32Array;
+  };
 }
 const states = new WeakMap<object, State>();
+function resolveRow(state: State, index: number): { state: State; index: number } {
+  while (state.selection) {
+    const selection = state.selection;
+    state = selection.owners[selection.ownerIds[index]!]!;
+    index = selection.indices[index]!;
+  }
+  return { state, index };
+}
+
+/** Private evidence projection: invariant source-local rows plus newly evaluated controls. */
+export function selectCompactReviewSources(
+  original: CompactDiagnosticReviewEvaluations,
+  controls: CompactDiagnosticReviewEvaluations,
+  groups: ReadonlySet<string> | undefined,
+  origins?: ReadonlySet<string>,
+  cells?: ReadonlySet<string>,
+): CompactDiagnosticReviewEvaluations {
+  const parent = stateOf(original);
+  const control = stateOf(controls);
+  if (parent.rules !== control.rules) invalid("Review definitions must share ownership");
+  const ownerIds: number[] = [];
+  const indices: number[] = [];
+  const counts = zeroCounts();
+  const cellMembership = new WeakMap<DiagnosticReviewCoordinate, boolean>();
+  const rules = parent.rules.map((rule, ruleIndex) => {
+    const ownerId = rule.kind === "control-total" || (cells !== undefined && rule.kind === "monotonic") ? 1 : 0;
+    const source = ownerId === 1 ? controls : original;
+    const sourceState = ownerId === 1 ? control : parent;
+    const range = source.rules[ruleIndex]!;
+    const start = indices.length;
+    const summary = zeroCounts();
+    for (let index = range.start; index < range.start + range.count; index++) {
+      const resolved = resolveRow(sourceState, index);
+      const chunk = resolved.state.chunks[Math.floor(resolved.index / CHUNK_SIZE)]!;
+      const row = resolved.index % CHUNK_SIZE;
+      if (ownerId === 0 && cells) {
+        const coordinate = resolved.state.coordinates[chunk.first[row]!]!;
+        let included = cellMembership.get(coordinate);
+        if (included === undefined) {
+          included = cells.has(JSON.stringify([coordinate.sourceGroup, coordinate.origin, coordinate.valuation]));
+          cellMembership.set(coordinate, included);
+        }
+        if (!included) continue;
+      }
+      if (ownerId === 0 && origins &&
+        !origins.has(resolved.state.coordinates[chunk.first[row]!]!.origin)) continue;
+      if (ownerId === 0 && groups) {
+        if (!groups.has(resolved.state.coordinates[chunk.first[row]!]!.sourceGroup)) continue;
+        if (rule.kind === "monotonic" &&
+          !groups.has(resolved.state.coordinates[chunk.second[row]!]!.sourceGroup)) continue;
+      }
+      assertCompactReviewCapacity(indices.length);
+      ownerIds.push(ownerId);
+      indices.push(index);
+      const status = effective(statuses[chunk.flags[row]! & 3]!, rule.severity,
+        resolved.state.overflows.get(resolved.index)?.length ?? 0);
+      increment(summary, status);
+      increment(counts, status);
+    }
+    return Object.freeze({ ruleId: rule.id, start, count: indices.length - start,
+      summary: Object.freeze(summary) });
+  });
+  const handle = Object.freeze({ count: indices.length, summary: Object.freeze(counts),
+    rules: Object.freeze(rules) }) as CompactDiagnosticReviewEvaluations;
+  states.set(handle, { ...parent, count: indices.length,
+    selection: { owners: [parent, control], ownerIds: Uint8Array.from(ownerIds),
+      indices: Uint32Array.from(indices) } });
+  return handle;
+}
 /** Private index guard: reject capacity overflow before any Uint32 assignment. */
 export function assertCompactReviewCapacity(count: number, addition = 1): void {
   if (
@@ -223,7 +298,10 @@ export function createCompactReviewBuilder(
   const coordinates: DiagnosticReviewCoordinate[] = [];
   const sourceLocations: DiagnosticSourceLocation[] = [];
   const sourceLists: Uint32Array[] = [];
-  const coordinateIds = new Map<string, number>();
+  // Invocation-local tuple index: avoid allocating/serializing the same five
+  // coordinate fields for every rule evaluation. Never retained by State.
+  type CoordinateIndex = Map<string | number, CoordinateIndex | number>;
+  const coordinateIds: CoordinateIndex = new Map();
   const sourceIds = new Map<string, number>();
   // Only this evaluator invocation's snapshots may skip canonicalization.
   // Merely freezing a caller array/object does not prove deep snapshot ownership.
@@ -238,18 +316,25 @@ export function createCompactReviewBuilder(
   let count = 0;
   let finished = false;
   const coordinateId = (value: DiagnosticReviewCoordinate): number => {
-    const key = JSON.stringify([
+    let index = coordinateIds;
+    for (const key of [
       value.sourceGroup,
       value.origin,
       value.valuation,
       Object.is(value.developmentAge, -0) ? "-0" : value.developmentAge,
-      value.ageUnit,
-    ]);
-    let id = coordinateIds.get(key);
+    ]) {
+      let next = index.get(key) as CoordinateIndex | undefined;
+      if (!next) {
+        next = new Map();
+        index.set(key, next);
+      }
+      index = next;
+    }
+    let id = index.get(value.ageUnit) as number | undefined;
     if (id === undefined) {
       assertCompactReviewCapacity(coordinates.length);
       id = coordinates.length;
-      coordinateIds.set(key, id);
+      index.set(value.ageUnit, id);
       coordinates.push(Object.freeze({ ...value }));
     }
     return id;
@@ -391,6 +476,8 @@ function summaryAt(
   state: State,
   index: number,
 ): DiagnosticReviewEvaluationSummary {
+  const outputIndex = index;
+  ({ state, index } = resolveRow(state, index));
   const chunk = state.chunks[Math.floor(index / CHUNK_SIZE)]!;
   const row = index % CHUNK_SIZE;
   const rule = state.rules[chunk.rule[row]!]!;
@@ -414,7 +501,7 @@ function summaryAt(
             sourceCount,
           };
   return Object.freeze({
-    index,
+    index: outputIndex,
     ruleId: rule.id,
     ruleKind: rule.kind,
     status,
@@ -444,8 +531,9 @@ export function getDiagnosticReviewEvaluation(
   store: CompactDiagnosticReviewEvaluations,
   index: number,
 ): DiagnosticReviewRuleEvaluation {
-  const state = stateOf(store);
+  let state = stateOf(store);
   checkedIndex(state, index);
+  ({ state, index } = resolveRow(state, index));
   const {
     index: _index,
     effectiveStatus: _effective,
@@ -498,13 +586,16 @@ export function getCompactDiagnosticReviewEvaluationsIdentityDocument(
   store: CompactDiagnosticReviewEvaluations,
 ): DiagnosticIdentityDocument {
   const state = stateOf(store);
-  const sources = (id: number) => {
+  const sources = (state: State, id: number) => {
     const values = state.sourceLists[id]!;
     return createDiagnosticIdentityArray(values.length, (index) =>
       createDiagnosticIdentityValue(state.sourceLocations[values[index]!]!),
     );
   };
   return createDiagnosticIdentityArray(state.count, (index) => {
+    const resolved = resolveRow(state, index);
+    const owner = resolved.state;
+    const ownerIndex = resolved.index;
     const {
       index: _index,
       effectiveStatus: _effective,
@@ -513,45 +604,36 @@ export function getCompactDiagnosticReviewEvaluationsIdentityDocument(
       ...base
     } = summaryAt(state, index);
     const { sourceCount: _sources, ...scopeValues } = scope;
-    const chunk = state.chunks[Math.floor(index / CHUNK_SIZE)]!;
-    const row = index % CHUNK_SIZE;
-    const rule = state.rules[chunk.rule[row]!]!;
-    const overflow = state.overflows.get(index) ?? [];
-    return createDiagnosticIdentityObject({
-      ...Object.fromEntries(
-        Object.entries(base).map(([key, value]) => [
-          key,
-          createDiagnosticIdentityValue(value),
-        ]),
-      ),
-      scope: createDiagnosticIdentityObject({
-        ...Object.fromEntries(
-          Object.entries(scopeValues).map(([key, value]) => [
-            key,
-            createDiagnosticIdentityValue(value),
-          ]),
+    const chunk = owner.chunks[Math.floor(ownerIndex / CHUNK_SIZE)]!;
+    const row = ownerIndex % CHUNK_SIZE;
+    const rule = owner.rules[chunk.rule[row]!]!;
+    const overflow = owner.overflows.get(ownerIndex) ?? [];
+    return createDiagnosticIdentityMixedObject(
+      {
+        ...base,
+        ...(rule.kind === "layer-order" ? { comparability: rule.comparability } : {}),
+      },
+      {
+        scope: createDiagnosticIdentityMixedObject(scopeValues, {
+          sources: sources(owner, chunk.sources[row]!),
+        }),
+        expressionOverflows: createDiagnosticIdentityArray(
+          overflow.length,
+          (overflowIndex) => {
+            const item = overflow[overflowIndex]!;
+            return createDiagnosticIdentityObject({
+              expressionPath: createDiagnosticIdentityValue(item.path),
+              coordinate: createDiagnosticIdentityValue(
+                item.coordinate === null
+                  ? null
+                  : owner.coordinates[item.coordinate]!,
+              ),
+              sources: sources(owner, item.sources),
+            });
+          },
         ),
-        sources: sources(chunk.sources[row]!),
-      }),
-      expressionOverflows: createDiagnosticIdentityArray(
-        overflow.length,
-        (overflowIndex) => {
-          const item = overflow[overflowIndex]!;
-          return createDiagnosticIdentityObject({
-            expressionPath: createDiagnosticIdentityValue(item.path),
-            coordinate: createDiagnosticIdentityValue(
-              item.coordinate === null
-                ? null
-                : state.coordinates[item.coordinate]!,
-            ),
-            sources: sources(item.sources),
-          });
-        },
-      ),
-      ...(rule.kind === "layer-order"
-        ? { comparability: createDiagnosticIdentityValue(rule.comparability) }
-        : {}),
-    });
+      },
+    );
   });
 }
 function checkedQuery<T extends object>(
@@ -632,25 +714,27 @@ export function pageDiagnosticReviewEvaluations(
     (checked.valuation === undefined ||
       coordinate.valuation === checked.valuation);
   for (let index = range.start; index < range.start + range.count; index++) {
-    const chunk = state.chunks[Math.floor(index / CHUNK_SIZE)]!;
-    const row = index % CHUNK_SIZE;
-    const rule = state.rules[chunk.rule[row]!]!;
+    const resolved = resolveRow(state, index);
+    const owner = resolved.state;
+    const chunk = owner.chunks[Math.floor(resolved.index / CHUNK_SIZE)]!;
+    const row = resolved.index % CHUNK_SIZE;
+    const rule = owner.rules[chunk.rule[row]!]!;
     if (
       checked.effectiveStatus !== undefined &&
       checked.effectiveStatus !==
         effective(
           statuses[chunk.flags[row]! & 3]!,
           rule.severity,
-          state.overflows.get(index)?.length ?? 0,
+          owner.overflows.get(resolved.index)?.length ?? 0,
         )
     )
       continue;
     if (
       coordinateFilter &&
       (rule.kind === "control-total" ||
-        (!matches(state.coordinates[chunk.first[row]!]!) &&
+        (!matches(owner.coordinates[chunk.first[row]!]!) &&
           (rule.kind !== "monotonic" ||
-            !matches(state.coordinates[chunk.second[row]!]!))))
+            !matches(owner.coordinates[chunk.second[row]!]!))))
     )
       continue;
     if (total >= checked.offset && items.length < checked.limit)
@@ -664,8 +748,9 @@ export function pageDiagnosticReviewEvaluationSources(
   index: number,
   query: DiagnosticReviewSourceQuery = {},
 ): DiagnosticReviewPage<DiagnosticSourceLocation> {
-  const state = stateOf(store);
+  let state = stateOf(store);
   checkedIndex(state, index);
+  ({ state, index } = resolveRow(state, index));
   const checked = checkedQuery(query, ["offset", "limit", "overflowIndex"]);
   const overflowIndex = checked.overflowIndex;
   if (

package/src/diagnosticRunner.ts

@@ -47,6 +47,7 @@ import {
 import { compareDiagnosticFindings } from "./diagnosticOrdering.js";
 import { normalizeDiagnosticPeriod } from "./diagnosticPeriods.js";
 import { normalizeDiagnosticSourceLocations } from "./diagnosticSourceOrdering.js";
+import { freezeDiagnosticGraph as deepFreeze } from "./diagnosticFreeze.js";
 import {
   diagnosticJsonPreflight,
   hasDiagnosticOwn,
@@ -163,17 +164,6 @@ function codeUnit(a: string, b: string): number {
 function pointer(path: string, segment: string | number): string {
   return `${path}/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`;
 }
-function deepFreeze<T>(
-  value: T,
-  seen = new WeakSet<object>(),
-): DiagnosticDeepReadonly<T> {
-  if (value === null || typeof value !== "object" || seen.has(value))
-    return value as DiagnosticDeepReadonly<T>;
-  seen.add(value);
-  for (const child of Object.values(value as Record<string, unknown>))
-    deepFreeze(child, seen);
-  return Object.freeze(value) as DiagnosticDeepReadonly<T>;
-}
 function quantity(
   measure: DiagnosticMeasureDefinition,
   value: number | null,

package/src/exposureEarning.ts

@@ -0,0 +1,314 @@
+import type {
+  CustomizationCapabilityFinding,
+  CustomizationExposureObservation,
+  EarnedExposureAllocation,
+  ExposureAllocationResult,
+  ExposureAllocationTarget,
+  ExposureMeasureDefinitionV1,
+  ExposureScopeDefinition,
+  HistoricalScalar,
+} from "./customizationContracts.js";
+import { isRealIsoDate, snapshotDiagnosticJson } from "./diagnosticRuntime.js";
+import { daysBetweenIsoDates } from "./policyPeriods.js";
+import { DiagnosticValidationError, type DiagnosticValidationIssue } from "./types.js";
+
+function compareText(left: string, right: string): number {
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+
+function dimensionsMatch(
+  source: Readonly<Record<string, HistoricalScalar>>,
+  target: Readonly<Record<string, HistoricalScalar>>,
+  keys: readonly string[],
+): boolean {
+  return keys.every((key) => Object.is(source[key], target[key]));
+}
+
+function overlapDays(
+  sourceStart: string,
+  sourceEnd: string,
+  targetStart: string,
+  targetEnd: string,
+): number {
+  const start = sourceStart > targetStart ? sourceStart : targetStart;
+  const end = sourceEnd < targetEnd ? sourceEnd : targetEnd;
+  return end <= start ? 0 : daysBetweenIsoDates(start, end);
+}
+
+function validateInput(
+  definition: ExposureMeasureDefinitionV1,
+  scope: ExposureScopeDefinition,
+  observation: CustomizationExposureObservation,
+  targets: readonly ExposureAllocationTarget[],
+): void {
+  const issues: DiagnosticValidationIssue[] = [];
+  if (observation.measureId !== definition.id)
+    issues.push({
+      domain: "input",
+      code: "invalid-input-relationship",
+      path: "$.observation.measureId",
+      message: "Exposure observation does not match the measure definition",
+    });
+  if (definition.scopeId !== scope.id)
+    issues.push({
+      domain: "configuration",
+      code: "unknown-reference",
+      path: "$.definition.scopeId",
+      message: "Exposure definition does not reference the supplied scope",
+    });
+  if (observation.value !== null && !Number.isFinite(observation.value))
+    issues.push({
+      domain: "input",
+      code: "invalid-number",
+      path: "$.observation.value",
+      message: "Exposure value must be finite or null",
+    });
+  if (definition.sourceMeaning === "point-in-time") {
+    if (!isRealIsoDate(observation.pointDate))
+      issues.push({
+        domain: "input",
+        code: "missing-required",
+        path: "$.observation.pointDate",
+        message: "Point-in-time exposure requires pointDate",
+      });
+  } else if (
+    !isRealIsoDate(observation.startDate) ||
+    !isRealIsoDate(observation.endDate) ||
+    observation.startDate >= observation.endDate
+  )
+    issues.push({
+      domain: "input",
+      code: "invalid-period",
+      path: "$.observation",
+      message: "Interval exposure requires startDate before endDate",
+    });
+  targets.forEach((target, index) => {
+    if (!isRealIsoDate(target.startDate) || !isRealIsoDate(target.endDate) || target.startDate >= target.endDate)
+      issues.push({
+        domain: "configuration",
+        code: "invalid-period",
+        path: `$.targets[${index}]`,
+        message: "Allocation target requires startDate before endDate",
+      });
+  });
+  if (issues.length > 0) throw new DiagnosticValidationError(issues);
+}
+
+/**
+ * Earns and allocates one source exposure under explicit interval, scope, and
+ * allocation meanings. It never converts point-in-time stock into a flow.
+ */
+export function earnAndAllocateExposure(input: {
+  readonly definition: ExposureMeasureDefinitionV1;
+  readonly scope: ExposureScopeDefinition;
+  readonly observation: CustomizationExposureObservation;
+  readonly targets: readonly ExposureAllocationTarget[];
+}): ExposureAllocationResult {
+  validateInput(input.definition, input.scope, input.observation, input.targets);
+  const findings: CustomizationCapabilityFinding[] = [];
+  if (input.observation.value === null)
+    return snapshotDiagnosticJson({
+      measureId: input.definition.id,
+      sourceValue: null,
+      allocations: [],
+      allocatedValue: 0,
+      unallocatedValue: null,
+      findings: [
+        {
+          code: "missing-prerequisite",
+          capability: "exposure-earning",
+          path: `$.exposures.${input.observation.id}.value`,
+          message: "Missing source exposure cannot be allocated",
+          requiredFields: ["value"],
+        },
+      ],
+    });
+  const missingPopulationKeys = input.scope.populationKeys.filter(
+    (key) => !Object.hasOwn(input.observation.dimensions, key),
+  );
+  if (missingPopulationKeys.length > 0)
+    return snapshotDiagnosticJson({
+      measureId: input.definition.id,
+      sourceValue: input.observation.value,
+      allocations: [],
+      allocatedValue: 0,
+      unallocatedValue: input.observation.value,
+      findings: [
+        {
+          code: "missing-prerequisite",
+          capability: "exposure-earning",
+          path: `$.exposures.${input.observation.id}.dimensions`,
+          message: `Exposure observation lacks population keys: ${missingPopulationKeys.join(", ")}`,
+          requiredFields: missingPopulationKeys.map((key) => `dimensions.${key}`),
+        },
+      ],
+    });
+  if (input.definition.sourceMeaning === "point-in-time")
+    return snapshotDiagnosticJson({
+      measureId: input.definition.id,
+      sourceValue: input.observation.value,
+      allocations: [],
+      allocatedValue: 0,
+      unallocatedValue: input.observation.value,
+      findings: [
+        {
+          code: "unsupported-operation",
+          capability: "exposure-earning",
+          path: `$.exposures.${input.observation.id}`,
+          message: "Point-in-time exposure cannot be allocated as additive interval exposure",
+        },
+      ],
+    });
+  const matching = input.targets.filter((target) =>
+    dimensionsMatch(input.observation.dimensions, target.dimensions, input.scope.populationKeys),
+  );
+  if (matching.length === 0)
+    findings.push({
+      code: "missing-prerequisite",
+      capability: "exposure-earning",
+      path: `$.exposures.${input.observation.id}`,
+      message: "No allocation target matches the declared exposure population keys",
+    });
+  let allocations: EarnedExposureAllocation[] = [];
+  const value = input.observation.value;
+  const sourceStart = input.observation.startDate!;
+  const sourceEnd = input.observation.endDate!;
+  if (input.definition.allocation.kind === "exact-match") {
+    const exact = matching.filter(
+      (target) => target.startDate === sourceStart && target.endDate === sourceEnd,
+    );
+    if (exact.length === 1)
+      allocations = [
+        {
+          sourceObservationId: input.observation.id,
+          targetId: exact[0]!.id,
+          value,
+          method: "exact-match",
+          overlapDays: daysBetweenIsoDates(sourceStart, sourceEnd),
+        },
+      ];
+    else if (exact.length > 1)
+      findings.push({
+        code: "ambiguous-attribution",
+        capability: "exposure-earning",
+        path: `$.exposures.${input.observation.id}`,
+        message: "Multiple exact allocation targets match the source exposure",
+      });
+  } else if (input.definition.allocation.kind === "supplied-weights") {
+    const weightId = input.definition.allocation.weightMeasureId;
+    const weighted = matching.map((target) => ({ target, weight: target.weights?.[weightId] }));
+    if (weighted.some(({ weight }) => weight === undefined || !Number.isFinite(weight) || weight < 0))
+      findings.push({
+        code: "missing-prerequisite",
+        capability: "exposure-earning",
+        path: `$.targets.weights.${weightId}`,
+        message: "Supplied-weight allocation requires finite nonnegative weights on every matching target",
+        requiredFields: [`weights.${weightId}`],
+      });
+    else {
+      const total = weighted.reduce((sum, item) => sum + item.weight!, 0);
+      if (!(total > 0))
+        findings.push({
+          code: "missing-prerequisite",
+          capability: "exposure-earning",
+          path: `$.targets.weights.${weightId}`,
+          message: "Supplied allocation weights must have a positive total",
+        });
+      else
+        allocations = weighted.map(({ target, weight }) => ({
+          sourceObservationId: input.observation.id,
+          targetId: target.id,
+          value: value * (weight! / total),
+          method: "supplied-weights" as const,
+          overlapDays: null,
+        }));
+    }
+  } else {
+    const sourceDays = daysBetweenIsoDates(sourceStart, sourceEnd);
+    const overlaps = matching
+      .map((target) => ({ target, days: overlapDays(sourceStart, sourceEnd, target.startDate, target.endDate) }))
+      .filter(({ days }) => days > 0);
+    if (overlaps.reduce((total, item) => total + item.days, 0) > sourceDays) {
+      findings.push({
+        code: "ambiguous-attribution",
+        capability: "exposure-earning",
+        path: `$.exposures.${input.observation.id}`,
+        message: "Overlapping allocation targets would duplicate source exposure",
+      });
+    } else
+    if (
+      input.definition.sourceMeaning === "already-earned" ||
+      input.definition.earning.kind === "supplied"
+    )
+      findings.push({
+        code: "unsupported-operation",
+        capability: "exposure-earning",
+        path: `$.exposures.${input.observation.id}`,
+        message: "Already-earned/supplied exposure requires exact matching or supplied allocation weights",
+      });
+    else if (input.definition.earning.kind === "weighted") {
+      const weightId = input.definition.earning.scheduleId;
+      const weighted = overlaps.map(({ target, days }) => ({
+        target,
+        days,
+        weight: target.weights?.[weightId],
+      }));
+      if (weighted.some(({ weight }) => weight === undefined || !Number.isFinite(weight) || weight < 0))
+        findings.push({
+          code: "missing-prerequisite",
+          capability: "exposure-earning",
+          path: `$.targets.weights.${weightId}`,
+          message: "Weighted earning requires finite nonnegative schedule weights on every overlapping target",
+          requiredFields: [`weights.${weightId}`],
+        });
+      else {
+        const total = weighted.reduce((sum, item) => sum + item.weight!, 0);
+        if (!(total > 0))
+          findings.push({
+            code: "missing-prerequisite",
+            capability: "exposure-earning",
+            path: `$.targets.weights.${weightId}`,
+            message: "Weighted earning schedule must have a positive total",
+          });
+        else
+          allocations = weighted.map(({ target, days, weight }) => ({
+            sourceObservationId: input.observation.id,
+            targetId: target.id,
+            value: value * (weight! / total),
+            method: "weighted-schedule" as const,
+            overlapDays: days,
+          }));
+      }
+    } else
+      allocations = overlaps.map(({ target, days }) => ({
+        sourceObservationId: input.observation.id,
+        targetId: target.id,
+        value: value * (days / sourceDays),
+        method:
+          input.definition.earning.kind === "uniform-daily"
+            ? ("uniform-daily" as const)
+            : ("time-overlap" as const),
+        overlapDays: days,
+      }));
+  }
+  allocations.sort((left, right) => compareText(left.targetId, right.targetId));
+  const allocatedValue = allocations.reduce((sum, allocation) => sum + allocation.value, 0);
+  let unallocatedValue = value - allocatedValue;
+  const tolerance = Math.max(1, Math.abs(value)) * Number.EPSILON * 8;
+  if (Math.abs(unallocatedValue) <= tolerance) unallocatedValue = 0;
+  if (unallocatedValue !== 0)
+    findings.push({
+      code: "missing-prerequisite",
+      capability: "exposure-earning",
+      path: `$.exposures.${input.observation.id}`,
+      message: `Exposure leaves ${unallocatedValue} ${input.definition.unit} unallocated`,
+    });
+  return snapshotDiagnosticJson({
+    measureId: input.definition.id,
+    sourceValue: value,
+    allocations,
+    allocatedValue,
+    unallocatedValue,
+    findings,
+  });
+}